#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,O3")
#pragma GCC target("avx,avx2")
#include "garden.h"
#include "gardenlib.h"
using namespace std;
void count_routes(int N, int M, int P, int R[][2], int Q, int G[]) {
const int INF = (int) 1e9;
vector<vector<int>> edges(N);
for (int i = 0; i < M; ++i) {
edges[R[i][0]].push_back(R[i][1]);
edges[R[i][1]].push_back(R[i][0]);
}
vector<int> next(2 * N, -1);
for (int i = 0; i < N; ++i) {
int x = edges[i][0];
next[2 * i] = (i == edges[x][0] ? 2 * x + 1 : 2 * x);
x = ((int) edges[i].size() == 1 ? edges[i][0] : edges[i][1]);
next[2 * i + 1] = (i == edges[x][0] ? 2 * x + 1 : 2 * x);
}
vector<vector<int>> pred(2 * N);
for (int i = 0; i < 2 * N; ++i) {
pred[next[i]].push_back(i);
}
vector<bool> visited(2 * N, false), active(2 * N, false);
vector<int> st, cyc_sz(2 * N, 0), cyc_dist(2 * N, INF), elem(2 * N, -1),
cyc_root(2 * N, -1), cyc_id(2 * N, -1);
int cycles = -1, start = 0;
function<void(int)> dfs = [&](int node) {
if (active[node]) {
++cycles;
int sz = (int) st.size();
int bgn = 0;
while (st[bgn] != node) {
++bgn;
}
sz -= bgn;
for (int i = bgn; i < (int) st.size(); ++i) {
cyc_id[st[i]] = i - bgn;
cyc_sz[st[i]] = sz;
cyc_dist[st[i]] = 0;
cyc_root[st[i]] = st[i];
elem[st[i]] = cycles;
}
}
if (visited[node]) {
return;
}
visited[node] = true;
active[node] = true;
st.push_back(node);
dfs(next[node]);
active[node] = false;
st.pop_back();
};
vector<vector<int>> anc(20, vector<int>(2 * N, -1));
function<void(int, int)> tree_dfs = [&](int node, int root) -> void {
for (auto x : pred[node]) {
cyc_dist[x] = cyc_dist[node] + 1;
anc[0][x] = node;
elem[x] = elem[root];
tree_dfs(x, root);
}
};
for (start = 0; start < 2 * N; start += 2) {
if (!visited[start]) {
dfs(start);
}
}
for (int i = 0; i < 2 * N; ++i) {
if (cyc_dist[i] == INF && cyc_dist[next[i]] == 0) {
cyc_dist[i] = 1;
anc[0][i] = next[i];
elem[i] = elem[next[i]];
tree_dfs(i, i);
}
}
for (int j = 1; j < 20; ++j) {
for (int i = 0; i < 2 * N; ++i) {
if (anc[j - 1][i] == -1) continue;
anc[j][i] = anc[j - 1][anc[j - 1][i]];
}
}
auto get = [&](int i, int k) {
for (int j = 19; j >= 0; --j) {
if (k >= 1 << j) {
i = anc[j][i];
k -= 1 << j;
}
}
return i;
};
for (int j = 0; j < Q; ++j) {
int k = G[j], cnt = 0;
for (int i = 0; i < N; ++i) {
for (int p = 2 * P; p <= 2 * P + 1; ++p) {
int node = 2 * i, dist = 0;
if (elem[node] != elem[p]) continue;
if (cyc_dist[node] != 0 && cyc_dist[p] <= cyc_dist[node]
&& cyc_root[p] == cyc_root[node]) {
dist = cyc_dist[node] - cyc_dist[p];
if (dist == k && get(node, dist) == p) {
++cnt;
}
continue;
} else if (cyc_dist[p] > cyc_dist[node] ||
(cyc_dist[p] != 0 && cyc_root[p] != cyc_root[node])) {
continue;
} else if (cyc_dist[node] != 0) {
dist += cyc_dist[node];
node = next[cyc_root[node]];
}
dist += (cyc_id[p] >= cyc_id[node] ? cyc_id[p] - cyc_id[node]
: cyc_sz[node] - cyc_id[node] + cyc_id[p]);
if (k >= dist && dist % cyc_sz[node] == k % cyc_sz[node]) {
++cnt;
}
}
}
answer(cnt);
}
}
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
1 ms |
724 KB |
Output is correct |
| 2 |
Correct |
1 ms |
596 KB |
Output is correct |
| 3 |
Correct |
1 ms |
768 KB |
Output is correct |
| 4 |
Runtime error |
1 ms |
468 KB |
Execution killed with signal 8 |
| 5 |
Halted |
0 ms |
0 KB |
- |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
1 ms |
724 KB |
Output is correct |
| 2 |
Correct |
1 ms |
596 KB |
Output is correct |
| 3 |
Correct |
1 ms |
768 KB |
Output is correct |
| 4 |
Runtime error |
1 ms |
468 KB |
Execution killed with signal 8 |
| 5 |
Halted |
0 ms |
0 KB |
- |
| # |
결과 |
실행 시간 |
메모리 |
Grader output |
| 1 |
Correct |
1 ms |
724 KB |
Output is correct |
| 2 |
Correct |
1 ms |
596 KB |
Output is correct |
| 3 |
Correct |
1 ms |
768 KB |
Output is correct |
| 4 |
Runtime error |
1 ms |
468 KB |
Execution killed with signal 8 |
| 5 |
Halted |
0 ms |
0 KB |
- |
