text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
ofstream out("biconex.out");
ifstream in("biconex.in");
struct Edge {
int node;
bool is_critic;
};
const int N_MAX = 100000;
vector<Edge> neighbours[1 + N_MAX];
stack<int> component;
int n, m, h, minim = N_MAX + 1, node_ans, Depth, root_sons, depth[1 + N_MAX],
height[1 + N_MAX], main_hour[1 + N_MAX], color[1 + N_MAX];
bool visited[1 + N_MAX], not_in_subgraph[1 + N_MAX], is_critic[1 + N_MAX],
on_stack[1 + N_MAX];
void read() {
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> main_hour[i];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if (main_hour[x] - main_hour[y] == 1 |
(main_hour[x] == 0 & main_hour[y] == h - 1))
neighbours[y].push_back({x, false});
if (main_hour[y] - main_hour[x] == 1 |
(main_hour[y] == 0 & main_hour[x] == h - 1))
neighbours[x].push_back({y, false});
}
for (int i = 1; i <= n; i++) depth[i] = -1;
}
void DFS(int node, int root) {
depth[node] = height[node] = Depth;
component.push(node);
on_stack[node] = true;
Depth++;
for (Edge& son : neighbours[node]) {
if (depth[son.node] == -1) {
DFS(son.node, root);
height[node] = min(height[node], height[son.node]);
} else if (on_stack[son.node])
height[node] = min(height[node], depth[son.node]);
}
if (height[node] == depth[node]) {
int son;
do {
son = component.top();
color[son] = node;
component.pop();
on_stack[son] = false;
} while (son != node);
}
}
int DFS2(int node, int cnt, bool possible_ans) {
cnt++;
visited[node] = true;
for (Edge son : neighbours[node]) {
if (color[node] != color[son.node]) {
possible_ans = false;
continue;
}
if (visited[son.node]) continue;
cnt = DFS2(son.node, cnt, possible_ans);
if (!cnt) possible_ans = false;
}
if (!possible_ans) cnt = 0;
return cnt;
}
void solution() {
for (int i = 1; i <= n; i++)
if (depth[i] == -1) DFS(i, i);
for (int i = 1; i <= n; i++) visited[i] = false;
for (int i = 1; i <= n; i++) {
if (visited[i]) continue;
int cnt = DFS2(i, 0, true);
if (cnt)
if (minim > cnt) {
minim = cnt;
node_ans = i;
}
}
}
void DFS_print(int node) {
cout << node << " ";
visited[node] = true;
for (Edge son : neighbours[node]) {
if (!visited[son.node]) DFS_print(son.node);
}
}
void print() {
cout << minim << "\n";
for (int i = 1; i <= n; i++) visited[i] = false;
DFS_print(node_ans);
}
int main() {
read();
solution();
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
vector<int> b[N];
int n, m, ecnt, h, a[N], ft[N], cnt, dfn[N], low[N], stk[N], top, bl[N], num,
sz[N], d[N];
bool vis[N];
struct edge {
int nxt, to;
} e[N << 1];
void dfs(int x) {
dfn[x] = low[x] = ++cnt;
vis[x] = 1;
stk[top++] = x;
for (int i = ft[x]; i; i = e[i].nxt)
if (!dfn[e[i].to]) {
dfs(e[i].to);
low[x] = min(low[x], low[e[i].to]);
} else if (vis[e[i].to])
low[x] = min(low[x], dfn[e[i].to]);
if (low[x] == dfn[x]) {
while (1) {
int u = stk[--top];
vis[u] = 0;
bl[u] = num;
sz[num]++;
b[num].push_back(u);
if (u == x) break;
}
num++;
}
}
void add(int x, int y) {
ecnt++;
e[ecnt] = (edge){ft[x], y};
ft[x] = ecnt;
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
if ((a[x] + 1) % h == a[y]) add(x, y);
if ((a[y] + 1) % h == a[x]) add(y, x);
}
for (int i = 0; i < n; i++)
if (!dfn[i]) dfs(i);
for (int i = 0; i < n; i++)
for (int j = ft[i]; j; j = e[j].nxt)
if (bl[i] != bl[e[j].to]) d[bl[i]]++;
int ans = n, f = 0;
for (int i = 0; i < num; i++)
if (!d[i] && sz[i] < ans) {
ans = sz[i];
f = i;
}
printf("%d\n", ans);
sort(b[f].begin(), b[f].end());
for (int i = 0; i < ans; i++) printf("%d ", b[f][i] + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 2e6 + 9;
int scc[MAXN], a[MAXN], out[MAXN];
int id;
vector<bool> used;
vector<int> order;
vector<vector<int>> g, gr, c;
void dfs1(int node) {
used[node] = true;
for (auto child : g[node]) {
if (!used[child]) dfs1(child);
}
order.push_back(node);
}
void dfs2(int node) {
used[node] = true;
c[id].push_back(node);
for (auto child : gr[node])
if (!used[child]) dfs2(child);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, m, h;
cin >> n >> m >> h;
used.assign(n + 1, false);
c.resize(n + 1);
g.resize(n + 1);
gr.resize(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
if (a[u] < a[v]) swap(u, v);
if (a[u] - a[v] == 1) {
g[v].push_back(u);
gr[u].push_back(v);
}
if (a[u] == h - 1 && a[v] == 0) {
g[u].push_back(v);
gr[v].push_back(u);
}
}
for (int i = 1; i <= n; i++)
if (!used[i]) dfs1(i);
used.assign(n + 1, false);
reverse(order.begin(), order.end());
for (auto cur : order) {
if (!used[cur]) {
dfs2(cur);
for (auto x : c[id]) scc[x] = id;
id++;
}
}
for (int i = 1; i <= n; i++) {
for (auto child : g[i]) {
if (scc[i] != scc[child]) {
out[scc[i]]++;
}
}
}
vector<int> ans;
for (int i = 0; i < id; i++) {
if (out[i] == 0) {
if (ans.size() == 0 or (int) ans.size() > (int)c[i].size()) ans = c[i];
}
}
cout << ans.size() << "\n";
for (auto cur : ans) cout << cur << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 50;
int n, m, h, value[maxn];
int dfn[maxn], low[maxn], Stack[maxn], top, cnt, tot, belong[maxn];
int sum[maxn];
bool instack[maxn];
vector<int> G[maxn];
vector<int> ans[maxn];
inline void dfs(int x) {
dfn[x] = low[x] = ++cnt;
Stack[++top] = x;
instack[x] = true;
for (unsigned i = 0; i < G[x].size(); ++i) {
int v = G[x][i];
if (dfn[v] == 0) {
dfs(v);
low[x] = min(low[x], low[v]);
} else if (instack[v])
low[x] = min(low[x], dfn[v]);
}
if (low[x] == dfn[x]) {
++tot;
int v = Stack[top];
while (v != x) {
instack[v] = false;
--top;
belong[v] = tot;
v = Stack[top];
}
instack[v] = false;
--top;
belong[v] = tot;
}
}
inline bool check(int opt) {
for (unsigned i = 0; i < ans[opt].size(); ++i) {
int v = ans[opt][i];
for (unsigned j = 0; j < G[v].size(); ++j) {
int toit = G[v][j];
if (belong[toit] == opt) continue;
return false;
}
}
return true;
}
int main(void) {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) scanf("%d", &value[i]);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
if ((value[u] + 1) % h == value[v]) G[u].push_back(v);
if ((value[v] + 1) % h == value[u]) G[v].push_back(u);
}
cnt = 0;
tot = 1;
for (int i = 1; i <= n; ++i)
if (dfn[i] == 0) {
cnt = 0;
top = 0;
dfs(i);
}
for (int i = 1; i <= n; ++i) ++sum[belong[i]], ans[belong[i]].push_back(i);
int Min = n + 1, pos = -1;
for (int i = 1; i <= n; ++i)
if (sum[i] < Min && sum[i] != 0 && check(i)) {
Min = sum[i];
pos = i;
}
printf("%d\n", Min);
for (int i = 1; i <= n; ++i)
if (belong[i] == pos) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-10;
template <typename A, typename B>
inline void chmin(A& a, B b) {
if (a > b) a = b;
}
template <typename A, typename B>
inline void chmax(A& a, B b) {
if (a < b) a = b;
}
const int32 DIRECTED = 0;
const int32 UNDIRECTED = 1;
template <int32 isUNDIRECTED = 0>
class Graph {
struct Edge {
int32 u, v, id;
int64 c;
Edge(int32 u, int32 v, int64 c = 0, int32 id = 0)
: u(u), v(v), c(c), id(id) {}
};
int32 V, E;
vector<vector<Edge>> G;
vector<Edge> Es;
public:
Graph() {}
Graph(int32 V) : V(V) { G.resize(V); }
Graph(const Graph<isUNDIRECTED>& g) : V(g.V), E(g.E), G(g.G), Es(g.Es) {}
void add_edge(int32 u, int32 v, int64 c = 0, int32 id = 0) {
G[u].emplace_back(u, v, c, id);
if (isUNDIRECTED) G[v].emplace_back(v, u, c, id);
Es.emplace_back(u, v, c, id);
E++;
}
const vector<Edge>& operator[](int32 k) { return G[k]; }
};
class SCC {
private:
Graph<DIRECTED> orgG, revG, newG;
vector<int32> ord, comp;
vector<bool> used;
vector<vector<int32>> vs;
int32 V, nV;
public:
SCC() {}
SCC(int32 V) : orgG(V), revG(V), comp(V, -1), used(V, 0), V(V) {}
void add_edge(int32 u, int32 v) {
orgG.add_edge(u, v);
revG.add_edge(v, u);
}
void dfs(int32 v) {
used[v] = true;
for (auto e : orgG[v]) {
if (!used[e.v]) dfs(e.v);
}
ord.push_back(v);
}
void rdfs(int32 v, int32 k) {
used[v] = true;
comp[v] = k;
for (auto e : revG[v]) {
if (!used[e.v]) rdfs(e.v, k);
}
}
int32 build() {
for (int32 i = 0; i < V; i++) {
if (!used[i]) dfs(i);
}
fill(used.begin(), used.end(), 0);
int32 k = 0;
for (int32 i = ord.size() - 1; i >= 0; i--) {
if (!used[ord[i]]) rdfs(ord[i], k++);
}
nV = k;
vs.resize(k, vector<int32>());
for (int32 i = 0; i < V; i++) vs[comp[i]].push_back(i);
newG = Graph<DIRECTED>(k);
for (int32 i = 0; i < V; i++) {
for (auto e : orgG[i]) {
if (comp[i] != comp[e.v]) newG.add_edge(comp[i], comp[e.v], e.c);
}
}
return k;
}
int32 size() { return nV; }
const Graph<DIRECTED>& graph() { return newG; }
const vector<int32>& vertices(int32 v) { return vs[v]; }
int32 operator[](int32 k) { return comp[k]; }
};
SCC scc;
int32 n, m, h;
int32 u[112345];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> h;
for (int i = 0; i < (n); i++) cin >> u[i];
scc = SCC(2 * n);
for (int i = 0; i < (n); i++) {
scc.add_edge(i, i + n);
}
for (int i = 0; i < (m); i++) {
int32 a, b;
cin >> a >> b;
a--;
b--;
if ((u[a] + 1) % h == u[b]) scc.add_edge(a + n, b);
if ((u[b] + 1) % h == u[a]) scc.add_edge(b + n, a);
}
scc.build();
Graph<DIRECTED> G = scc.graph();
vector<bool> visited(scc.size(), 0);
vector<int32> dp(scc.size(), -1);
int32 res_s = (int)1e9;
vector<int32> res;
function<void(int32)> dfs = [&](int32 v) {
if (G[v].size() == 0) {
vector<int32> a = scc.vertices(v);
if (res_s > a.size()) {
res_s = a.size();
res = a;
}
return;
}
for (auto e : G[v]) {
if (!visited[e.v]) {
visited[e.v] = 1;
dfs(e.v);
}
}
};
for (int i = 0; i < (scc.size()); i++) {
if (!visited[i]) {
dfs(i);
}
}
cout << (res.size() + res.size() % 2) / 2 << endl;
for (int i = 0; i < (res.size()); i++) {
if (res[i] >= n) cout << res[i] - n + 1 << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100001;
const int MAXM = 100001;
vector<int> G[MAXN];
int dfn[MAXN], low[MAXN], tim;
int scc[MAXN], size[MAXN], num, minsize = 99999999;
int t[MAXN], du[MAXN];
bool vis[MAXN];
stack<int> S;
void Tarjan(int u) {
dfn[u] = low[u] = ++tim;
S.push(u), vis[u] = true;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (!dfn[v]) {
Tarjan(v);
low[u] = min(low[u], low[v]);
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
num++;
while (1) {
int x = S.top();
S.pop();
scc[x] = num;
size[num]++;
if (x == u) break;
}
}
}
int main() {
int n, m, h, rec;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if ((t[u] + 1) % h == t[v]) G[u].push_back(v);
if ((t[v] + 1) % h == t[u]) G[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) Tarjan(i);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < G[i].size(); j++) {
int x = G[i][j];
if (scc[x] != scc[i]) {
du[scc[i]]++;
}
}
}
for (int i = 1; i <= n; i++) {
if (!du[scc[i]] && size[scc[i]] < minsize) {
minsize = size[scc[i]];
rec = scc[i];
}
}
printf("%d\n", minsize);
for (int i = 1; i <= n; i++) {
if (scc[i] == rec) printf("%d ", i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gotcha() {
int a = 0, b = 1, c = getchar();
while (!isdigit(c)) b ^= c == '-', c = getchar();
while (isdigit(c)) a = a * 10 + c - 48, c = getchar();
return b ? a : -a;
}
const int _ = 100002, __ = _ << 1;
struct edge {
int to[__], ne[__], he[_], ecnt;
edge() { memset(he, 0, sizeof(he)), ecnt = 1; }
void adde(int a, int b) { to[++ecnt] = b, ne[ecnt] = he[a], he[a] = ecnt; }
} e;
int dfn[_] = {0}, low[_] = {0}, cnt = 0, sta[_], lst = 0;
int co[_], cocnt = 0, du[_] = {0};
bool ed[_] = {0};
vector<int> col[_];
void tarjan(int now) {
dfn[now] = low[now] = ++cnt;
sta[++lst] = now, ed[now] = 1;
int i, b;
for (i = e.he[now]; i; i = e.ne[i]) {
b = e.to[i];
if (!dfn[b])
tarjan(b), low[now] = min(low[now], low[b]);
else if (ed[b])
low[now] = min(low[now], dfn[b]);
}
if (low[now] == dfn[now]) {
cocnt++, ed[now] = 0;
while (sta[lst + 1] != now) {
co[sta[lst]] = cocnt;
col[cocnt].push_back(sta[lst]);
ed[sta[lst--]] = 0;
}
}
}
int n, m, hr, un[_];
int main() {
int i, j, k, a, b, mi, miloc;
n = gotcha(), m = gotcha(), hr = gotcha();
mi = n + 1, miloc = 0;
for (i = 1; i <= n; i++) un[i] = gotcha();
for (i = 1; i <= m; i++) {
a = gotcha(), b = gotcha();
if (un[a] == (un[b] + 1) % hr) e.adde(a, b);
if (un[b] == (un[a] + 1) % hr) e.adde(b, a);
}
for (i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (i = 1; i <= n; i++)
for (j = e.he[i]; j; j = e.ne[j]) {
k = e.to[j];
if (co[i] != co[k]) du[co[k]]++;
}
for (i = 1; i <= cocnt; i++) {
if (!du[i]) {
a = col[i].size();
if (a < mi) mi = a, miloc = i;
}
}
sort(col[miloc].begin(), col[miloc].end());
printf("%d\n", mi);
for (i = 0; i < mi; i++) printf("%d ", col[miloc][i]);
return 0;
}
|
#include <bits/stdc++.h>
using pii = std::pair<int, int>;
using pll = std::pair<long long, long long>;
const int maxn = 1e5 + 100;
std::vector<int> v[maxn], rev[maxn];
inline void add_edge(int i, int j) {
v[i].push_back(j);
rev[j].push_back(i);
}
int component[maxn];
std::vector<int> in_component[maxn];
std::vector<int> sorted;
char seen[maxn];
void sort_down(int x) {
seen[x] = 1;
for (int y : v[x])
if (!seen[y]) sort_down(y);
sorted.push_back(x);
}
char seen2[maxn];
void enumerate_component(int x, int cur) {
seen2[x] = 1;
component[x] = cur;
in_component[cur].push_back(x);
for (int y : rev[x])
if (!seen2[y]) enumerate_component(y, cur);
}
int u[maxn], c1[maxn], c2[maxn];
int output[maxn];
int main() {
int n = 5;
std::ios::sync_with_stdio(false);
int m, h;
std::cin >> n >> m >> h;
for (int i = 0; i < n; i++) std::cin >> u[i + 1];
for (int i = 0; i < m; i++) {
std::cin >> c1[i] >> c2[i];
if (u[c1[i]] > u[c2[i]]) std::swap(c1[i], c2[i]);
int t1 = u[c1[i]];
int t2 = u[c2[i]];
if (t2 == t1 + 1) {
add_edge(c1[i], c2[i]);
}
if (t2 == h - 1 && t1 == 0) {
add_edge(c2[i], c1[i]);
}
}
for (int i = 1; i <= n; i++)
if (!seen[i]) sort_down(i);
for (int i = n; i >= 1; i--)
if (!seen2[sorted[i - 1]]) enumerate_component(sorted[i - 1], i);
for (int i = 1; i <= n; i++)
for (int j : v[i])
if (component[i] != component[j]) output[component[i]]++;
pii ans = {0x3f3f3f3f, 0};
for (int i = 1; i <= n; i++) {
if (in_component[i].size() && output[i] == 0)
ans = std::min(ans, {in_component[i].size(), i});
}
std::cout << ans.first << "\n";
for (auto y : in_component[ans.second]) std::cout << y << " ";
std::cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int MOD = 1000000007;
const int UNDEF = -1;
const int INF = 1 << 30;
template <typename T>
inline bool chkmax(T &aa, T bb) {
return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T &aa, T bb) {
return aa > bb ? aa = bb, true : false;
}
int rint();
char rch();
long long rlong();
class SCC {
static const int N = 1e5 + 4;
public:
vector<int> g[N];
int scc[N], nsc, low[N], num[N], mn, st[N], sz;
void dfs(int p) {
low[p] = num[p] = mn++;
st[sz++] = p;
for (int i : g[p])
if (scc[i] == -1) {
if (num[i] == -1) dfs(i);
low[p] = min(low[p], low[i]);
}
if (low[p] == num[p]) {
while (scc[p] != nsc) scc[st[--sz]] = nsc;
++nsc;
}
}
int get_scc(int n) {
memset(num, -1, sizeof num);
memset(scc, -1, sizeof scc);
nsc = mn = sz = 0;
for (int i = 1; i <= n; ++i)
if (num[i] == -1) dfs(i);
return nsc;
}
int vcnt[N];
void getCount(int n) {
for (int x = 1; x <= n; x++) vcnt[scc[x]]++;
}
vector<int> sccid2vtx[N];
set<int> sccGraph[N];
int condensation(int n) {
for (int x = 1; x <= n; x++) sccid2vtx[scc[x]].push_back(x);
for (int x = 1; x <= n; x++) {
for (auto &y : g[x]) {
if (scc[y] != scc[x]) sccGraph[scc[x]].insert(scc[y]);
}
}
return nsc;
}
};
SCC cs;
const int mn = 1e5 + 4;
set<int> gg[mn];
int u[mn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n = rint(), m = rint(), h = rint();
for (int c = 1; c <= n; c++) {
u[c] = rint();
}
for (int i = 0; i < m; i++) {
int a = rint(), b = rint();
if (u[b] == (u[a] + 1) % h) {
gg[a].insert(b);
}
if (u[a] == (u[b] + 1) % h) {
gg[b].insert(a);
}
}
for (int x = 1; x <= n; x++) {
for (auto &y : gg[x]) cs.g[x].push_back(y);
}
cs.get_scc(n);
int nsc = cs.condensation(n);
pair<int, int> ans = make_pair(INF, INF);
for (int sccid = 0; sccid < nsc; sccid++) {
if (cs.sccGraph[sccid].size() == 0) {
chkmin(ans, make_pair((int)cs.sccid2vtx[sccid].size(), sccid));
}
}
printf("%d\n", ans.first);
for (auto &w : cs.sccid2vtx[ans.second]) {
printf("%d ", w);
}
}
static char stdinBuffer[1024];
static char *stdinDataEnd = stdinBuffer + sizeof(stdinBuffer);
static const char *stdinPos = stdinDataEnd;
void readAhead(size_t amount) {
size_t remaining = stdinDataEnd - stdinPos;
if (remaining < amount) {
memmove(stdinBuffer, stdinPos, remaining);
size_t sz = fread(stdinBuffer + remaining, 1,
sizeof(stdinBuffer) - remaining, stdin);
stdinPos = stdinBuffer;
stdinDataEnd = stdinBuffer + remaining + sz;
if (stdinDataEnd != stdinBuffer + sizeof(stdinBuffer)) *stdinDataEnd = 0;
}
}
int rint() {
readAhead(16);
int x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
char rch() {
readAhead(16);
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
char ans = *stdinPos;
++stdinPos;
return ans;
}
long long rlong() {
readAhead(32);
long long x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
using namespace std;
const long long inf = numeric_limits<long long>::max() / 2;
const long double eps = 1e-9;
const long double pi = acos(-1);
struct graph {
long long vn;
vector<set<long long> > es;
graph() {}
graph(long long v) {
vn = v;
es.resize(vn + 1);
}
void insert(long long v, long long u) { es[v].insert(u); }
};
long long N, M, H;
graph g, gt;
vector<long long> u;
vector<long long> tsort;
vector<bool> used;
void dfs(long long v) {
used[v] = true;
for (long long u : g.es[v]) {
if (used[u]) {
continue;
}
dfs(u);
}
tsort.push_back(v);
}
vector<vector<long long> > cs;
vector<long long> color;
void dfs2(long long v, long long c) {
used[v] = true;
cs.back().push_back(v);
color[v] = c;
for (long long u : gt.es[v]) {
if (used[u]) {
continue;
}
dfs2(u, c);
}
}
void solve() {
used.assign(g.vn + 1, false);
for (long long i = 1; i <= g.vn; i++) {
if (!used[i]) {
dfs(i);
}
}
reverse((tsort).begin(), (tsort).end());
used.assign(g.vn + 1, false);
color.assign(g.vn + 1, -1);
long long c = 0;
for (long long v : tsort) {
if (!used[v]) {
cs.push_back({});
dfs2(v, c);
++c;
}
}
vector<long long> ind;
for (long long i = 0; i < c; i++) {
bool ok = true;
for (long long v : cs[i]) {
for (long long u : g.es[v]) {
if (color[u] != i) {
ok = false;
}
}
}
if (ok) {
ind.push_back(i);
}
}
long long minn = ind[0];
for (long long i : ind) {
if ((long long)((cs[i]).size()) < (long long)((cs[minn]).size())) {
minn = i;
}
}
cout << (long long)((cs[minn]).size()) << "\n";
for (long long v : cs[minn]) {
cout << v << " ";
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> N >> M >> H;
u.resize(N + 1);
for (long long i = 1; i <= N; i++) {
cin >> u[i];
}
g = graph(N);
gt = graph(N);
for (long long i = 0; i < M; i++) {
long long c1, c2;
cin >> c1 >> c2;
long long h1, h2;
h1 = u[c1], h2 = u[c2];
if (u[c1] == 0) {
h1 = H;
}
if (h1 - h2 == 1) {
g.insert(c2, c1);
gt.insert(c1, c2);
}
h1 = u[c1], h2 = u[c2];
if (u[c2] == 0) {
h2 = H;
}
if (h2 - h1 == 1) {
g.insert(c1, c2);
gt.insert(c2, c1);
}
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)(2e5) + 2;
const int MOD = (int)(1e9) + 7;
vector<int> g[MAXN], gr[MAXN], cg[MAXN], hg[MAXN], ord;
bool used[MAXN];
int n, m, h, a[MAXN], k;
void dfs(int v) {
used[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!used[to]) dfs(to);
}
ord.push_back(v);
}
int col[MAXN];
vector<int> vec[MAXN];
void dfs1(int v) {
used[v] = 1;
col[v] = k;
vec[k].push_back(v);
for (int i = 0; i < gr[v].size(); i++) {
int to = gr[v][i];
if (!used[to]) dfs1(to);
}
}
map<pair<int, int>, bool> e;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
if (e[make_pair(u, v)]) continue;
e[make_pair(u, v)] = e[make_pair(v, u)] = 1;
hg[v].push_back(u);
hg[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < hg[i].size(); j++) {
if (a[i] + 1 == a[hg[i][j]] || (a[i] == h - 1 && a[hg[i][j]] == 0)) {
g[i].push_back(hg[i][j]);
gr[hg[i][j]].push_back(i);
}
}
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs(i);
}
}
memset(used, 0, sizeof used);
for (int i = ord.size() - 1; i >= 0; i--) {
int v = ord[i];
if (!used[v]) {
k++;
dfs1(v);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
if (col[i] != col[g[i][j]]) cg[col[i]].push_back(col[g[i][j]]);
}
}
int mn = MOD;
int id = -1;
for (int i = 1; i <= k; i++) {
if (cg[i].empty()) {
if (mn > vec[i].size()) {
mn = vec[i].size();
id = i;
}
}
}
cout << vec[id].size() << endl;
for (int i = 0; i < vec[id].size(); i++) cout << vec[id][i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double EPS = 1e-10;
const int N = 100010;
int n, m, h;
vector<int> adjList[2][N];
int color[N];
int low[N], num[N];
stack<int> dfsStack;
vector<vector<int>> comps;
int compIndex[N];
set<int> adjComp[N];
void dfs(int u) {
static int dfsCounter = 0;
low[u] = num[u] = ++dfsCounter;
dfsStack.push(u);
for (int v : adjList[1][u]) {
if (num[v]) {
low[u] = min(low[u], num[v]);
} else {
dfs(v);
low[u] = min(low[u], low[v]);
}
}
if (low[u] >= num[u]) {
vector<int> newComp;
int v;
do {
v = dfsStack.top();
dfsStack.pop();
newComp.push_back(v);
compIndex[v] = (int)comps.size();
low[v] = num[v] = INF;
} while (v != u);
comps.push_back(newComp);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> h;
for (int i = 0; i < n; ++i) {
cin >> color[i];
}
while (m--) {
int u, v;
cin >> u >> v;
adjList[0][u - 1].push_back(v - 1);
adjList[0][v - 1].push_back(u - 1);
}
for (int i = 0; i < n; ++i) {
for (int j : adjList[0][i]) {
if ((color[i] + 1) % h == color[j]) {
adjList[1][i].push_back(j);
}
}
}
for (int i = 0; i < n; ++i) {
if (!num[i]) {
dfs(i);
}
}
for (int i = 0; i < n; ++i) {
for (int j : adjList[1][i]) {
if (compIndex[i] != compIndex[j]) {
adjComp[compIndex[i]].insert(compIndex[j]);
}
}
}
int res = INF;
for (int i = 0; i < (int)comps.size(); ++i) {
if (adjComp[i].empty()) {
res = min(res, (int)comps[i].size());
}
}
cout << res << '\n';
for (auto comp : comps) {
if ((int)comp.size() == res) {
for (int v : comp) {
cout << v + 1 << ' ';
}
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 5;
vector<int> V[N];
int D[N], low[N], T, H[N], Sc[N], scc, sz[N], ok[N], A[N], n, m, h, x, y, i,
ans;
stack<int> S;
void f(int x) {
low[x] = D[x] = ++T;
S.push(x);
H[x] = 1;
for (auto y : V[x]) {
if (!D[y])
f(y), low[x] = min(low[x], low[y]);
else if (H[y])
low[x] = min(low[x], D[y]);
}
if (low[x] == D[x]) {
scc++;
for (int y = 0; y != x;) {
y = S.top();
S.pop();
H[y] = 0;
Sc[y] = scc;
sz[scc]++;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (i = 1; i <= n; i++) scanf("%d", &A[i]);
for (; m--;) {
scanf("%d%d", &x, &y);
if ((A[x] + 1) % h == A[y]) V[x].push_back(y);
if ((A[y] + 1) % h == A[x]) V[y].push_back(x);
}
for (i = 1; i <= n; i++)
if (!D[i]) f(i);
for (x = 1; x <= n; x++)
for (auto y : V[x])
if (Sc[x] != Sc[y]) ok[Sc[x]] = -1;
sz[ans = 0] = N;
for (i = 1; i <= scc; i++)
if (sz[ans] > sz[i] && !ok[i]) ans = i;
cout << sz[ans] << endl;
for (i = 1; i <= n; i++)
if (Sc[i] == ans) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T x, T y) {
if (x < y) swap(x, y);
while (y > 0) {
T f = x % y;
x = y;
y = f;
}
return x;
}
void exgcd(long long a, long long b, long long &d, long long &x, long long &y) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
long long inv(long long a, long long m) {
long long x, y, d;
exgcd(a, m, d, x, y);
return d == 1 ? ((x % m) + m) % m : -1;
}
const int maxn = 1e5 + 7;
const int maxm = 1e5 + 7;
const int maxh = 1e5 + 7;
int n, m, h;
int u[maxh];
set<int> sadj[maxn];
vector<int> adj[maxn];
int vs[maxn];
int inDeg[maxn];
int cnt[maxn];
int S;
int tj_low_link[maxn];
int tj_index[maxn];
int tj_inS[maxn];
int tj_idx;
vector<int> tj_S;
vector<int> tj_res;
void dfs(int u) {
tj_index[u] = tj_idx;
tj_low_link[u] = tj_idx;
tj_idx++;
tj_S.push_back(u);
tj_inS[u] = 1;
for (int v : adj[u]) {
if (!tj_index[v]) {
dfs(v);
tj_low_link[u] = min(tj_low_link[u], tj_low_link[v]);
} else if (tj_inS[v]) {
tj_low_link[u] = min(tj_low_link[u], tj_index[v]);
}
}
if (tj_low_link[u] == tj_index[u]) {
vector<int> rr;
int w;
bool hasOut = false;
do {
w = tj_S.back();
rr.push_back(w);
tj_S.pop_back();
tj_inS[w] = 2;
} while (w != u);
for (int w : rr) {
for (int v : adj[w]) {
if (tj_inS[v] != 2) {
hasOut = true;
break;
}
}
if (hasOut) break;
}
for (int w : rr) {
tj_inS[w] = false;
}
if (!hasOut && (tj_res.empty() || rr.size() < tj_res.size())) {
tj_res = rr;
}
}
}
int main(int argc, char *argv[]) {
std::cin.sync_with_stdio(false);
std::cin.tie(nullptr);
cin >> n >> m >> h;
{
for (int i = 1; i <= n; i++) cin >> u[i], sadj[i].clear(), adj[i].clear();
for (int i = 1; i <= m; i++) {
int c1, c2;
cin >> c1 >> c2;
if ((u[c1] + 1) % h == u[c2]) {
sadj[c1].insert(c2);
}
if ((u[c2] + 1) % h == u[c1]) {
sadj[c2].insert(c1);
}
}
memset(inDeg, 0, sizeof(inDeg));
for (int u = 1; u <= n; u++) {
for (int v : sadj[u]) {
inDeg[v]++;
adj[u].push_back(v);
}
}
int best0 = -1;
for (int u = 1; u <= n; u++) {
if (adj[u].empty()) {
best0 = u;
break;
}
}
if (best0 >= 0) {
cout << 1 << endl << best0 << endl;
} else {
memset(vs, 0, sizeof(vs));
memset(tj_index, 0, sizeof(tj_index));
memset(tj_low_link, 0, sizeof(tj_low_link));
memset(tj_inS, 0, sizeof(tj_inS));
tj_idx = 1;
for (int u = 1; u <= n; u++) {
if (!tj_index[u]) {
dfs(u);
}
}
cout << tj_res.size() << endl;
for (int x : tj_res) cout << x << " ";
cout << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 10;
int n, m, h, ui[mx], head[mx], tot, ans, anstype;
vector<int> sta;
struct node {
int y;
int nxt;
} Edge[mx << 1];
void AddEdge(int x, int y) {
Edge[tot].y = y;
Edge[tot].nxt = head[x];
head[x] = tot++;
}
int out[mx];
int type[mx], typeCnt[mx], top;
bool vis[mx];
void dfs1(int x) {
if (vis[x]) return;
vis[x] = 1;
for (int i = head[x]; ~i; i = Edge[i].nxt) dfs1(Edge[i].y);
sta.push_back(x);
}
void Dfs(int x) {
if (type[x]) return;
type[x] = top;
typeCnt[top]++;
for (int i = head[x]; ~i; i = Edge[i].nxt) Dfs(Edge[i].y);
}
int main() {
memset(head, -1, sizeof(head));
top = tot = 0;
ans = 1e9;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", ui + i);
int a, b, flag = 0;
while (m--) {
scanf("%d%d", &a, &b);
if ((ui[a] + 1) % h == ui[b]) vis[a] = 1, AddEdge(a, b);
if ((ui[b] + 1) % h == ui[a]) vis[b] = 1, AddEdge(b, a);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) return 0 * printf("1\n%d", i);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs1(i);
for (int i = 0; i < n; i++)
if (!type[sta[i]]) top++, Dfs(sta[i]);
for (int i = 1; i <= n; i++) {
if (out[type[i]]) continue;
for (int j = head[i]; ~j; j = Edge[j].nxt) {
int son = Edge[j].y;
if (type[son] != type[i]) {
out[type[i]]++;
break;
}
}
}
for (int i = 1; i <= top; i++)
if (!out[i] && ans > typeCnt[i]) ans = typeCnt[i], anstype = i;
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (type[i] == anstype) printf("%d ", i);
return puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int uptime[maxn];
vector<int> ve[maxn];
int res[maxn];
int pp[maxn], cnt[maxn];
int e = 0, dns[maxn], low[maxn], tot, stack1[maxn], vis[maxn];
int cd[maxn];
map<pair<int, int>, int> cao;
void Tarjan(int pos) {
low[pos] = dns[pos] = ++tot;
stack1[++e] = pos;
vis[pos] = 1;
int l = (int)ve[pos].size();
for (int v : ve[pos]) {
if (!dns[v]) {
Tarjan(v);
low[pos] = min(low[pos], low[v]);
} else if (vis[v])
low[pos] = min(low[pos], dns[v]);
}
if (dns[pos] == low[pos]) {
while (stack1[e] != pos) {
vis[stack1[e]] = 0;
pp[stack1[e]] = pos;
cnt[pos]++;
e--;
}
e--;
cnt[pos]++;
vis[pos] = 0;
pp[pos] = pos;
}
}
void dfs(int pos) {
vis[pos] = 1;
for (int i : ve[pos]) {
if (vis[i] == 0) {
printf(" %d", i);
dfs(i);
}
}
}
int main() {
int n, m, h;
res[0] = 1000000000;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) {
scanf("%d", &uptime[i]);
}
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (abs(uptime[u] - uptime[v]) == 1) {
if (uptime[u] < uptime[v]) {
if (cao[make_pair(u, v)] == 0) {
cao[make_pair(u, v)] = 1;
ve[u].push_back(v);
}
} else {
if (cao[make_pair(v, u)] == 0) {
cao[make_pair(v, u)] = 1;
ve[v].push_back(u);
}
}
}
if (abs(uptime[u] - uptime[v]) == h - 1) {
if (uptime[u] == 0 && uptime[v] == h - 1) {
if (cao[make_pair(v, u)] == 0) {
cao[make_pair(v, u)] = 1;
ve[v].push_back(u);
}
} else {
if (cao[make_pair(u, v)] == 0) {
cao[make_pair(u, v)] = 1;
ve[u].push_back(v);
}
}
}
}
for (int i = 1; i <= n; i++) {
if (!dns[i]) {
Tarjan(i);
}
}
for (int i = 1; i <= n; i++) {
if (cd[pp[i]] == 0) {
for (int j : ve[i]) {
if (pp[j] == pp[i])
continue;
else {
cd[pp[i]]++;
break;
}
}
}
}
int minn = 100000000, Index = 0;
for (int i = 1; i <= n; i++) {
if (cd[pp[i]] == 0) {
if (minn > cnt[pp[i]]) {
Index = pp[i];
minn = cnt[pp[i]];
}
}
}
printf("%d\n%d", minn, Index);
memset(vis, 0, sizeof(vis));
dfs(Index);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
bool onStack[MAXN];
stack<int> path;
int lowLink[MAXN];
int curindex;
int ind[MAXN];
vector<vector<int>> components;
vector<int> g[MAXN];
void tarjan(int vertex) {
onStack[vertex] = 1;
path.push(vertex);
ind[vertex] = curindex;
lowLink[vertex] = ind[vertex];
++curindex;
for (int to : g[vertex]) {
if (ind[to] == -1) {
tarjan(to);
lowLink[vertex] = std::min(lowLink[vertex], lowLink[to]);
} else if (onStack[to]) {
lowLink[vertex] = std::min(lowLink[vertex], ind[to]);
}
}
if (ind[vertex] == lowLink[vertex]) {
components.push_back({});
while (onStack[vertex]) {
onStack[path.top()] = false;
components.back().push_back(path.top());
path.pop();
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, h;
cin >> n >> m >> h;
vector<int> c(n);
for (int i = 0; i < n; ++i) {
cin >> c[i];
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
if ((c[u] == h - 1 && c[v] == 0) || c[v] - c[u] == 1) {
g[u].push_back(v);
}
swap(u, v);
if ((c[u] == h - 1 && c[v] == 0) || c[v] - c[u] == 1) {
g[u].push_back(v);
}
}
for (int i = 0; i < n; ++i) {
ind[i] = -1;
}
for (int i = 0; i < n; ++i) {
if (ind[i] == -1) {
tarjan(i);
}
}
vector<int> col(n);
for (int i = 0; i < (int)(components).size(); ++i) {
for (int el : components[i]) {
col[el] = i;
}
}
vector<int> f((int)(components).size());
for (int u = 0; u < n; ++u) {
for (int v : g[u]) {
if (col[u] != col[v]) {
f[col[u]] = 1;
}
}
}
int ans = n;
vector<int> s;
for (int i = 0; i < n; ++i) {
s.push_back(i);
}
for (int i = 0; i < (int)(components).size(); ++i) {
if (f[i] || (int)(components[i]).size() >= ans) {
continue;
}
ans = (int)(components[i]).size();
s = components[i];
}
cout << ans << endl;
for (int i = 0; i < (int)(s).size(); ++i) {
cout << s[i] + 1 << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int N = 1e5 + 11;
bitset<N> u;
int n, m, h, tin[N], tout[N], timer = 0, col[N];
vector<int> hs(N);
vector<vector<int>> g(N), or_g(N), rev_or_g(N), comps(N), mg(N);
void dfs(const int &v) {
u[v] = 1;
tin[v] = timer++;
for (int to : or_g[v]) {
if (!u[to]) {
dfs(to);
}
}
tout[v] = timer++;
}
int ccol = 0;
void color(const int &v) {
u[v] = 1;
col[v] = ccol;
comps[ccol].push_back(v);
for (int to : rev_or_g[v]) {
if (!u[to]) {
color(to);
}
}
}
inline bool cmp(const int &v, const int &u) { return tout[v] > tout[u]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> h;
vector<int> order(n);
for (int i = 0; i < n; ++i) {
cin >> hs[i];
order[i] = i;
}
for (int i = 0; i < m; ++i) {
int v, u;
cin >> v >> u;
v--;
u--;
g[v].push_back(u);
g[u].push_back(v);
}
for (int i = 0; i < n; ++i) {
if (!u[i]) {
queue<int> q;
q.push(i);
u[i] = 1;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int to : g[v]) {
if ((hs[v] + 1) % h == hs[to]) {
if (!u[to]) {
u[to] = 1;
q.push(to);
}
or_g[v].push_back(to);
rev_or_g[to].push_back(v);
}
}
}
}
}
u.reset();
for (int i = 0; i < n; ++i) {
if (!u[i]) {
dfs(i);
}
}
u.reset();
sort(order.begin(), order.end(), cmp);
for (int v : order) {
if (!u[v]) {
color(v);
ccol++;
}
}
for (int i = 0; i < ccol; ++i) {
for (int v : comps[i]) {
for (int j : or_g[v]) {
if (col[v] != col[j]) {
mg[i].push_back(col[j]);
}
}
}
}
int min_sz = INF, ind = -1;
for (int i = 0; i < ccol; ++i) {
if (mg[i].size() == 0) {
if (min_sz > comps[i].size()) {
ind = i;
min_sz = comps[i].size();
}
}
}
cout << min_sz << "\n";
for (int i : comps[ind]) {
cout << i + 1 << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 5e5 + 5;
const int OO = 1e9;
const int mod = 1e9 + 7;
int n, m, u[N], c1, c2, h, ans, ID[N], compSz, vis[N], inS[N], low[N], rnk[N],
nodes, compID;
vector<int> comp[N], cG[N], g[N];
stack<int> second;
void tarjan(int u) {
if (vis[u]) return;
vis[u] = inS[u] = 1;
low[u] = rnk[u] = ++nodes;
second.push(u);
for (auto v : g[u]) {
if (vis[v]) {
if (inS[v]) low[u] = min(low[u], rnk[v]);
} else {
tarjan(v);
low[u] = min(low[u], low[v]);
}
}
if (rnk[u] == low[u]) {
++compSz;
while (true) {
int cur = second.top();
second.pop();
inS[cur] = false;
ID[cur] = compSz;
comp[compSz].push_back(cur);
if (cur == u) break;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) {
cin >> u[i];
}
while (m--) {
cin >> c1 >> c2;
if (u[c1] == (u[c2] + 1) % h) g[c2].push_back(c1);
swap(c1, c2);
if (u[c1] == (u[c2] + 1) % h) g[c2].push_back(c1);
}
ans = n + 1;
for (int i = 1; i <= n; ++i) {
tarjan(i);
}
for (int i = 1; i <= n; ++i) {
for (auto v : g[i]) {
if (ID[i] != ID[v]) {
cG[ID[i]].push_back(ID[v]);
}
}
}
for (int i = 1; i <= compSz; ++i) {
if (cG[i].empty()) {
int sz = comp[i].size();
if (sz < ans) {
ans = sz;
compID = i;
}
}
}
cout << ans << '\n';
for (auto i : comp[compID]) {
cout << i << ' ';
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
int n;
int u[100000 + 1];
int m;
int h;
int ne;
int v[(2 * 100000) + 1];
int next[(2 * 100000) + 1];
int head[100000 + 1];
int tag;
int DFn[100000 + 1], low[100000 + 1];
bool vis[100000 + 1];
int ns;
int stk[100000 + 1];
bool in_stk[100000 + 1];
bool not_leaf[100000 + 1];
int ans_size;
int ans_entry;
void connect(int x, int y) {
++ne;
v[ne] = y;
next[ne] = head[x];
head[x] = ne;
}
void read() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) scanf("%d", &u[i]);
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if ((u[x] + 1) % h == u[y]) connect(x, y);
if ((u[y] + 1) % h == u[x]) connect(y, x);
}
}
void Tarjan(int x) {
vis[x] = true;
++tag;
DFn[x] = tag;
low[x] = tag;
++ns;
stk[ns] = x;
in_stk[x] = true;
for (int t = head[x]; t; t = next[t]) {
int y = v[t];
if (!vis[y]) Tarjan(y);
if (in_stk[y]) {
if (low[y] < low[x]) low[x] = low[y];
} else
not_leaf[x] = true;
}
if (DFn[x] == low[x]) {
bool is_leaf = true;
int size = 0;
while (true) {
++size;
int y = stk[ns];
if (not_leaf[y]) is_leaf = false;
in_stk[y] = false;
if (y == x) break;
--ns;
}
if (is_leaf && size < ans_size) {
ans_size = size;
ans_entry = x;
}
}
}
void chief() {
ans_size = n + 1;
for (int i = 1; i <= n; ++i)
if (!vis[i]) Tarjan(i);
}
void output_DFS(int x) {
++tag;
vis[x] = true;
if (tag > 1) putchar(' ');
printf("%d", x);
if (tag == ans_size) putchar('\n');
for (int t = head[x]; t; t = next[t]) {
int y = v[t];
if (!vis[y]) output_DFS(y);
}
}
void write() {
printf("%d\n", ans_size);
tag = 0;
memset(vis, false, (n + 1) * sizeof(bool));
output_DFS(ans_entry);
}
int main() {
read();
chief();
write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> edg[100007];
vector<int> redg[100007];
stack<int> st;
int vs[100007];
void dfs(int u) {
vs[u] = 1;
int i, v;
for (i = 0; i < edg[u].size(); i++) {
v = edg[u][i];
if (vs[v]) continue;
dfs(v);
}
st.push(u);
}
int belogsto[100007];
int compsize[100007];
int id[100007];
set<int> components[100007];
vector<int> cmpNodes[100007];
int scc(int n) {
int i;
for (i = 1; i <= n; i++) {
if (vs[i] == 0) dfs(i);
}
memset(vs, 0, sizeof vs);
int sz = 0;
while (!st.empty()) {
int u, v;
u = st.top();
st.pop();
if (vs[u]) continue;
belogsto[u] = ++sz;
queue<int> q;
q.push(u);
while (!q.empty()) {
u = q.front();
q.pop();
if (vs[u]) continue;
vs[u] = 1;
belogsto[u] = sz;
cmpNodes[sz].push_back(u);
id[u] = compsize[sz]++;
for (i = 0; i < redg[u].size(); i++) {
v = redg[u][i];
if (vs[v] == 0) q.push(v);
}
}
}
for (int i = 1; i <= n; i++) {
for (int v : edg[i]) {
if (belogsto[i] == belogsto[v]) continue;
components[belogsto[i]].insert(belogsto[v]);
}
}
assert(sz > 0 && sz <= n);
return sz;
}
int mntnce[100007];
long long dp[100007];
int color[100007];
void loopFinder(int u) {
color[u] = 1;
for (int v : components[u]) {
if (color[v] == 1) {
printf("loop found!!!\n");
exit(0);
}
if (color[v] == 0) loopFinder(v);
}
color[u] = 2;
}
void rc(int u) {
if (dp[u] != -1) return;
dp[u] = compsize[u];
for (int v : components[u]) {
rc(v);
dp[u] += dp[v];
}
}
void print(int u) {
for (int x : cmpNodes[u]) {
assert(vs[x] == 0);
vs[x] = 1;
printf(" %d", x);
}
for (int v : components[u]) {
print(v);
}
}
int main() {
int n, m, h;
scanf("%d %d %d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &mntnce[i]);
while (m--) {
int c1, c2;
scanf("%d %d", &c1, &c2);
if ((mntnce[c1] + 1) % h == mntnce[c2]) {
edg[c1].push_back(c2);
redg[c2].push_back(c1);
}
if ((mntnce[c2] + 1) % h == mntnce[c1]) {
edg[c2].push_back(c1);
redg[c1].push_back(c2);
}
}
int cmp = scc(n);
for (int i = 1; i <= cmp; i++)
if (color[i] == 0) loopFinder(i);
memset(dp, -1, sizeof dp);
memset(vs, 0, sizeof vs);
int ans = n + 1, idx = -1;
for (int i = 1; i <= cmp; i++) {
rc(i);
if (dp[i] < ans) {
ans = dp[i];
idx = i;
}
}
printf("%d\n", ans);
memset(vs, 0, sizeof vs);
print(idx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 100 + 10;
int n, m, h, T[maxn];
vector<int> G[2][maxn], q, vCol[maxn];
int mark[maxn];
void add(int u, int v) {
G[0][u].push_back(v);
G[1][v].push_back(u);
}
void dfs(int root, int yal, int col) {
mark[root] = col;
if (yal == 1) vCol[col].push_back(root);
for (int j = 0; j < G[yal][root].size(); j++) {
int tmp = G[yal][root][j];
if (mark[tmp] == 0) dfs(tmp, yal, col);
}
if (yal == 0) q.push_back(root);
}
int main() {
scanf("%d%d%d", &n, &m, &h);
int ans = n;
for (int i = 0; i < n; i++) scanf("%d", &T[i]);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
if ((T[u] + 1) % h == T[v]) add(u, v);
if ((T[v] + 1) % h == T[u]) add(v, u);
}
for (int i = 0; i < n; i++)
if (!mark[i]) dfs(i, 0, 1);
for (int i = 0; i < maxn; i++) mark[i] = 0;
int col = 0;
for (int i = q.size() - 1; i >= 0; i--)
if (!mark[q[i]]) {
col++;
dfs(q[i], 1, col);
}
int myCol = 0;
for (int i = 1; i <= col; i++) {
int flag = 1;
for (int j = 0; j < vCol[i].size(); j++) {
int u = vCol[i][j];
for (int l = 0; l < G[0][u].size(); l++) {
int v = G[0][u][l];
if (mark[u] != mark[v]) {
flag = 0;
break;
}
}
}
if (flag and ans >= vCol[i].size()) {
ans = vCol[i].size();
myCol = i;
}
}
printf("%d\n", ans);
for (int i = 0; i < vCol[myCol].size(); i++)
printf("%d ", vCol[myCol][i] + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct rec {
int next, to;
} edge[100000 * 2 + 1];
int dfn[100000 + 1], low[100000 + 1], head[100000 + 1], a[100000 + 1],
b[100000 + 1], s[100000 + 1], n, m, h, cnt = 1, ans = 2147483647, tot = 0;
bool bz[100000 + 1], bz1[100000 + 1];
void add(int u, int v) {
edge[cnt].to = v, edge[cnt].next = head[u];
head[u] = cnt++;
}
void tarjan(int k) {
dfn[k] = low[k] = ++tot, s[++s[0]] = k, bz1[k] = true, bz[k] = false;
for (int i = head[k]; i; i = edge[i].next) {
if (!dfn[edge[i].to]) {
tarjan(edge[i].to);
low[k] = min(low[k], low[edge[i].to]);
} else if (bz1[edge[i].to])
low[k] = min(low[k], dfn[edge[i].to]);
}
if (dfn[k] == low[k]) {
bool bz2 = true;
int size = 0;
for (int i = s[0]; i; i = (s[i] == k ? 0 : i - 1)) {
++size;
for (int j = head[s[i]]; j; j = edge[j].next)
if (!bz1[edge[j].to]) bz2 = false;
}
if (bz2 && size < ans) {
ans = size;
for (int i = s[0]; i; i = (s[i] == k ? 0 : i - 1), size--, --s[0]) {
bz1[s[i]] = false, b[ans - size + 1] = s[i];
}
} else {
for (int i = s[0]; i; i = (s[i] == k ? 0 : i - 1), --s[0])
bz1[s[i]] = false;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int x, y;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
if ((a[x] + 1) % h == a[y]) add(x, y);
if ((a[y] + 1) % h == a[x]) add(y, x);
}
memset(bz, true, sizeof bz);
memset(dfn, 0, sizeof dfn);
memset(low, 0, sizeof low);
s[0] = 0;
for (int i = 1; i <= n; i++) {
if (bz[i]) tarjan(i);
tot = 0;
}
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) printf("%d ", b[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h, a[100005], cnt, out[100005], siz[100005], hd[100005], dfn[100005],
low[100005], tim, sd[100005];
struct node {
int from, to, next;
} e[200005];
int read() {
int f = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
f = f * 10 + ch - '0';
ch = getchar();
}
return f * w;
}
void addedge(int x, int y) {
e[++cnt].next = hd[x];
e[cnt].from = x;
e[cnt].to = y;
hd[x] = cnt;
}
stack<int> q;
int num;
bool vis[100005];
void tarjan(int x) {
q.push(x);
dfn[x] = low[x] = ++tim;
vis[x] = 1;
for (int i = hd[x]; i; i = e[i].next) {
int to = e[i].to;
if (vis[to]) {
low[x] = min(low[x], dfn[to]);
} else if (!dfn[to]) {
tarjan(to);
low[x] = min(low[x], low[to]);
}
}
if (dfn[x] == low[x]) {
num++;
while (!q.empty()) {
int xx = q.top();
q.pop();
siz[num]++;
sd[xx] = num;
vis[xx] = 0;
if (x == xx) {
break;
}
}
}
}
int main() {
n = read(), m = read(), h = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
}
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
if ((a[x] + 1) % h == a[y]) addedge(x, y);
if ((a[y] + 1) % h == a[x]) addedge(y, x);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i);
}
for (int i = 1; i <= cnt; i++) {
if (sd[e[i].from] != sd[e[i].to]) {
out[sd[e[i].from]]++;
}
}
siz[0] = 0x3f3f3f3f;
int pos = 0;
for (int i = 1; i <= num; i++) {
if (siz[i] < siz[pos] && !out[i]) pos = i;
}
printf("%d\n", siz[pos]);
for (int i = 1; i <= n; i++) {
if (sd[i] == pos) printf("%d ", i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 100005;
vector<int> G[NMAX], GT[NMAX], ctc[NMAX];
int N, M, post[NMAX], viz[NMAX], cnt, H, hours[NMAX], whatCtc[NMAX];
void dfs(int nod) {
viz[nod] = 1;
for (vector<int>::iterator it = G[nod].begin(); it != G[nod].end(); ++it)
if (!viz[*it]) dfs(*it);
post[++cnt] = nod;
}
void dfs2(int nod, int sol) {
viz[nod] = 0;
ctc[sol].push_back(nod);
for (vector<int>::iterator it = GT[nod].begin(); it != GT[nod].end(); ++it)
if (viz[*it]) dfs2(*it, sol);
}
bool verifica(int nod) {
for (int i = 0; i < G[nod].size(); ++i)
if (whatCtc[nod] != whatCtc[G[nod][i]]) return false;
return true;
}
int main() {
scanf("%d%d%d", &N, &M, &H);
for (int i = 1; i <= N; ++i) scanf("%d", &hours[i]);
int a, b;
for (int i = 1; i <= M; ++i) {
scanf("%d%d", &a, &b);
if ((hours[a] + 1) % H == hours[b]) {
G[a].push_back(b);
GT[b].push_back(a);
}
if ((hours[b] + 1) % H == hours[a]) {
G[b].push_back(a);
GT[a].push_back(b);
}
}
for (int i = 1; i <= N; ++i)
if (!viz[i]) dfs(i);
int sol = 0;
for (int i = N; i >= 1; --i)
if (viz[post[i]]) {
++sol;
dfs2(post[i], sol);
}
int minim = NMAX, indSol = 1;
for (int i = 1; i <= sol; ++i)
for (int j = 0; j < ctc[i].size(); ++j) whatCtc[ctc[i][j]] = i;
for (int i = 1; i <= sol; ++i) {
bool ok = true;
for (int j = 0; j < ctc[i].size(); ++j) ok &= verifica(ctc[i][j]);
if (ok && minim > ctc[i].size()) {
minim = ctc[i].size();
indSol = i;
}
}
cout << ctc[indSol].size() << "\n";
for (int i = 0; i < ctc[indSol].size(); ++i) cout << ctc[indSol][i] << " ";
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << "\n";
err(++it, args...);
}
const long long N = 1e5 + 5, M = 1001, inf = 1e18;
vector<int> gr[N], gt[N], gc[N], order, comp(N);
vector<int> deg(N), s(N);
vector<bool> used(N);
int cycle;
void dfsa(int u) {
used[u] = true;
for (int v : gr[u])
if (not used[v]) dfsa(v);
order.push_back(u);
}
void dfsb(int u) {
used[u] = true;
comp[u] = cycle;
s[cycle]++;
for (int v : gt[u])
if (not used[v]) dfsb(v);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, m, h;
cin >> n >> m >> h;
int t[n + 1];
for (int i = 0; i < n; i++) cin >> t[i + 1];
;
set<pair<int, int> > done;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
if (done.find({a, b}) != done.end()) {
continue;
}
if ((t[a] + 1) % h == t[b]) {
gr[a].push_back(b);
gt[b].push_back(a);
}
if ((t[b] + 1) % h == t[a]) {
gr[b].push_back(a);
gt[a].push_back(b);
}
done.insert({a, b});
done.insert({b, a});
}
for (int u = 1; u < n + 1; u++)
if (not used[u]) dfsa(u);
reverse(order.begin(), order.end());
used.assign(n + 1, false);
for (int u : order)
if (not used[u]) {
cycle++;
dfsb(u);
}
for (int u = 1; u < n + 1; u++) {
for (int v : gr[u]) {
int x, y;
x = comp[u];
y = comp[v];
if (x != y) {
deg[x]++;
}
}
}
long long ans = -1, val = inf;
for (int i = 1; i < cycle + 1; i++) {
if (deg[i] == 0 and s[i] <= val) {
ans = i;
val = s[i];
}
}
cout << s[ans] << "\n";
for (int i = 1; i < n + 1; i++)
if (comp[i] == ans) {
cout << i << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int Add(int &a, int b) { a = (a + b) % 1000000007; }
int Min(int &a, int b) { a = (a + 1000000007 - b) % 1000000007; }
int Mul(int &a, int b) { a = (long long)a * b % 1000000007; }
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long pow(long long a, long long b) {
long long res(1);
while (b) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return res;
}
long long powM(long long a, long long b, long long mod) {
long long res(1);
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
const int infi = 2147483647;
const long long infl = 9223372036854775807;
struct E {
int u, v, n;
} G[200010], G1[200010];
int cnt, point[200010];
void adde(int u, int v, int w = 0) {
G[++cnt] = (E){u, v, point[u]}, point[u] = cnt;
}
void Ginit() {
cnt = 0;
memset(point, 0, sizeof point);
}
int n, m, k, a[200010];
int low[200010], dfn[200010], belong[200010], Stack[200010];
bool instack[200010];
int dfsnow, Stop, sccnum;
int sz[200010];
void tarjan(int u) {
int v;
dfn[u] = low[u] = ++dfsnow;
instack[u] = 1;
Stack[++Stop] = u;
for (int i = point[u]; i; i = G[i].n) {
v = G[i].v;
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (instack[v])
low[u] = min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
sccnum++;
do {
v = Stack[Stop--];
instack[v] = 0;
belong[v] = sccnum;
sz[sccnum]++;
} while (v != u);
}
}
void SCC() {
Stop = sccnum = dfsnow = 0;
memset(dfn, 0, sizeof dfn);
for (int i = 1; i <= (n); ++i)
if (!dfn[i]) tarjan(i);
}
int ind[200010], oud[200010];
void suodian() {
for (int i = 1; i <= (cnt); ++i)
if (belong[G[i].u] != belong[G[i].v]) {
oud[belong[G[i].u]]++;
}
}
int main() {
scanf("%d", &n), scanf("%d", &m), scanf("%d", &k);
for (int i = 1; i <= (n); ++i) scanf("%d", &a[i]);
for (int i = 1; i <= (m); ++i) {
int u, v;
scanf("%d", &u), scanf("%d", &v);
if ((a[u] + 1) % k == a[v]) adde(u, v);
if ((a[v] + 1) % k == a[u]) adde(v, u);
}
SCC();
suodian();
int ans = infi, ansi;
for (int i = 1; i <= (sccnum); ++i)
if (oud[i] == 0 && sz[i] < ans) {
ans = sz[i];
ansi = i;
}
printf("%d", (ans));
putchar('\n');
for (int i = 1; i <= (n); ++i)
if (belong[i] == ansi) printf("%d", (i)), putchar(' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
vector<int> Upd;
vector<vector<int>> G;
vector<vector<int>> Rev;
vector<int> Ans, Met1;
set<int> Final;
void dfs(int v) {
Met1[v] = 1;
for (int i = 0; i < G[v].size(); i++) {
if (Met1[G[v][i]] == 1) continue;
dfs(G[v][i]);
}
Ans.push_back(v);
}
void topsort() {
Ans.clear();
Met1.resize(n, 0);
for (int i = 0; i < n; i++) {
if (Met1[i] == 0) dfs(i);
}
reverse(Ans.begin(), Ans.end());
}
vector<int> Color, Met2;
int cou = -1;
void dfs2(int v) {
Met2[v] = 1;
Color[v] = cou;
for (int i = 0; i < Rev[v].size(); i++) {
if (Met2[Rev[v][i]] == 1) continue;
dfs2(Rev[v][i]);
}
}
void kras() {
Color.resize(n, -1);
Met2.resize(n, 0);
for (int i = 0; i < n; i++) {
if (Met2[Ans[i]] == 0) {
cou++;
dfs2(Ans[i]);
}
}
}
vector<vector<int>> Comp, D;
void sv() {
Comp.resize(cou + 1, vector<int>(0));
D = Comp;
for (int i = 0; i < n; i++) {
Comp[Color[i]].push_back(i);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < G[i].size(); j++) {
if (Color[i] == Color[G[i][j]]) continue;
D[Color[i]].push_back(Color[G[i][j]]);
}
}
int mi = 2e9, numi = -1;
for (int i = 0; i <= cou; i++) {
if (D[i].size() > 0) continue;
if (Comp[i].size() < mi) {
mi = Comp[i].size();
numi = i;
}
}
for (int i = 0; i < Comp[numi].size(); i++) {
Final.insert(Comp[numi][i] + 1);
}
}
int main() {
string s;
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m >> h;
Upd.resize(n);
G.resize(n, vector<int>(0));
Rev = G;
for (int i = 0; i < n; i++) {
cin >> Upd[i];
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
if ((Upd[a] + 1) % h == Upd[b] % h) {
G[a].push_back(b);
Rev[b].push_back(a);
}
if ((Upd[b] + 1) % h == Upd[a] % h) {
G[b].push_back(a);
Rev[a].push_back(b);
}
}
topsort();
kras();
sv();
cout << Final.size() << "\n";
for (auto first : Final) {
cout << first << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, h, i, j, x, y, p, t, sum;
int a[N], f[N], g[N], dfn[N], low[N], ans[N];
int b[N], lst[N], e[N * 2][2], c[N];
bool bz[N];
void link(int x, int y) { e[++t][0] = lst[x], e[t][1] = y, lst[x] = t; }
int find(int x) {
if (x == f[x])
return x;
else
return f[x] = find(f[x]);
}
void merge(int x, int y) {
x = find(x), y = find(y);
f[x] = y, g[y] += g[x];
}
void dg(int x) {
dfn[x] = low[x] = ++t, c[++c[0]] = x, bz[x] = 1;
int i = lst[x];
while (i) {
int y = e[i][1];
i = e[i][0];
if (!dfn[y])
dg(y), low[x] = min(low[x], low[y]);
else if (bz[y])
low[x] = min(low[x], dfn[y]);
}
if (low[x] == dfn[x]) {
while (x != c[c[0]]) merge(x, c[c[0]]), bz[c[c[0]--]] = 0;
bz[x] = 0, c[0]--;
}
}
void dg2(int x) {
if (bz[x]) return;
int i = lst[x];
bz[x] = 1, ans[++ans[0]] = x;
while (i) {
int y = e[i][1];
i = e[i][0], dg2(y);
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), f[i] = i, g[i] = 1;
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
if ((a[x] + 1) % h == a[y]) link(x, y), b[x]++;
if ((a[y] + 1) % h == a[x]) link(y, x), b[y]++;
}
for (i = 1; i <= n; i++)
if (!b[i]) {
ans[0] = 1, ans[1] = i;
break;
}
if (!ans[0]) {
t = 0;
for (i = 1; i <= n; i++)
if (!dfn[i]) dg(i);
memset(b, 0, sizeof(b));
c[0] = 0;
for (i = 1; i <= n; i++) {
j = lst[i], x = find(i);
if (i == x) c[++c[0]] = i;
while (j) {
t = e[j][1], j = e[j][0], y = find(t);
if (x != y) b[x]++;
}
}
ans[0] = n + 1;
for (i = 1; i <= c[0]; i++)
if (!b[x = c[i]]) {
if (g[x] < ans[0]) ans[0] = g[x], p = x;
}
memset(bz, 0, sizeof(bz));
ans[0] = 0, dg2(p);
}
printf("%d\n", ans[0]);
for (i = 1; i <= ans[0]; i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g, r;
int n;
vector<int> color, st, scc;
int nSCC;
void dfs(int v, int flag) {
color[v] = 1;
for (int u : (flag ? g[v] : r[v]))
if (!color[u]) dfs(u, flag);
if (flag)
st.push_back(v);
else
scc[v] = nSCC;
}
void traverse() {
color = vector<int>(n, 0);
st.clear();
for (int i = 0; i < n; i++)
if (!color[i]) dfs(i, 1);
color = vector<int>(n, 0);
scc = vector<int>(n);
nSCC = 0;
for (int i = n - 1; i >= 0; i--)
if (!color[st[i]]) {
dfs(st[i], 0);
nSCC++;
}
}
vector<int> hour, szSCC, valid;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int m, h, px, py, x, y;
set<pair<int, int> > st;
while (cin >> n >> m >> h) {
hour = vector<int>(n);
for (int i = 0; i < n; i++) cin >> hour[i];
st.clear();
g = vector<vector<int> >(n);
r = vector<vector<int> >(n);
for (int i = 0; i < m; i++) {
cin >> px >> py;
px--;
py--;
x = min(px, py);
y = max(px, py);
if (st.count({x, y})) continue;
st.insert({x, y});
if ((hour[x] + 1) % h == hour[y]) {
g[x].push_back(y);
r[y].push_back(x);
}
if ((hour[y] + 1) % h == hour[x]) {
g[y].push_back(x);
r[x].push_back(y);
}
}
traverse();
szSCC = vector<int>(nSCC, 0);
valid = vector<int>(nSCC, 1);
for (int v = 0; v < n; v++) {
szSCC[scc[v]]++;
for (int u : g[v])
if (scc[u] != scc[v]) valid[scc[v]] = 0;
}
int ans = n + 1, pos = -1;
for (int i = 0; i < nSCC; i++)
if (valid[i] && szSCC[i] < ans) {
ans = szSCC[i];
pos = i;
}
cout << ans << '\n';
for (int i = 0; i < n; i++)
if (scc[i] == pos) cout << i + 1 << " ";
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 10;
int u[MAXN];
vector<int> g[MAXN], grev[MAXN];
vector<int> top_sort;
bool used[MAXN];
int out_deg[MAXN];
int color[MAXN];
vector<int> comp[MAXN];
void dfs(int v) {
used[v] = true;
for (int to : g[v]) {
if (!used[to]) {
dfs(to);
}
}
top_sort.push_back(v);
}
void coloring(int v, int cnt) {
used[v] = true;
color[v] = cnt;
comp[cnt].push_back(v);
for (int to : grev[v]) {
if (!used[to]) {
coloring(to, cnt);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
memset(used, 0, sizeof(used));
int n, m, h;
cin >> n >> m >> h;
for (int i = 0; i < n; ++i) {
cin >> u[i];
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
if ((u[a] + 1) % h == u[b]) {
g[a].push_back(b);
grev[b].push_back(a);
}
if ((u[b] + 1) % h == u[a]) {
g[b].push_back(a);
grev[a].push_back(b);
}
}
for (int i = 0; i < n; ++i) {
if (!used[i]) {
dfs(i);
}
}
memset(used, 0, sizeof(used));
int cnt = 0;
for (int i = n - 1; i >= 0; --i) {
int v = top_sort[i];
if (!used[v]) {
coloring(v, cnt++);
}
}
memset(out_deg, 0, sizeof(out_deg));
for (int i = 0; i < n; ++i) {
for (int to : g[i]) {
if (color[i] != color[to]) {
out_deg[color[i]]++;
}
}
}
int num = 0;
for (int i = 1; i < cnt; ++i) {
if (out_deg[i] != 0) {
continue;
}
if (out_deg[num] != 0) {
num = i;
continue;
}
if (comp[i].size() < comp[num].size()) {
num = i;
}
}
cout << comp[num].size() << "\n";
for (int v : comp[num]) {
cout << v + 1 << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 101000;
int n, m, h, a[N], fir[N], cnt;
struct node {
int nxt, to;
} e[N << 1];
void add(int u, int v) {
e[++cnt].nxt = fir[u];
fir[u] = cnt;
e[cnt].to = v;
}
int scc[N], dfn[N], low[N], tot, du[N], color, sz[N];
stack<int> s;
bool in[N];
void tarjan(int u) {
dfn[u] = low[u] = ++tot;
s.push(u);
in[u] = 1;
int v;
for (int i = fir[u]; i; i = e[i].nxt) {
v = e[i].to;
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (in[v]) {
low[u] = min(low[u], dfn[v]);
}
}
int num = 0;
if (low[u] == dfn[u]) {
++color;
do {
++num;
v = s.top();
s.pop();
in[v] = 0;
scc[v] = color;
} while (low[v] != dfn[v]);
sz[color] = num;
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
int u, v;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
if ((a[u] + 1) % h == a[v]) {
add(u, v);
}
if ((a[v] + 1) % h == a[u]) {
add(v, u);
}
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) {
tarjan(i);
}
for (int u = 1; u <= n; ++u) {
for (int v, i = fir[u]; i; i = e[i].nxt) {
v = e[i].to;
if (scc[u] != scc[v]) {
++du[scc[u]];
}
}
}
int ans = 0x3f3f3f3f, col = 0;
for (int i = 1; i <= color; ++i) {
if (du[i] == 0) {
if (ans > sz[i]) {
ans = sz[i];
col = i;
}
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; ++i)
if (scc[i] == col) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h, u[100001], visit[100001], low[100001], num[100001], cur,
Min = INT_MAX;
vector<int> adj[100001], comp;
set<int> scc, res;
bool checkScc() {
for (int i : scc)
for (int j : adj[i])
if (scc.find(j) == scc.end()) return false;
return true;
}
void dfs(int x) {
if (num[x] != 0) return;
visit[x] = 1;
comp.push_back(x);
num[x] = low[x] = cur++;
for (int i : adj[x]) {
if (num[i] == 0) dfs(i);
if (visit[i]) low[x] = min(low[x], low[i]);
}
if (low[x] == num[x]) {
scc.clear();
while (1) {
int v = comp.back();
comp.pop_back();
visit[v] = 0;
scc.insert(v);
if (v == x) break;
}
if (checkScc() && scc.size() < Min) {
res = scc;
Min = scc.size();
}
}
}
void setup() {
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) cin >> u[i];
for (int i = 1; i <= m; ++i) {
int c1, c2;
cin >> c1 >> c2;
int temp = u[c2] - u[c1];
if (temp == 1 || temp == 1 - h) adj[c1].push_back(c2);
if (temp == -1 || temp == h - 1) adj[c2].push_back(c1);
}
}
void process() {
for (int i = 1; i <= n; ++i)
if (num[i] == 0) dfs(i);
cout << res.size() << '\n';
for (int i : res) cout << i << ' ';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
setup();
process();
return 0;
}
|
#include <bits/stdc++.h>
int const maxn = 200003;
int n = 0, m = 0, h = 0;
int t[maxn];
int head[maxn], nxt[maxn], to[maxn], cnt = 0;
inline void insert(int u, int e) {
nxt[++cnt] = head[u];
head[u] = cnt;
to[cnt] = e;
}
int dfn[maxn], low[maxn], cdfn = 0;
int st[maxn], top = 0;
bool in[maxn];
int sym[maxn], siz[maxn];
void tarjan(int x) {
dfn[x] = low[x] = ++cdfn;
st[++top] = x;
in[x] = true;
for (int i = head[x]; i; i = nxt[i])
if (!dfn[to[i]]) {
tarjan(to[i]);
low[x] = std::min(low[x], low[to[i]]);
} else if (in[to[i]])
low[x] = std::min(low[x], dfn[to[i]]);
if (dfn[x] == low[x]) {
int y = 0;
do {
y = st[top--];
in[y] = false;
sym[y] = x;
++siz[x];
} while (y != x);
}
}
int d[maxn];
int main() {
scanf("%d %d %d", &n, &m, &h);
for (int i = 1; i <= n; ++i) scanf("%d", t + i);
int x = 0, y = 0;
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &x, &y);
if ((t[x] + 1) % h == t[y]) insert(x, y);
if ((t[y] + 1) % h == t[x]) insert(y, x);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i);
for (int x = 1; x <= n; ++x)
for (int i = head[x]; i; i = nxt[i])
if (sym[to[i]] != sym[x]) ++d[sym[x]];
int j = 0, s = 0x3f3f3f3f;
for (int i = 1; i <= n; ++i)
if (sym[i] == i && d[i] == 0 && siz[i] < s) {
j = i;
s = siz[i];
}
printf("%d\n", s);
for (int i = 1; i <= n; ++i)
if (sym[i] == j) printf("%d ", i);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> ady[100005], rev_ady[100005];
int N, M, H, ho[100005], marcas[100005], CFC, x, y, comp, tamcom[100005],
tamres;
bool vis[100005], relacion[100005];
stack<int> elementos;
void dfs(int nodo) {
vis[nodo] = true;
for (int i = 0; i < ady[nodo].size(); i++)
if (!vis[ady[nodo][i]]) dfs(ady[nodo][i]);
elementos.push(nodo);
}
void dfs2(int nodo) {
marcas[nodo] = CFC, tamcom[CFC]++;
for (int i = 0; i < rev_ady[nodo].size(); i++)
if (!marcas[rev_ady[nodo][i]]) dfs2(rev_ady[nodo][i]);
}
void Kosaraju() {
for (int i = 1; i <= N; i++)
if (!vis[i]) dfs(i);
while (!elementos.empty()) {
x = elementos.top();
elementos.pop();
if (!marcas[x]) CFC++, dfs2(x);
}
}
int main() {
scanf("%d %d %d", &N, &M, &H);
for (int i = 1; i <= N; i++) scanf("%d", &ho[i]);
for (int i = 0; i < M; i++) {
scanf("%d %d", &x, &y);
if ((ho[x] + 1) % H == ho[y]) ady[x].push_back(y), rev_ady[y].push_back(x);
if ((ho[y] + 1) % H == ho[x]) ady[y].push_back(x), rev_ady[x].push_back(y);
}
Kosaraju();
for (int i = 1; i <= N; i++)
for (int j = 0; j < ady[i].size(); j++) {
if (relacion[marcas[i]]) break;
if (marcas[i] != marcas[ady[i][j]]) relacion[marcas[i]] = true;
}
for (int i = 1; i <= CFC; i++)
if (!relacion[i] && (!tamres || tamres > tamcom[i]))
tamres = tamcom[i], comp = i;
printf("%d\n", tamres);
for (int i = 1; i <= N; i++)
if (marcas[i] == comp) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
int arr[100005];
vector<int> adj[100005];
vector<int> sadj[100005];
vector<int> scc[100005];
int vn, sn;
int s[100005], d[100005];
stack<int> st;
int dfs(int now) {
int ret = d[now] = vn++;
st.push(now);
for (auto &there : adj[now]) {
if (d[there] == -1)
ret = min(ret, dfs(there));
else if (s[there] == -1)
ret = min(ret, d[there]);
}
if (ret == d[now]) {
while (true) {
int temp = st.top();
st.pop();
s[temp] = sn;
if (temp == now) break;
}
sn++;
}
return ret;
}
int out[100005];
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
if ((arr[a] + 1) % h == arr[b]) adj[a].push_back(b);
swap(a, b);
if ((arr[a] + 1) % h == arr[b]) adj[a].push_back(b);
}
for (int i = 1; i <= n; i++) {
sort(adj[i].begin(), adj[i].end());
adj[i].erase(unique(adj[i].begin(), adj[i].end()), adj[i].end());
}
memset(s, -1, sizeof(s));
memset(d, -1, sizeof(d));
for (int i = 1; i <= n; i++)
if (d[i] == -1) dfs(i);
for (int now = 1; now <= n; now++) {
scc[s[now]].push_back(now);
for (auto &there : adj[now]) {
if (s[now] == s[there]) continue;
sadj[s[now]].push_back(s[there]);
out[s[now]]++;
}
}
for (int i = 0; i < sn; i++) {
sort(sadj[i].begin(), sadj[i].end());
sadj[i].erase(unique(sadj[i].begin(), sadj[i].end()), sadj[i].end());
}
int ans = 0x3f3f3f3f;
int idx = -1;
for (int i = 0; i < sn; i++) {
if (!out[i]) {
if (ans > scc[i].size()) {
ans = scc[i].size();
idx = i;
}
}
}
printf("%d\n", ans);
for (auto x : scc[idx]) printf("%d ", x);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210000;
const long long INF = 1e18;
int n, m, h, t[N], was[N], clr, pr[N], bad[N];
vector<int> g1[N], g2[N], topsort, cmp[N];
void dfs1(int v) {
was[v] = 1;
for (int u : g1[v]) {
if (!was[u]) {
dfs1(u);
}
}
topsort.push_back(v);
}
void dfs2(int v) {
if (was[v]) {
if (pr[v] != clr) bad[pr[v]] = 1;
return;
}
was[v] = 1;
pr[v] = clr;
for (int u : g2[v]) {
dfs2(u);
}
cmp[clr].push_back(v);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> t[i], cmp[0].push_back(i);
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
if ((t[x] + 1) % h == t[y]) g1[x].push_back(y), g2[y].push_back(x);
swap(x, y);
if ((t[x] + 1) % h == t[y]) g1[x].push_back(y), g2[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!was[i]) dfs1(i);
}
memset(was, 0, sizeof(was));
for (int i = (int)topsort.size() - 1; i >= 0; i--) {
if (!was[topsort[i]]) {
clr += 1;
dfs2(topsort[i]);
}
}
int ans = 0;
for (int i = 1; i <= clr; i++) {
if (!bad[i] && cmp[ans].size() > cmp[i].size()) ans = i;
}
cout << cmp[ans].size() << "\n";
for (int i : cmp[ans]) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 123456;
int u[MAXN], sz[MAXN], col[MAXN];
bool visit[MAXN];
vector<int> G[MAXN], rG[MAXN], fG[MAXN];
stack<int> stk;
set<int> outdeg[MAXN];
void dfs1(int cur) {
visit[cur] = 1;
for (auto i : G[cur])
if (!visit[i]) dfs1(i);
stk.push(cur);
}
void dfs2(int cur, int color) {
col[cur] = color;
sz[color]++;
for (int i : rG[cur])
if (!col[i]) dfs2(i, color);
}
int kosaragu(int n) {
for (int i = 1; i <= n; i++)
if (!visit[i]) dfs1(i);
int sum = 1;
while (!stk.empty()) {
int tp = stk.top();
stk.pop();
if (!col[tp]) dfs2(tp, sum++);
}
return sum;
}
int main() {
int n, m, h;
while (~scanf("%d %d %d", &n, &m, &h)) {
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
int xx = u[x], yy = u[y];
if (xx > yy) {
swap(xx, yy);
swap(x, y);
}
if (xx == yy - 1) {
G[x].push_back(y);
rG[y].push_back(x);
}
if (xx == (yy + 1) % h) {
G[y].push_back(x);
rG[x].push_back(y);
}
}
int col_num = kosaragu(n);
for (int i = 1; i <= n; i++) {
for (auto j : G[i]) {
if (col[j] != col[i]) outdeg[col[i]].insert(col[j]);
}
}
int ans = n, ans_c = 1;
for (int i = 1; i < col_num; i++) {
if ((int)outdeg[i].size() == 0 && sz[i] <= ans) {
ans = sz[i];
ans_c = i;
}
}
printf("%d\n", ans);
vector<int> OK;
for (int i = 1; i <= n; i++) {
if (col[i] == ans_c) OK.push_back(i);
}
for (int i : OK) printf("%d ", i);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
const int MAXN = 1e5 + 10;
const int MOD = 1e9 + 7;
int n, m, h, nn;
vector<int> c[MAXN], u(MAXN);
vector<vector<int>> scc, e, r;
vector<set<int>> v, av;
int d[MAXN];
int go(int first, bool print = false) {
int& ret = d[first];
if (~ret) return ret;
ret = int(scc[first - 1].size());
if (print) {
for (auto& second : scc[first - 1]) printf("%d ", second);
}
for (auto& second : v[first]) ret += go(second, print);
return ret;
}
using Graph = vector<vector<int>>;
int SCC(Graph& edge, Graph& redge, Graph& result) {
result.clear();
int n = edge.size() - 1;
vector<int> vis_i(n + 1, -1);
stack<int> rev;
for (int i = 1; i <= n; i++) {
if (vis_i[i] != -1) continue;
stack<int> s;
s.push(i);
while (!s.empty()) {
int u, i;
u = s.top();
i = vis_i[u];
for (++i; i < edge[u].size(); i++) {
int v = edge[u][i];
if (vis_i[v] == -1) {
s.push(v);
break;
}
}
vis_i[u] = i;
if (i == edge[u].size()) {
rev.push(u);
s.pop();
}
}
}
while (!rev.empty()) {
int i = rev.top();
rev.pop();
if (vis_i[i] == -2) continue;
result.push_back(vector<int>());
stack<int> s;
s.push(i);
while (!s.empty()) {
int u = s.top();
s.pop();
if (vis_i[u] == -2) continue;
vis_i[u] = -2;
for (auto& v : redge[u]) {
if (vis_i[v] != -2) s.push(v);
}
result.back().emplace_back(u);
}
}
return result.size();
}
int main() {
scanf("%d%d%d", &n, &m, &h);
e.resize(n + 1);
r.resize(n + 1);
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
for (int i = 0; i < m; i++) {
int first, second;
scanf("%d%d", &first, &second);
c[first].emplace_back(second);
c[second].emplace_back(first);
}
for (int i = 1; i <= n; i++) {
int nh = (u[i] + 1) % h;
for (auto& j : c[i])
if (nh == u[j] && i != j) e[i].emplace_back(j), r[j].emplace_back(i);
}
nn = SCC(e, r, scc);
v.resize(nn + 1);
vector<int> lab(n + 1);
{
int ptr = 0;
for (auto& xx : scc) {
for (auto& p : xx) lab[p] = ptr;
++ptr;
}
}
vector<bool> dirty(n + 1);
{
for (auto& p : scc) {
for (auto& q : p)
for (auto& r : e[q])
if (lab[r] != lab[q]) dirty[lab[q]] = true, v[lab[q]].emplace(lab[r]);
}
}
int ans = 0;
{
int i = -1, j = 0;
for (auto& p : scc) {
if (!dirty[j] & (i < 0 || p.size() < scc[i].size())) i = j;
++j;
}
ans = i;
}
printf("%d\n", (int)scc[ans].size());
for (auto& p : scc[ans]) printf("%d ", p);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100044;
const int INF = 1e9 + 7;
vector<int> G[MAXN], scc[MAXN];
int pre[MAXN], lowlink[MAXN], sccno[MAXN], dfs_clock, scc_cnt;
stack<int> S;
struct edge {
int from, to;
};
vector<edge> edges;
void dfs(int u) {
pre[u] = lowlink[u] = ++dfs_clock;
S.push(u);
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (!pre[v]) {
dfs(v);
lowlink[u] = min(lowlink[u], lowlink[v]);
} else if (!sccno[v])
lowlink[u] = min(lowlink[u], pre[v]);
}
if (lowlink[u] == pre[u]) {
scc_cnt++;
scc[scc_cnt].clear();
while (1) {
int x = S.top();
S.pop();
if (sccno[x] != scc_cnt) scc[scc_cnt].push_back(x);
sccno[x] = scc_cnt;
if (x == u) break;
}
}
}
void find_scc(int n) {
dfs_clock = scc_cnt = 0;
memset(sccno, 0, sizeof(sccno));
memset(pre, 0, sizeof(pre));
for (int i = 1; i <= n; ++i)
if (!pre[i]) dfs(i);
}
void adde(int u, int v) {
G[u].push_back(v);
edges.push_back(edge{u, v});
}
int n, m, h, H[MAXN], out[MAXN], u[MAXN], v[MAXN];
int trans(int x) { return (x + 1) % h; }
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) scanf("%d", H + i);
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (trans(H[x]) == H[y]) adde(x, y);
if (trans(H[y]) == H[x]) adde(y, x);
}
for (int i = 1; i <= n; ++i) reverse(G[i].begin(), G[i].end());
find_scc(n);
for (int i = 0; i < edges.size(); ++i) {
int x = edges[i].from;
int y = edges[i].to;
if (sccno[x] != sccno[y]) ++out[sccno[x]];
}
int ans = INF, ind;
for (int i = 1; i <= scc_cnt; ++i)
if (out[i] == 0 && scc[i].size() < ans) ans = scc[i].size(), ind = i;
printf("%d\n", ans);
for (int i = 0; i < scc[ind].size(); ++i)
printf("%d%c", scc[ind][i], " \n"[i == scc[ind].size() - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -f;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
x *= f;
}
void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (!x) return;
print(x / 10), putchar(x % 10 + 48);
}
void write(int x) {
if (!x)
putchar('0');
else
print(x);
putchar('\n');
}
const int maxn = 1e6 + 10;
const int inf = 1e9;
const double eps = 1e-8;
const int mod = 1e9 + 7;
int n, m, t, a[maxn], dfn[maxn], low[maxn], sta[maxn], top, cnt, in[maxn];
vector<int> e[maxn], ans;
void tarjan(int x) {
dfn[x] = low[x] = ++cnt, sta[++top] = x, in[x] = 1;
int t = top;
for (auto v : e[x])
if (!dfn[v])
tarjan(v), low[x] = min(low[x], low[v]);
else if (in[v])
low[x] = min(low[x], dfn[v]);
if (low[x] == dfn[x]) {
int bo = 0;
for (int i = t; i <= top; i++)
for (auto v : e[sta[i]])
if (!in[v]) bo = 1;
if (!bo && (!ans.size() || top - t + 1 < ans.size())) {
ans.clear();
for (int i = t; i <= top; i++) ans.push_back(sta[i]);
}
for (int i = t; i <= top; i++) in[sta[i]] = 0;
top = t - 1;
}
}
int main() {
read(n), read(m), read(t);
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= m; i++) {
int x, y;
read(x), read(y);
if ((a[x] + 1) % t == a[y]) e[x].push_back(y);
if ((a[y] + 1) % t == a[x]) e[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
write(ans.size());
for (auto v : ans) printf("%d ", v);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 100;
const int INF = 2147000000;
vector<int> G[maxn];
vector<int> SCC[maxn];
int u[maxn], c[maxn][2];
int in[maxn];
int n, m, h;
int pre[maxn], lowlink[maxn], sccno[maxn], dfs_clock, scc_cnt;
stack<int> S;
void dfs(int u) {
pre[u] = lowlink[u] = ++dfs_clock;
S.push(u);
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (!pre[v]) {
dfs(v);
lowlink[u] = min(lowlink[u], lowlink[v]);
} else if (!sccno[v]) {
lowlink[u] = min(lowlink[u], pre[v]);
}
}
if (lowlink[u] == pre[u]) {
scc_cnt++;
SCC[scc_cnt].clear();
for (;;) {
int x = S.top();
S.pop();
sccno[x] = scc_cnt;
SCC[scc_cnt].push_back(x);
if (x == u) break;
}
}
}
void find_scc(int n) {
dfs_clock = scc_cnt = 0;
memset(sccno, 0, sizeof(sccno));
memset(pre, 0, sizeof(pre));
for (int i = 1; i <= n; i++)
if (!pre[i]) dfs(i);
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &c[i][0], &c[i][1]);
if (u[c[i][0]] > u[c[i][1]]) swap(c[i][0], c[i][1]);
if (u[c[i][0]] + 1 == u[c[i][1]]) G[c[i][0]].push_back(c[i][1]);
if (u[c[i][0]] == 0 && u[c[i][1]] == h - 1) G[c[i][1]].push_back(c[i][0]);
}
find_scc(n);
int ans = 0;
int Min = INF;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < G[i].size(); j++) {
int v = G[i][j];
if (sccno[i] != sccno[v]) in[sccno[i]]++;
}
}
for (int i = 1; i <= scc_cnt; i++) {
if (!in[i]) {
if (Min > SCC[i].size()) {
Min = SCC[i].size();
ans = i;
}
}
}
printf("%d\n", Min);
for (int i = 0; i < SCC[ans].size(); i++) printf("%d ", SCC[ans][i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
int a[300005];
int lv, comp;
int d[300005], low[300005], scc[300005];
bool vis[300005], nope[300005];
int cnt[300005];
stack<int> s;
vector<int> edge[300005];
void tarjan(int v) {
d[v] = low[v] = lv++;
vis[v] = true;
s.push(v);
for (int i = 0; i < edge[v].size(); ++i) {
int u = edge[v][i];
if (d[u] == -1) {
tarjan(u);
low[v] = min(low[v], low[u]);
} else if (vis[u]) {
low[v] = min(low[v], low[u]);
}
}
if (d[v] == low[v]) {
int u;
do {
u = s.top();
s.pop();
vis[u] = false;
scc[u] = comp;
} while (v != u);
comp++;
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
scc[i] = -1;
d[i] = -1;
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
if ((a[x] + 1) % h == a[y]) edge[x].push_back(y);
if ((a[y] + 1) % h == a[x]) edge[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (d[i] == -1) {
tarjan(i);
}
}
for (int i = 0; i < n; i++) {
cnt[scc[i]]++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < edge[i].size(); j++) {
if (scc[i] != scc[edge[i][j]]) nope[scc[i]] = true;
}
}
int cid = -1;
for (int i = 0; i < n; i++) {
if (nope[scc[i]]) continue;
if (cid == -1 || cnt[scc[i]] < cnt[cid]) cid = scc[i];
}
printf("%d\n", cnt[cid]);
vector<int> ans_v;
for (int i = 0; i < n; i++) {
if (scc[i] == cid) {
ans_v.push_back(i + 1);
}
}
for (int i = 0; i < ans_v.size(); i++) {
if (i) printf(" ");
printf("%d", ans_v[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int hours[100007], konta[100007];
bool vis[100007];
vector<int> v[100007], v2[100007];
vector<int> scc[100007], graph[100007];
vector<int> topsort;
void dfs(int s) {
vis[s] = true;
for (int i = 0; i < v[s].size(); i++) {
int ve = v[s][i];
if (!vis[ve]) {
dfs(ve);
}
}
topsort.push_back(s);
}
void dfs2(int s, int cnt) {
vis[s] = true;
for (int i = 0; i < v2[s].size(); i++) {
int ve = v2[s][i];
if (!vis[ve]) {
dfs2(ve, cnt);
}
}
scc[cnt].push_back(s);
konta[s] = cnt;
}
int main() {
int n, m, h, i, j, k, l, x, y;
cin >> n >> m >> h;
for (i = 1; i <= n; i++) {
cin >> hours[i];
}
for (i = 0; i < m; i++) {
cin >> x >> y;
if (hours[y] == (hours[x] + 1) % h) {
v[x].push_back(y);
v2[y].push_back(x);
}
if (hours[x] == (hours[y] + 1) % h) {
v[y].push_back(x);
v2[x].push_back(y);
}
}
for (i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i);
}
}
reverse(topsort.begin(), topsort.end());
memset(vis, false, sizeof(vis));
int cnt = 0;
for (i = 0; i < n; i++) {
int s = topsort[i];
if (!vis[s]) {
dfs2(s, cnt);
cnt++;
}
}
for (i = 1; i <= n; i++) {
for (j = 0; j < v[i].size(); j++) {
x = i;
y = v[i][j];
if (konta[x] != konta[y]) {
graph[konta[x]].push_back(konta[y]);
}
}
}
int minn = 100007;
int ke;
for (i = 0; i < cnt; i++) {
if ((int)graph[i].size() == 0) {
if ((int)scc[i].size() < minn) {
minn = (int)scc[i].size();
ke = i;
}
}
}
cout << minn << endl;
for (i = 0; i < scc[ke].size(); i++) {
cout << scc[ke][i] << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5;
const int LOGN = 0;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 10;
const long long INFLL = (long long)1e18 + 10;
int N, M, H;
int u[MAXN + 10];
pair<int, int> c[MAXN + 10];
vector<int> adjl[MAXN + 10];
vector<int> tadjl[MAXN + 10];
bool visited[MAXN + 10], assigned[MAXN + 10];
list<int> l;
vector<int> components[MAXN + 10];
int component_of[MAXN + 10];
bool has_out[MAXN + 10];
void read() {
cin >> N >> M >> H;
for (int(i) = 1; (i) <= (N); ++(i)) cin >> u[i];
for (int(i) = 1; (i) <= (M); ++(i)) cin >> c[i].first >> c[i].second;
return;
}
int next_hour(int x) { return (x + 1) % H; }
void build() {
for (int(i) = 1; (i) <= (M); ++(i)) {
if (next_hour(u[c[i].first]) == u[c[i].second]) {
adjl[c[i].first].push_back(c[i].second);
tadjl[c[i].second].push_back(c[i].first);
}
if (next_hour(u[c[i].second]) == u[c[i].first]) {
adjl[c[i].second].push_back(c[i].first);
tadjl[c[i].first].push_back(c[i].second);
}
}
return;
}
void visit(int node) {
if (!visited[node]) {
visited[node] = true;
for (auto(it) : (adjl[node])) visit(it);
l.push_front(node);
}
return;
}
void assign(int node, int root) {
if (!assigned[node]) {
assigned[node] = true;
components[root].push_back(node);
component_of[node] = root;
for (auto(it) : (tadjl[node])) assign(it, root);
}
return;
}
void kosaraju() {
for (int(i) = 1; (i) <= (N); ++(i)) visit(i);
for (auto(it) : (l)) assign(it, it);
return;
}
void select() {
pair<int, int> ans = pair<int, int>(INF, INF);
for (int(i) = 1; (i) <= (N); ++(i)) {
if (components[i].size()) {
for (auto(it) : (components[i])) {
for (auto(neigh) : (adjl[it])) {
if (component_of[neigh] != i) has_out[i] = true;
}
}
if (!has_out[i]) ans = min(ans, pair<int, int>(components[i].size(), i));
}
}
cout << ans.first;
cout << "\n";
for (auto(it) : (components[ans.second])) cout << it << " ";
cout << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
read();
build();
kosaraju();
select();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> drogi[1000010];
vector<int> trans[1000010];
stack<int> stos;
int val[1000010];
bool czy[1000010];
int ojciec[1000010];
int f(int gdzie) {
if (ojciec[gdzie] == gdzie) return gdzie;
return ojciec[gdzie] = f(ojciec[gdzie]);
}
void u(int a, int b) { ojciec[f(a)] = f(b); }
void dfs(int gdzie) {
czy[gdzie] = true;
for (int i : drogi[gdzie]) {
if (!czy[i]) {
dfs(i);
}
}
stos.push(gdzie);
}
void dfs2(int gdzie) {
czy[gdzie] = false;
for (int i : trans[gdzie]) {
if (czy[i]) {
u(gdzie, i);
dfs2(i);
}
}
}
int wie[1000010];
bool kon[1000010];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, h;
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
cin >> val[i];
ojciec[i] = i;
}
for (int a, b, i = 0; i < m; i++) {
cin >> a >> b;
if ((val[a] + 1) % h == val[b]) {
drogi[a].push_back(b);
trans[b].push_back(a);
}
swap(a, b);
if ((val[a] + 1) % h == val[b]) {
drogi[a].push_back(b);
trans[b].push_back(a);
}
}
for (int i = 1; i <= n; i++) {
if (!czy[i]) dfs(i);
}
while (!stos.empty()) {
if (czy[stos.top()]) dfs2(stos.top());
stos.pop();
}
for (int i = 1; i <= n; i++) {
wie[f(i)]++;
for (int j : drogi[i]) {
if (f(j) != f(i)) kon[f(i)] = true;
}
}
int res = n + 1;
int id;
for (int i = 1; i <= n; i++) {
if (f(i) != i) continue;
if (kon[i]) continue;
if (res > wie[i]) {
res = wie[i];
id = i;
}
}
cout << res << "\n";
for (int i = 1; i <= n; i++) {
if (f(i) == id) {
cout << i << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T lcm(T a, T b) {
a = abs(a);
b = abs(b);
return (a / gcd(a, b)) * b;
}
template <class T, class X>
inline bool getbit(T a, X i) {
T t = 1;
return ((a & (t << i)) > 0);
}
template <class T, class X>
inline T setbit(T a, X i) {
T t = 1;
return (a | (t << i));
}
template <class T, class X>
inline T resetbit(T a, X i) {
T t = 1;
return (a & (~(t << i)));
}
inline long long getnum() {
char c = getchar();
long long num, sign = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') sign = -1;
for (num = 0; c >= '0' && c <= '9';) {
c -= '0';
num = num * 10 + c;
c = getchar();
}
return num * sign;
}
inline long long power(long long a, long long b) {
long long multiply = 1;
for (int i = (0); i < (b); i++) {
multiply *= a;
}
return multiply;
}
stack<int> st;
vector<vector<int> > scc;
int low[100005], disc[100005], comp[100005];
int dfs_time, off[100005];
bool in_stack[100005];
vector<int> graph[100005];
int n, csize[100005];
void dfs(int u) {
low[u] = dfs_time;
disc[u] = dfs_time;
dfs_time++;
in_stack[u] = true;
st.push(u);
int sz = graph[u].size(), v;
for (int i = 0; i < sz; i++) {
v = graph[u][i];
if (disc[v] == -1) {
dfs(v);
low[u] = min(low[u], low[v]);
} else if (in_stack[v] == true)
low[u] = min(low[u], disc[v]);
}
if (low[u] == disc[u]) {
scc.push_back(vector<int>());
while (st.top() != u) {
scc[scc.size() - 1].push_back(st.top());
in_stack[st.top()] = false;
st.pop();
}
scc[scc.size() - 1].push_back(u);
in_stack[u] = false;
st.pop();
}
}
int tarjan() {
memset(comp, -1, sizeof(comp));
memset(disc, -1, sizeof(disc));
memset(low, -1, sizeof(low));
memset(in_stack, 0, sizeof(in_stack));
dfs_time = 0;
while (!st.empty()) st.pop();
for (int i = 1; i <= n; i++)
if (disc[i] == -1) dfs(i);
int sz = scc.size();
for (int i = 0; i < sz; i++)
for (int j = 0; j < (int)scc[i].size(); j++)
comp[scc[i][j]] = i, csize[i]++;
return sz;
}
bool visited[100005];
int in[100005];
long long dp[100005];
vector<int> dag[100005];
map<pair<int, int>, bool> done;
void gendag(int u) {
visited[u] = true;
for (auto v : graph[u]) {
if (comp[u] != comp[v] && done.find({comp[u], comp[v]}) == done.end()) {
dag[comp[u]].push_back(comp[v]);
in[comp[v]]++;
done[{comp[u], comp[v]}] = true;
}
if (!visited[v]) gendag(v);
}
}
void go(int u) {
visited[u] = true;
dp[u] = csize[u];
for (auto v : dag[u]) {
if (!visited[v]) {
go(v);
}
dp[u] += dp[v];
}
}
int main() {
int test, cases = 1;
int m, h;
scanf("%d%d%d", &n, &m, &h);
for (int i = (1); i < (n + 1); i++) scanf("%d", &off[i]);
int u, v;
for (int i = (1); i < (m + 1); i++) {
scanf("%d%d", &u, &v);
if ((off[u] + 1) % h == off[v]) {
graph[u].push_back(v);
}
if ((off[v] + 1) % h == off[u]) {
graph[v].push_back(u);
}
}
int sz = tarjan();
for (int i = (1); i < (n + 1); i++) {
if (!visited[i]) gendag(i);
}
memset(visited, false, sizeof(visited));
for (int i = (0); i < (sz); i++) {
if (in[i] == 0) {
go(i);
}
}
int mnsz = 1e8, idx = 0;
for (int i = (0); i < (sz); i++) {
if (dp[i] < mnsz) {
mnsz = csize[i];
idx = i;
}
}
printf("%d\n", mnsz);
for (int i = (1); i < (n + 1); i++)
if (comp[i] == idx) printf("%d ", i);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T>
constexpr int infValue =
std::is_same<T, int>::value ? 2000000007 : 8600000000000000007ll;
template <typename T>
constexpr int maxValue =
std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;
const int INF = infValue<int>;
const int MOD = 1000000007ll;
const double EPS = 1e-6;
const int MAX = maxValue<int>;
int n, m, h;
int ut[101001];
vector<int> g[101001], gr[101001];
int u[101001], cv = 1;
vector<int> p;
void dfs1(int v) {
u[v] = cv;
for (int to : g[v]) {
if (!u[to]) dfs1(to);
}
p.push_back(v);
}
bool use;
vector<int> cmp, acmp;
void dfs2(int v) {
u[v] = cv;
cmp.push_back(v);
for (int to : gr[v])
if (u[to] == 1) dfs2(to);
}
void dfs3(int v) {
for (int to : g[v])
if (u[to] != cv) use = false;
}
int c0, c1;
int main(void) {
scanf("%d %d %d", &n, &m, &h);
for (register int i = 1; i <= n; ++i) scanf("%d", ut + i);
while (m--) {
scanf("%d %d", &c0, &c1);
if ((ut[c0] + 1) % h == ut[c1]) g[c0].push_back(c1), gr[c1].push_back(c0);
if ((ut[c1] + 1) % h == ut[c0]) g[c1].push_back(c0), gr[c0].push_back(c1);
}
for (register int i = 1; i <= n; ++i)
if (!u[i]) dfs1(i);
for (register int i = p.size() - 1; i >= 0; --i) {
if (u[p[i]] == 1) {
++cv, use = true, cmp.clear();
dfs2(p[i]);
for (int v : cmp) {
dfs3(v);
}
if (use && (acmp.empty() || cmp.size() < acmp.size())) swap(cmp, acmp);
}
}
printf("%d\n", acmp.size());
for (int v : acmp) printf("%d ", v);
putc('\n', stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, k, m, h, u[N], use[N], c1, c2, b1, b2, nrc, ans, ind, cc[N];
stack<int> s;
vector<int> v[N], vt[N], c[N];
set<int> g[N];
template <class T>
ostream& operator<<(ostream& out, vector<T> v) {
out << v.size() << '\n';
for (auto e : v) out << e << ' ';
return out;
}
void dfs1(int k) {
use[k] = 1;
for (auto i : v[k])
if (!use[i]) dfs1(i);
s.push(k);
}
void dfs2(int k) {
use[k] = 1;
for (auto i : vt[k])
if (!use[i]) dfs2(i);
c[nrc].push_back(k);
cc[k] = nrc;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> h;
ans = n + 1;
for (int i = 1; i <= n; i++) cin >> u[i];
for (int i = 1; i <= m; i++) {
cin >> b1 >> b2;
assert(u[b1] != u[b2]);
if (u[b1] > u[b2]) swap(b1, b2);
if (u[b1] == 0 && u[b2] == h - 1) {
v[b2].push_back(b1);
vt[b1].push_back(b2);
}
if (u[b1] + 1 == u[b2]) {
v[b1].push_back(b2);
vt[b2].push_back(b1);
}
}
for (int i = 1; i <= n; i++)
if (v[i].size() == 0) return cout << "1\n" << i << '\n', 0;
for (int i = 1; i <= n; i++)
if (!use[i]) dfs1(i);
memset(use, 0, sizeof use);
while (!s.empty()) {
int a = s.top();
s.pop();
if (!use[a]) nrc++, dfs2(a);
}
for (int i = 1; i <= nrc; i++)
for (auto j : c[i])
for (auto k : v[j]) g[i].insert(cc[k]);
for (int i = 1; i <= nrc; i++)
if (ans > c[i].size() && c[i].size() > 1 && g[i].size() == 1)
ans = c[i].size(), ind = i;
cerr << "ind"
": "
<< ind << "\n";
cout << c[ind];
return 0;
}
|
#include <bits/stdc++.h>
const long long MXN = 1e6 + 1;
const long long MNN = 1e3 + 1;
const long long MOD = 10;
const long long INF = 1e18;
const long long OO = 1e6 + 1;
const double pi = 3.141592653589;
using namespace std;
int n, m, k, h[MXN], H, ans = OO, c[MXN];
vector<int> q[MXN], g[MXN], lst, comp, ansV;
bool used[MXN];
bool another;
void dfs(int x) {
used[x] = 1;
for (int i = 0; i < g[x].size(); i++) {
int to = g[x][i];
if (used[to] == 0) {
dfs(to);
}
}
lst.push_back(x);
}
void dfs1(int x, int cmp) {
used[x] = 1;
c[x] = cmp;
comp.push_back(x);
for (int i = 0; i < q[x].size(); i++) {
int to = q[x][i];
if (used[to] == 0) {
dfs1(to, cmp);
} else if (c[to] != cmp) {
another = 1;
}
}
}
int main() {
ios_base::sync_with_stdio(0), cout.tie(0), cin.tie(0);
;
cin >> n >> m >> H;
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
if ((h[u] + 1) % H == h[v]) {
q[u].push_back(v);
g[v].push_back(u);
}
if ((h[v] + 1) % H == h[u]) {
q[v].push_back(u);
g[u].push_back(v);
}
}
for (int i = 1; i <= n; i++) {
if (used[i] == 0) {
dfs(i);
}
used[i] = 0;
}
reverse(lst.begin(), lst.end());
int cnt = 0;
for (int i = 0; i < lst.size(); i++) {
int x = lst[i];
if (used[x] == 0) {
comp.clear();
cnt++;
another = 0;
dfs1(x, cnt);
if (!another && comp.size() < ans) {
ans = comp.size();
ansV = comp;
}
}
}
cout << ans << '\n';
for (int i = 0; i < ansV.size(); i++) {
cout << ansV[i] << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NN = 200005;
vector<int> vv[NN];
void _addedge(int x, int y) { vv[x].push_back(y); }
int dfn[NN], low[NN], stk[NN], blo[NN], block, Cnt, Now;
int ins[NN];
void tarjan(int n) {
int i, j;
low[n] = dfn[n] = ++Cnt, ins[stk[++Now] = n] = 1;
for (i = 0; i < vv[n].size(); i++)
if (dfn[j = vv[n][i]] == 0)
tarjan(j), low[n] = min(low[n], low[j]);
else if (ins[j])
low[n] = min(low[n], low[j]);
if (dfn[n] == low[n] && ++block) do
blo[i = stk[Now--]] = block, ins[i] = 0;
while (i != n);
}
int uu[NN];
vector<int> ans[NN];
bool vs[NN];
void check(int n) {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < vv[i].size(); j++)
if (blo[i] != blo[vv[i][j]]) vs[blo[i]] = 1;
}
for (int i = 1; i <= n; i++) ans[blo[i]].push_back(i);
int best = n + 1;
int index = 0;
for (int i = 1; i <= block; i++)
if (!vs[i]) {
if (best > ans[i].size()) {
best = ans[i].size();
index = i;
}
}
printf("%d\n", ans[index].size());
for (int i = 0; i < ans[index].size(); i++)
printf("%d%c", ans[index][i], i == ans[index].size() ? '\n' : ' ');
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) scanf("%d", &uu[i]);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
int v1 = uu[x], v2 = uu[y];
if (v1 < v2) {
if (v1 + 1 == v2) _addedge(x, y);
if (v1 == 0 && v2 == k - 1) _addedge(y, x);
}
if (v2 < v1) {
if (v2 + 1 == v1) _addedge(y, x);
if (v2 == 0 && v1 == k - 1) _addedge(x, y);
}
}
for (int i = 1; i <= n; i++)
if (dfn[i] == 0) tarjan(i);
check(n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long v, next;
} e[200005];
long long top = 1;
long long head[200005];
void Add_Edge(long long u, long long v) {
e[++top] = edge{v, head[u]};
head[u] = top;
}
long long n, m, h, cnt, Index;
long long value[200005];
long long chu[200005], dfn[200005], low[200005], size[200005], belong[200005];
bool vis[200005];
stack<long long> s;
long long Abs(long long x) { return x > 0 ? x : -x; }
void Tarjan(long long u) {
vis[u] = 1;
s.push(u);
dfn[u] = low[u] = ++Index;
for (register long long i = head[u]; i; i = e[i].next) {
long long v = e[i].v;
if (!dfn[v]) {
Tarjan(v);
low[u] = min(low[u], low[v]);
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
++cnt;
while (1) {
long long v = s.top();
s.pop();
vis[v] = 0;
size[cnt]++;
belong[v] = cnt;
if (v == u) break;
}
}
}
long long read() {
long long x = 0;
char c = getchar();
long long f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * f;
}
void write(long long x) {
if (x < 0) {
x = -x;
putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
signed main() {
n = read(), m = read(), h = read();
for (register long long i = 1; i <= n; ++i) value[i] = read();
long long Ans = 0;
for (register long long i = 1; i <= m; ++i) {
long long u = read(), v = read();
if ((value[u] + 1) % h == value[v]) Add_Edge(u, v);
if ((value[v] + 1) % h == value[u]) Add_Edge(v, u);
}
for (register long long i = 1; i <= n; ++i)
if (!dfn[i]) Tarjan(i);
for (register long long i = 1; i <= n; ++i)
for (register long long j = head[i]; j; j = e[j].next) {
long long v = e[j].v;
if (belong[i] != belong[v]) chu[belong[i]]++;
}
long long ans = 0;
size[0] = 0x3f3f3f3f3f;
for (register long long i = 1; i <= cnt; ++i)
if (!chu[i])
if (size[i] < size[ans]) ans = i;
write(size[ans]), putchar('\n');
for (register long long i = 1; i <= n; ++i)
if (belong[i] == ans) write(i), putchar(' ');
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
int a[200002];
int t[200002][2];
int k;
vector<int> g[200002];
vector<int> gr[200002];
vector<int> gg[200002];
vector<int> order;
vector<int> ver[200002];
int c[200002], cc;
void dfs(int v) {
c[v] = cc;
for (const int& v2 : g[v]) {
if (c[v2] == cc) continue;
dfs(v2);
}
order.push_back(v);
}
void dfs2(int v, int color) {
ver[color - 1].push_back(v);
c[v] = color;
for (const int& v2 : gr[v]) {
if (c[v2]) continue;
dfs2(v2, color);
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < m; ++i) {
scanf("%d%d", &t[i][0], &t[i][1]);
--t[i][0], --t[i][1];
if ((a[t[i][0]] + 1) % h == a[t[i][1]]) {
g[t[i][0]].push_back(t[i][1]);
gr[t[i][1]].push_back(t[i][0]);
}
if ((a[t[i][1]] + 1) % h == a[t[i][0]]) {
g[t[i][1]].push_back(t[i][0]);
gr[t[i][0]].push_back(t[i][1]);
}
}
++cc;
for (int i = 0; i < n; ++i) {
if (c[i] == cc) continue;
dfs(i);
}
memset(c, 0, sizeof(c));
for (int i = 0; i < n; ++i) {
int v = order[n - 1 - i];
if (c[v]) continue;
dfs2(v, ++k);
}
for (int i = 0; i < n; ++i) {
for (const int& v2 : g[i]) {
if (c[i] == c[v2]) continue;
gg[c[i] - 1].push_back(c[v2] - 1);
}
}
for (int i = 0; i < k; ++i) {
sort(gg[i].begin(), gg[i].end());
gg[i].erase(unique(gg[i].begin(), gg[i].end()), gg[i].end());
}
int ind = -1;
for (int i = 0; i < k; ++i) {
if ((int(gg[i].size()))) continue;
if (ind == -1 || (int(ver[ind].size())) > (int(ver[i].size()))) ind = i;
}
printf("%d\n", (int(ver[ind].size())));
for (int i = 0; i < (int(ver[ind].size())); ++i)
printf("%d%c", ver[ind][i] + 1, " \n"[i + 1 == (int(ver[ind].size()))]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool dbg = 0;
clock_t start_time = clock();
void bad(string mes = "Impossible") {
cout << mes;
exit(0);
}
void bad(int mes) {
cout << mes;
exit(0);
}
template <typename T>
string bin(T x, int st = 2) {
string ans = "";
while (x > 0) {
ans += char('0' + x % st);
x /= st;
}
reverse(ans.begin(), ans.end());
return ans.empty() ? "0" : ans;
}
template <typename T>
void amax(T& x, T y) {
x = max(x, y);
}
template <typename T>
void amin(T& x, T y) {
x = min(x, y);
}
template <typename T>
T input() {
T ans = 0, m = 1;
char c = ' ';
while (!((c >= '0' && c <= '9') || c == '-')) {
c = getchar();
}
if (c == '-') m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + (c - '0'), c = getchar();
}
return ans * m;
}
template <typename T>
void read(T& a) {
a = input<T>();
}
template <typename T>
void read(T& a, T& b) {
read(a), read(b);
}
template <typename T>
void read(T& a, T& b, T& c) {
read(a, b), read(c);
}
template <typename T>
void read(T& a, T& b, T& c, T& d) {
read(a, b), read(c, d);
}
const int inf = 1e9 + 20;
const short short_inf = 3e4 + 20;
const long double eps = 1e-15;
const int maxn = (int)1e5 + 12, base = 1e9 + 7;
const long long llinf = 2e18 + 5;
template <typename T>
T binpow(T n, T second) {
if (second <= 0) return 1LL;
if (second % 2 == 0) {
T b = binpow(n, second / 2);
return (1LL * b * b) % base;
} else {
return (1LL * binpow(n, second - 1) * n) % base;
}
}
vector<int> g[maxn], gr[maxn];
bool used[maxn];
int u[maxn];
vector<int> cmp, order;
void dfs1(int v) {
used[v] = 1;
for (int to : g[v])
if (!used[to]) dfs1(to);
order.push_back(v);
}
void dfs2(int v) {
used[v] = 1;
cmp.push_back(v);
for (int to : gr[v])
if (!used[to]) dfs2(to);
}
int comp[maxn], sz[maxn];
int main() {
int n, m, h;
ios_base::sync_with_stdio(0);
cin.tie(0);
read(n, m, h);
for (int i = 0; i < n; i++) {
read(u[i]);
}
for (int i = 0; i < m; i++) {
int a, b;
read(a, b);
a--, b--;
if (u[a] + 1 == u[b] || (u[a] == h - 1 && u[b] == 0)) {
g[a].push_back(b);
gr[b].push_back(a);
}
swap(a, b);
if (u[a] + 1 == u[b] || (u[a] == h - 1 && u[b] == 0)) {
g[a].push_back(b);
gr[b].push_back(a);
}
}
memset(used, 0, sizeof(used));
for (int i = 0; i < n; i++)
if (!used[i]) dfs1(i);
memset(used, 0, sizeof(used));
for (int i = n - 1; i >= 0; i--) {
int v = order[i];
if (!used[v]) {
cmp.clear();
dfs2(v);
for (int j : cmp) {
comp[j] = v;
sz[v]++;
}
}
}
for (int i = 0; i < n; i++) {
for (int to : g[i])
if (comp[to] != comp[i]) {
sz[comp[i]] = 0;
}
}
int res = inf, ans;
for (int i = 0; i < n; i++) {
if (sz[i] > 0 && sz[i] < res) {
res = sz[i];
ans = i;
}
}
cout << res << '\n';
for (int i = 0; i < n; i++)
if (comp[i] == ans) cout << i + 1 << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int nr, c, vaz[100010], v1[100010], val[100010], vaz1[100010], vaz2[100010];
vector<int> v[100010];
vector<int> vt[100010];
vector<int> r[100010];
void dfs(int nod) {
vaz[nod] = 1;
for (int i = 0; i < v[nod].size(); i++)
if (vaz[v[nod][i]] == 0) dfs(v[nod][i]);
v1[++nr] = nod;
}
void dfs1(int nod) {
vaz[nod] = 0;
r[c].push_back(nod);
vaz1[nod] = c;
for (int i = 0; i < vt[nod].size(); i++)
if (vaz[vt[nod][i]] == 1) dfs1(vt[nod][i]);
}
int main() {
int n, m, h, x, y;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
if ((val[x] + 1) % h == val[y]) {
v[x].push_back(y);
vt[y].push_back(x);
}
if ((val[y] + 1) % h == val[x]) {
v[y].push_back(x);
vt[x].push_back(y);
}
}
for (int i = 1; i <= n; i++)
if (vaz[i] == 0) dfs(i);
for (int i = nr; i >= 1; i--)
if (vaz[v1[i]] == 1) {
c++;
dfs1(v1[i]);
}
int sol = inf;
for (int i = 1; i <= c; i++) {
int a = r[i].size(), p = 0;
for (int j = 0; j < r[i].size(); j++) {
int nod = r[i][j];
for (int k = 0; k < v[nod].size(); k++)
if (vaz1[v[nod][k]] != i) {
p = 1;
break;
}
if (p == 1) break;
}
if (p == 0) {
vaz2[i] = 1;
sol = min(sol, a);
}
}
if (sol < inf) printf("%d\n", sol);
for (int i = 1; i <= c; i++)
if (vaz2[i] == 1 && r[i].size() == sol) {
for (int j = 0; j < r[i].size(); j++) printf("%d ", r[i][j]);
return 0;
}
printf("%d\n", n);
for (int i = 1; i <= n; i++) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100004;
int pre[N], vis[N], low[N];
vector<int> g[N];
int u[N], sz[N], sccno[N], out[N];
int clk, cnt;
stack<int> stk;
void dfs(int u) {
low[u] = pre[u] = ++clk;
vis[u] = 1;
stk.push(u);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!pre[v]) {
dfs(v);
low[u] = min(low[u], low[v]);
} else
low[u] = min(low[u], pre[v]);
}
if (low[u] == pre[u]) {
cnt++;
while (1) {
int x = stk.top();
vis[x] = 0;
stk.pop();
sz[cnt]++;
sccno[x] = cnt;
if (x == u) break;
}
}
}
int main() {
int n, m, h;
scanf("%d %d %d", &n, &m, &h);
int i;
for (i = 1; i <= n; i++) scanf("%d", &u[i]);
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
if ((u[x] + 1) % h == u[y]) g[x].push_back(y);
if ((u[y] + 1) % h == u[x]) g[y].push_back(x);
}
for (i = 1; i <= n; i++) {
if (!pre[i]) dfs(i);
}
for (i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
int x = i, y = g[i][j];
if (sccno[x] == sccno[y]) continue;
out[sccno[x]] = 1;
}
}
int ans = 1e9, idx;
for (i = 1; i <= cnt; i++) {
if (!out[i] && sz[i] < ans) {
ans = sz[i];
idx = i;
}
}
printf("%d\n", ans);
for (i = 1; i <= n; i++) {
if (sccno[i] == idx) printf("%d ", i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:60777216")
const int max_n = 100050;
int n;
vector<int> neigh[max_n];
int val[max_n];
int c;
int s[max_n], s_ed;
int b[2 * max_n], b_ed;
void run_dfs(int v) {
s[++s_ed] = v;
val[v] = s_ed;
b[++b_ed] = val[v];
for (int j = 0; j < int(neigh[v].size()); j++) {
int w = neigh[v][j];
if (val[w] == -1)
run_dfs(w);
else
while (val[w] < b[b_ed]) b_ed--;
}
if (val[v] == b[b_ed]) {
b_ed--;
c++;
while (val[v] <= s_ed) val[s[s_ed--]] = c;
}
}
void strong() {
s_ed = b_ed = -1;
for (int v = 0; v < n; v++) val[v] = -1;
c = n - 1;
for (int v = 0; v < n; v++)
if (val[v] == -1) run_dfs(v);
for (int v = 0; v < n; v++)
if (val[v] != -1) val[v] -= n;
}
const int inf = 1000000000;
int ans = inf;
int ans_v;
bool vis[max_n] = {false};
bool is_sink;
int dfs(int v) {
assert(vis[v] == false);
int sz = 1;
vis[v] = true;
for (int w : neigh[v]) {
if (val[w] == val[v] && !vis[w]) {
sz += dfs(w);
}
if (val[w] != val[v]) is_sink = false;
}
return sz;
}
void print(int v) {
assert(vis[v] == false);
printf("%d ", v + 1);
vis[v] = true;
for (int w : neigh[v])
if (!vis[w]) print(w);
}
void run() {
for (int i = 0; i < n; i++)
if (!vis[i]) {
is_sink = true;
int sz = dfs(i);
if (is_sink && ans > sz) {
ans = sz;
ans_v = i;
}
}
for (int i = 0; i < n; i++) vis[i] = false;
printf("%d\n", ans);
print(ans_v);
printf("\n");
}
int u[100050];
int c1[100050], c2[100050];
int main() {
scanf("%d", &n);
int m, h;
scanf("%d %d", &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
for (int i = 0; i < m; i++) scanf("%d %d", &c1[i], &c2[i]);
for (int i = 0; i < m; i++) {
if ((u[c1[i]] + 1) % h == u[c2[i]]) neigh[c1[i] - 1].push_back(c2[i] - 1);
if ((u[c2[i]] + 1) % h == u[c1[i]]) neigh[c2[i] - 1].push_back(c1[i] - 1);
}
strong();
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, m, h, st[N], sz[N], vis[N], cnt, scnt, vd[N], sn[N], a[N];
vector<int> vec[N], vec2[N];
void dfs1(int x) {
if (vis[x]) return;
vis[x] = 1;
for (int i = 0; i < vec[x].size(); i++) dfs1(vec[x][i]);
st[++cnt] = x;
}
void dfs2(int x) {
if (sn[x]) {
if (sn[x] != scnt) vd[sn[x]] = 1;
return;
}
sn[x] = scnt;
sz[scnt]++;
for (int i = 0; i < vec2[x].size(); i++) dfs2(vec2[x][i]);
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if ((a[u] - a[v] + h) % h == 1) vec[v].push_back(u), vec2[u].push_back(v);
if ((a[v] - a[u] + h) % h == 1) vec[u].push_back(v), vec2[v].push_back(u);
}
for (int i = 1; i <= n; i++) dfs1(i);
for (int i = n; i; i--)
if (!sn[st[i]]) {
scnt++;
dfs2(st[i]);
}
int ans = 0;
sz[0] = n + 1;
for (int i = 1; i <= scnt; i++)
if (!vd[i] && sz[i] < sz[ans]) ans = i;
printf("%d\n", sz[ans]);
for (int i = 1; i <= n; i++)
if (sn[i] == ans) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 163577857;
const long long linf = 1ll * inf * inf;
const int N = 1000000 + 7;
const int M = 20;
const int multipleTest = 0;
int n, m, h;
int a[N];
vector<int> adj[N], radj[N];
int color[N], num[N], low[N];
int cnt;
int comp;
vector<int> ver[N];
int nxt(int u) { return (u + 1) % h; }
void dfs(int u) {
static vector<int> stack;
stack.push_back(u);
num[u] = low[u] = ++cnt;
for (int v : adj[u]) {
if (color[v]) continue;
if (!num[v]) {
dfs(v);
low[u] = min(low[u], low[v]);
} else {
low[u] = min(low[u], num[v]);
}
}
if (low[u] == num[u]) {
color[u] = ++comp;
ver[comp].push_back(u);
while (stack.back() != u) {
color[stack.back()] = comp;
ver[comp].push_back(stack.back());
stack.pop_back();
}
stack.pop_back();
}
}
void solve() {
cin >> n >> m >> h;
for (int i = (1), _b = (n + 1); i < _b; ++i) scanf("%d", a + i);
while (m-- > 0) {
int u, v;
scanf("%d%d", &u, &v);
if (nxt(a[u]) == a[v]) {
adj[u].push_back(v);
radj[v].push_back(u);
}
if (nxt(a[v]) == a[u]) {
adj[v].push_back(u);
radj[u].push_back(v);
}
}
for (int i = 1; i <= n; ++i)
if (!num[i]) dfs(i);
int id = 0;
for (int i = 1; i <= comp; ++i) {
bool isLeaf = true;
for (int u : ver[i]) {
for (int v : adj[u])
if (color[u] != color[v]) isLeaf = false;
}
if (isLeaf) {
if (id == 0 || ver[id].size() > ver[i].size()) id = i;
}
}
cout << ver[id].size() << '\n';
for (int x : ver[id]) cout << x << ' ';
}
int main() {
int Test = 1;
if (multipleTest) {
cin >> Test;
}
for (int i = 0; i < Test; ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long ool = 1e18 + 9;
const int oo = 1e9 + 9, base = 1e9 + 7;
const double eps = 1e-7;
const int N = 2e5 + 6;
int n, m, H, cnt, col[N], a[N];
bool bad[N], u[N];
vector<int> g[N], rg[N], vec[N], tps;
void dfs(int v) {
u[v] = 1;
for (auto to : g[v]) {
if (!u[to]) dfs(to);
}
tps.emplace_back(v);
}
void dfs2(int v) {
col[v] = cnt;
vec[cnt].emplace_back(v);
u[v] = 1;
for (auto to : rg[v]) {
if (!u[to]) dfs2(to);
}
}
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> H;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
if ((a[x] + 1) % H == a[y]) {
g[x].emplace_back(y);
rg[y].emplace_back(x);
}
if ((a[y] + 1) % H == a[x]) {
g[y].emplace_back(x);
rg[x].emplace_back(y);
}
}
for (int i = 1; i <= n; ++i) {
if (!u[i]) dfs(i);
}
reverse(tps.begin(), tps.end());
for (int i = 1; i <= n; ++i) u[i] = 0;
for (auto it : tps) {
if (!u[it]) {
++cnt;
dfs2(it);
}
}
for (int i = 1; i <= n; ++i) {
for (auto to : g[i]) {
if (col[i] != col[to]) bad[col[i]] = 1;
}
}
int mn = 0;
for (int i = 1; i <= cnt; ++i) {
if (bad[i]) continue;
if (!mn || (int)vec[mn].size() > (int)vec[i].size()) mn = i;
}
cout << (int)vec[mn].size() << "\n";
for (auto it : vec[mn]) {
cout << it << " ";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, next;
} e[2393939];
inline int read() {
int x = 0, w = 0;
char ch = getchar();
while (!isdigit(ch)) w |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
return w ? -x : x;
}
int k, res, w[393939], mx, a[2393939], cnt, head[393939], out[393939], n, m,
mod, ans[393939], st[393939], dfn[393939], low[393939], num, top,
color[393939], col;
inline void add(int u, int v) {
e[++cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
}
void Tarjan(int u) {
low[u] = dfn[u] = ++num;
st[++top] = u;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].to;
if (!dfn[v]) {
Tarjan(v);
low[u] = min(low[u], low[v]);
} else if (!color[v])
low[u] = min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
color[u] = ++col;
++w[col];
while (st[top] != u) ++w[col], color[st[top--]] = col;
--top;
}
}
signed main() {
n = read(), m = read(), k = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
if ((a[u] + 1) % k == a[v]) add(u, v);
if ((a[v] + 1) % k == a[u]) add(v, u);
}
for (int i = 1; i <= n; ++i)
if (!color[i]) Tarjan(i);
for (int t = 1; t <= n; ++t)
for (int i = head[t]; i; i = e[i].next) {
int v = e[i].to;
if (color[t] == color[v]) continue;
++out[color[t]];
}
int ans = 0;
w[0] = 0x3f3f3f3f;
for (int i = 1; i <= col; ++i)
if (out[i] == 0 && w[i] < w[ans]) ans = i;
printf("%d\n", w[ans]);
for (int i = 1; i <= n; ++i)
if (color[i] == ans) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 5;
class Graph {
public:
class Node {
public:
bool isVisited;
int id, sccInd;
vector<Node *> v, revV;
};
int cntNodes, cntSccs;
Node nodes[MAX_N];
void Init(int cntNodes) {
this->cntNodes = cntNodes;
for (int i = 1; i <= cntNodes; i++) {
nodes[i].id = i;
}
}
void MarkAllNodesUnvisited() {
for (int i = 1; i <= cntNodes; i++) {
nodes[i].isVisited = false;
}
}
void AddEdge(int from, int to) {
nodes[from].v.push_back(&nodes[to]);
nodes[to].revV.push_back(&nodes[from]);
}
void Dfs(Node *nd, stack<int> &st) {
nd->isVisited = true;
for (Node *x : nd->v) {
if (!x->isVisited) {
Dfs(x, st);
}
}
st.push(nd->id);
}
void DfsRev(Node *nd, int sccInd) {
nd->sccInd = sccInd;
nd->isVisited = true;
for (Node *x : nd->revV) {
if (!x->isVisited) {
DfsRev(x, sccInd);
}
}
}
void ComputeSccs() {
stack<int> st;
for (int i = 1; i <= cntNodes; i++) {
if (!nodes[i].isVisited) {
Dfs(&nodes[i], st);
}
}
MarkAllNodesUnvisited();
int sccInd = 1;
while (!st.empty()) {
int aux = st.top();
st.pop();
if (!nodes[aux].isVisited) {
DfsRev(&nodes[aux], sccInd);
sccInd++;
}
}
cntSccs = sccInd - 1;
}
};
bool hasOutEdge[MAX_N];
int maintenanceTime[MAX_N], cntNodesInScc[MAX_N];
Graph graph;
vector<pair<int, int> > edges;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, h;
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
cin >> maintenanceTime[i];
}
graph.Init(n);
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
int timeX = maintenanceTime[x];
int timeY = maintenanceTime[y];
if ((timeX + 1) % h == timeY) {
graph.AddEdge(x, y);
edges.push_back({x, y});
}
if ((timeY + 1) % h == timeX) {
graph.AddEdge(y, x);
edges.push_back({y, x});
}
}
graph.ComputeSccs();
for (int i = 1; i <= n; i++) {
cntNodesInScc[graph.nodes[i].sccInd]++;
}
for (pair<int, int> edge : edges) {
if (graph.nodes[edge.first].sccInd != graph.nodes[edge.second].sccInd) {
hasOutEdge[graph.nodes[edge.first].sccInd] = true;
}
}
int ans = -1, ansComponentInd = -1;
for (int i = 1; i <= graph.cntSccs; i++) {
if (!hasOutEdge[i]) {
if (ans == -1 || ans > cntNodesInScc[i]) {
ans = cntNodesInScc[i];
ansComponentInd = i;
}
}
}
cout << ans << '\n';
for (int i = 1; i <= n; i++) {
if (graph.nodes[i].sccInd == ansComponentInd) {
cout << i << " ";
}
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NN = 1e5 + 3;
vector<vector<int>> g(NN), gr(NN);
int used[NN];
vector<int> cnt;
void dfs(int v) {
used[v] = 1;
for (const auto& to : g[v])
if (!used[to]) dfs(to);
cnt.push_back(v);
}
int pr[NN];
int sz[NN];
int used1[NN];
vector<vector<int>> gg(NN);
int used2[NN];
vector<int> mbans;
void dfs2(int v) {
used2[v] = 1;
for (const auto& to : gg[v])
if (!used2[to]) dfs2(to);
if (gg[v].size() == 0) mbans.push_back(v);
}
int main() {
int n, m, h;
cin >> n >> m >> h;
vector<int> hour(n);
for (int i = 0; i < n; ++i) cin >> hour[i];
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
x--;
y--;
if ((hour[x] + 1) % h == hour[y]) {
g[x].push_back(y);
gr[y].push_back(x);
}
if ((hour[y] + 1) % h == hour[x]) {
g[y].push_back(x);
gr[x].push_back(y);
}
}
for (int i = 0; i < n; ++i)
if (!used[i]) dfs(i);
for (int i = n - 1; i >= 0; --i) {
if (!used1[cnt[i]]) {
queue<int> q;
q.push(cnt[i]);
int y = cnt[i];
sz[y] = 1;
pr[y] = y;
while (!q.empty()) {
int cur = q.front();
q.pop();
used1[cur] = 1;
for (const auto& to : gr[cur])
if (!used1[to]) {
pr[to] = y;
used1[to] = 1;
q.push(to);
sz[y]++;
}
}
}
}
for (int i = 0; i < n; ++i)
for (const auto& to : g[i])
if (pr[i] != pr[to]) gg[pr[i]].push_back(pr[to]);
for (int i = 0; i < n; ++i)
if (sz[i] && !used2[i]) dfs2(i);
int ans = n + 3, id = 0;
for (int i = 0; i < mbans.size(); ++i)
if (sz[mbans[i]] < ans) {
ans = sz[mbans[i]];
id = mbans[i];
}
cout << ans << endl;
for (int i = 0; i < n; ++i)
if (pr[i] == id) cout << i + 1 << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int nbNoeuds, nbReqs, nbHeures;
int heureMAJ[100 * 1000];
vector<int> decales[100 * 1000];
vector<int> invs[100 * 1000];
bool estPasse[100 * 1000];
vector<int> postOrder;
void genPostOrder(int noeud) {
if (estPasse[noeud]) return;
estPasse[noeud] = true;
for (int voisin : invs[noeud]) {
genPostOrder(voisin);
}
postOrder.push_back(noeud);
}
int curComposante = 0;
int composante[100 * 1000];
int explore(int noeud) {
if (composante[noeud] != 0) {
if (composante[noeud] == curComposante) return 0;
return 1000 * 1000;
}
composante[noeud] = curComposante;
int taille = 0;
for (int voisin : decales[noeud]) {
taille += explore(voisin);
taille = min(taille, 1000 * 1000);
}
return taille + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> nbNoeuds >> nbReqs >> nbHeures;
for (int iNoeud = 0; iNoeud < nbNoeuds; iNoeud++) {
cin >> heureMAJ[iNoeud];
}
for (int iReq = 0; iReq < nbReqs; iReq++) {
int a, b;
cin >> a >> b;
if ((heureMAJ[a - 1] + 1) % nbHeures == heureMAJ[b - 1]) {
decales[a - 1].push_back(b - 1);
invs[b - 1].push_back(a - 1);
}
if ((heureMAJ[b - 1] + 1) % nbHeures == heureMAJ[a - 1]) {
decales[b - 1].push_back(a - 1);
invs[a - 1].push_back(b - 1);
}
}
for (int iNoeud = 0; iNoeud < nbNoeuds; iNoeud++) {
genPostOrder(iNoeud);
}
int minTaille = 1000 * 1000;
int minComposante = 0;
while (!postOrder.empty()) {
int racine = postOrder.back();
postOrder.pop_back();
curComposante++;
int taille = explore(racine);
if (taille < minTaille) {
minTaille = taille;
minComposante = curComposante;
}
}
cout << minTaille << endl;
for (int iNoeud = 0; iNoeud < nbNoeuds; iNoeud++) {
if (composante[iNoeud] == minComposante) {
cout << iNoeud + 1 << " ";
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int h;
vector<vector<int>> g(N), tree(N);
vector<int> used(N, 0), u(N), comp, comp_size, order, comp_node(N);
void dfs(int v) {
used[v] = 1;
for (auto &to : g[v]) {
if (!used[to] && (u[v] + 1) % h == u[to]) {
dfs(to);
}
}
order.push_back(v);
}
void find_comp(int v) {
used[v] = 1;
comp.push_back(v);
for (auto &to : g[v]) {
if (!used[to] && (u[to] + 1) % h == u[v]) {
find_comp(to);
}
}
}
int main() {
int n, m;
cin >> n >> m >> h;
for (int i = 0; i < n; ++i) {
cin >> u[i];
}
for (int i = 0; i < m; ++i) {
int e, v;
cin >> e >> v;
g[--e].push_back(--v);
g[v].push_back(e);
}
for (int i = 0; i < n; ++i) {
if (!used[i]) {
dfs(i);
}
}
used.assign(n + 1, 0);
int cnt_comp = 0;
for (int i = n - 1; i >= 0; --i) {
if (!used[order[i]]) {
find_comp(order[i]);
for (int j : comp) {
comp_node[j] = cnt_comp;
}
comp_size.push_back(comp.size());
comp.clear();
++cnt_comp;
}
}
used.assign(n + 1, 0);
for (int i = 0; i < n; ++i) {
for (auto &to : g[i]) {
if (comp_node[i] != comp_node[to] && (u[i] + 1) % h == u[to]) {
tree[comp_node[i]].push_back(comp_node[to]);
}
}
}
int comp_num, mn = 1e9;
for (int i = 0; i < cnt_comp; ++i) {
if (!tree[i].size() && comp_size[i] < mn) {
mn = comp_size[i];
comp_num = i;
}
}
cout << mn << endl;
for (int i = 0; i < n; ++i) {
if (comp_node[i] == comp_num) {
cout << i + 1 << " ";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 110000;
int n, m, h;
int head[maxn], num;
struct road {
int to, next;
} edge[maxn * 2];
void add(int u, int v) {
edge[num].to = v;
edge[num].next = head[u];
head[u] = num++;
}
int dfn[maxn], low[maxn], block[maxn];
int id, cnt, vis[maxn], numxx[maxn];
int out[maxn];
stack<int> q;
void dfs(int u, int fa) {
dfn[u] = low[u] = ++id;
q.push(u);
vis[u] = 1;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (!dfn[v]) {
dfs(v, u);
low[u] = min(low[v], low[u]);
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
cnt++;
int v;
do {
v = q.top();
vis[v] = 0;
q.pop();
block[v] = cnt;
numxx[cnt]++;
} while (v != u);
}
}
int tim[maxn];
void init() {
id = num = cnt = 0;
memset(dfn, 0, sizeof(dfn));
memset(low, 0, sizeof(low));
memset(edge, 0, sizeof(edge));
memset(numxx, 0, sizeof(numxx));
memset(block, 0, sizeof(block));
memset(vis, 0, sizeof(vis));
while (!q.empty()) q.pop();
memset(head, -1, sizeof(head));
memset(out, 0, sizeof(out));
}
int main() {
while (scanf("%d%d%d", &n, &m, &h) != EOF) {
init();
for (int i = 1; i <= n; i++) {
scanf("%d", &tim[i]);
}
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
if ((tim[a] + 1) % h == tim[b]) add(a, b);
if ((tim[b] + 1) % h == tim[a]) add(b, a);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) dfs(i, -1);
}
for (int i = 1; i <= n; i++) {
for (int j = head[i]; j != -1; j = edge[j].next) {
int v = edge[j].to;
if (block[v] != block[i]) {
out[block[i]]++;
}
}
}
int ans = INF;
int flag = 0;
for (int i = 1; i <= cnt; i++) {
if (out[i] == 0) {
if (ans > numxx[i]) {
ans = numxx[i];
flag = i;
}
}
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
int putt = 0;
if (block[i] == flag) {
ans--;
putt = 1;
}
if (ans != 0 && putt == 1)
cout << i << " ";
else if (ans == 0 && putt == 1)
cout << i << endl;
}
}
}
|
#include <bits/stdc++.h>
template <typename Y>
inline bool updmin(Y &a, Y b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename Y>
inline bool updmax(Y &a, Y b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename Y>
inline Y abs(Y a) {
if (a < 0) a = -a;
return a;
}
template <typename Y>
inline Y sqr(Y a) {
return a * a;
}
int read() {
int w = 1, q = 0, ch = ' ';
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') w = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) q = q * 10 + ch - 48;
return q * w;
}
inline void FileIO() {
freopen(
""
".in",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
int n, m, h;
const int N = 100020;
std::vector<int> G[N], s;
int tim = 0, cnt = 0;
int low[N], dfn[N], vis[N], bel[N];
void tarjan(int p) {
vis[p] = 1;
s.push_back(p);
low[p] = dfn[p] = ++tim;
for (int t : G[p]) {
if (!dfn[t]) {
tarjan(t);
updmin(low[p], low[t]);
} else if (vis[t]) {
updmin(low[p], dfn[t]);
}
}
if (low[p] == dfn[p]) {
++cnt;
while (s.back() != p) {
int cur = s.back();
s.pop_back();
vis[cur] = 0;
bel[cur] = cnt;
}
bel[p] = cnt;
vis[p] = 0;
s.pop_back();
}
}
int u[N], size[N], out[N];
int main() {
n = read();
m = read();
h = read();
for (int i = 1; i <= n; i++) {
u[i] = read();
}
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
if ((u[x] + 1) % h == u[y]) {
G[x].push_back(y);
}
if ((u[y] + 1) % h == u[x]) {
G[y].push_back(x);
}
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
tarjan(i);
}
}
for (int i = 1; i <= n; i++) {
size[bel[i]]++;
for (int j : G[i]) {
if (bel[i] != bel[j]) {
out[bel[i]]++;
}
}
}
int ans = n + 1, pos = 0;
for (int i = 1; i <= cnt; i++) {
if (!out[i] && updmin(ans, size[i])) {
pos = i;
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++) {
if (bel[i] == pos) {
printf("%d ", i);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
vector<int> vals;
vector<set<int>> adj;
vector<set<int>> adjr;
vector<bool> used;
vector<int> order, component;
vector<set<int>> adj2(1e5 + 1);
void dfs1(int node) {
used[node] = true;
for (auto neigh : adj[node])
if (!used[neigh]) dfs1(neigh);
order.push_back(node);
}
void dfs2(int node) {
used[node] = true;
component.push_back(node);
for (auto neigh : adjr[node])
if (!used[neigh]) dfs2(neigh);
}
void solve() {
cin >> n >> m >> h;
vals.resize(n + 1);
adj.resize(n + 1);
adjr.resize(n + 1);
for (int i = 1; i <= n; i++) cin >> vals[i];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if ((vals[x] + 1) % h == vals[y]) {
adj[x].insert(y);
}
if ((vals[y] + 1) % h == vals[x]) {
adj[y].insert(x);
}
}
for (int i = 1; i <= n; i++)
for (auto node : adj[i]) adjr[node].insert(i);
used.assign(n + 1, false);
for (int i = 1; i <= n; i++)
if (!used[i]) dfs1(i);
used.assign(n + 1, false);
vector<int> roots(n + 1, 0);
vector<int> root_nodes;
vector<int> comp_sizes(n + 1, 0);
for (int i = 0; i < n; i++) {
int v = order[n - i - 1];
if (!used[v]) {
dfs2(v);
int root = component.front();
for (auto node : component) roots[node] = root;
comp_sizes[root] = component.size();
root_nodes.push_back(root);
component.clear();
}
}
for (int child = 1; child <= n; child++)
for (auto neigh : adj[child]) {
int root_node2 = roots[neigh];
int root_node = roots[child];
assert(root_node and root_node2);
if (root_node2 != root_node) adj2[root_node].insert(root_node2);
}
int ans = INT_MAX, ans_node = -1;
for (auto root_node : root_nodes)
if (adj2[root_node].empty()) {
int sz = comp_sizes[root_node];
if (ans > sz) {
ans = sz;
ans_node = root_node;
}
}
assert(ans < INT_MAX);
cout << ans << "\n";
for (int i = 1; i <= n; i++)
if (roots[i] == ans_node) cout << i << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
|
#include <bits/stdc++.h>
constexpr int MAX_N = 100100;
using namespace std;
vector<int> val, comp, z, cont;
int Time, ncomps;
template <class G, class F>
int dfs(int j, G& g, F f) {
int low = val[j] = ++Time, x;
z.push_back(j);
for (auto& e : g[j])
if (comp[e] < 0) low = min(low, val[e] ?: dfs(e, g, f));
if (low == val[j]) {
do {
x = z.back();
z.pop_back();
comp[x] = ncomps;
cont.push_back(x);
} while (x != j);
f(cont);
cont.clear();
ncomps++;
}
return val[j] = low;
}
template <class G, class F>
void scc(G& g, F f) {
int n = (int)(g).size();
val.assign(n, 0);
comp.assign(n, -1);
Time = ncomps = 0;
for (int i = 0; i < (n); ++i)
if (comp[i] < 0) dfs(i, g, f);
}
int n, m, h;
int hour[MAX_N];
int u[MAX_N], v[MAX_N];
vector<vector<int>> adj;
vector<int> best;
void visit(vector<int>& c) {
for (int u : c) {
for (int v : adj[u]) {
if (comp[v] != comp[u]) {
return;
}
}
}
if (best.empty() || c.size() < best.size()) {
best = c;
}
}
int main() {
scanf(" %d %d %d", &n, &m, &h);
adj.resize(n);
for (int i = 0; i < n; ++i) {
scanf(" %d", &hour[i]);
}
for (int i = 1; i <= m; ++i) {
scanf(" %d %d", &u[i], &v[i]);
--u[i];
--v[i];
if (((hour[u[i]] + 1) % h) == hour[v[i]]) {
adj[u[i]].push_back(v[i]);
}
if (((hour[v[i]] + 1) % h) == hour[u[i]]) {
adj[v[i]].push_back(u[i]);
}
}
scc(adj, visit);
printf("%d\n", (int)best.size());
for (int x : best) {
printf("%d ", x + 1);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return x * f;
}
const int N = 100010, M = 100010;
const int INF = 0x3f3f3f3f;
int data[N];
struct G {
struct node {
int u, v, next;
} edge[M << 1];
int last[N], le;
void add(int u, int v) {
edge[++le].u = u, edge[le].v = v, edge[le].next = last[u], last[u] = le;
}
void cl() {
memset(last, 0, sizeof(last));
le = 0;
}
} G1, G2;
int pre[N], low[N], scc_cnt, lt, scc_node[N], sccsz[N], in[N];
stack<int> s;
void dfs(int u) {
pre[u] = low[u] = ++lt;
s.push(u);
for (int i = G1.last[u]; i; i = G1.edge[i].next) {
int v = G1.edge[i].v;
if (!pre[v]) {
dfs(v);
}
if (!scc_node[v]) low[u] = min(low[u], low[v]);
}
if (pre[u] == low[u]) {
++scc_cnt;
while (!s.empty()) {
int x = s.top();
s.pop();
scc_node[x] = scc_cnt;
++sccsz[scc_cnt];
if (u == x) break;
}
}
}
void init() {
memset(pre, 0, sizeof(pre));
memset(low, 0, sizeof(low));
memset(scc_node, 0, sizeof(scc_node));
memset(sccsz, 0, sizeof(sccsz));
memset(in, 0, sizeof(in));
scc_cnt = lt = 0;
}
int dp[N], vis[N];
int dfs2(int u) {
if (dp[u]) return dp[u];
dp[u] = sccsz[u];
for (int i = G2.last[u]; i; i = G2.edge[i].next) {
int v = G2.edge[i].v;
dp[u] += dfs2(v);
}
return dp[u];
}
int tans[N], la;
void dfs3(int u) {
tans[++la] = u;
vis[u] = 1;
for (int i = G1.last[u]; i; i = G1.edge[i].next) {
int v = G1.edge[i].v;
if (!vis[v]) dfs3(v);
}
}
int vis2[N];
bool dfs4(int u) {
vis[u] = vis2[u] = 1;
for (int i = G2.last[u]; i; i = G2.edge[i].next) {
int v = G2.edge[i].v;
if (vis[v]) return 1;
if (dfs4(v)) return 1;
}
vis[u] = 0;
return 0;
}
int main() {
init();
G1.cl(), G2.cl();
int n = read(), m = read(), h = read();
for (int i = 1; i <= n; ++i) data[i] = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
if (data[u] + 1 == data[v] || data[u] + 1 == data[v] + h) G1.add(u, v);
if (data[v] + 1 == data[u] || data[v] + 1 == data[u] + h) G1.add(v, u);
}
for (int i = 1; i <= n; ++i)
if (!pre[i]) dfs(i);
for (int i = 1; i <= G1.le; ++i) {
int u = G1.edge[i].u, v = G1.edge[i].v;
if (scc_node[u] != scc_node[v])
++in[scc_node[v]], G2.add(scc_node[u], scc_node[v]);
}
for (int i = 1; i <= scc_cnt; ++i)
if (!in[i]) dfs2(i);
int ans = INF;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; ++i)
if (dp[scc_node[i]] > 0) {
int num = dp[scc_node[i]];
if (num < ans) ans = num;
}
memset(vis, 0, sizeof(vis));
la = 0;
for (int i = 1; i <= n; ++i)
if (dp[scc_node[i]] > 0) {
int num = dp[scc_node[i]];
if (num == ans) {
dfs3(i);
break;
}
}
if (ans < 0) {
printf("%d\n", scc_cnt);
printf("%d %d\n", ans, la);
printf("%d %d\n", G1.le, G2.le);
for (int i = 1; i <= scc_cnt; ++i) printf("%d ", sccsz[i]);
memset(vis, 0, sizeof(vis));
bool gfg = 0;
for (int i = 1; i <= scc_cnt; ++i)
if (!vis2[i]) {
if (dfs4(i)) {
gfg = 1;
break;
}
}
printf("\n%d\n", gfg);
}
printf("%d\n", ans);
for (int i = 1; i <= la; ++i) printf("%d ", tans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const int MAXN = 1e5 + 10;
int n, m, h, a[MAXN], head[MAXN], cnt, cnt1, dfn[MAXN], low[MAXN], tim,
belog[MAXN], siz[MAXN], stac[MAXN], top;
bool vis[MAXN];
pair<int, int> tmp[MAXN];
namespace case1 {
int getfa(int x) { return belog[x] == x ? x : belog[x] = getfa(belog[x]); }
void solve() {
for (int i = 1; i <= n; ++i) siz[i] = 1, belog[i] = i;
for (int i = 1; i <= m; ++i) {
if (tmp[i].first == tmp[i - 1].first && tmp[i].second == tmp[i - 1].second)
continue;
int x = tmp[i].first, y = tmp[i].second;
int a = getfa(x), b = getfa(y);
if (a == b) continue;
belog[a] = b;
siz[b] += siz[a];
}
int ans1, ans2 = 0x3f3f3f3f;
for (int i = 1; i <= n; ++i) {
if (belog[i] == i && siz[i] < ans2) {
ans2 = siz[i];
ans1 = i;
}
}
printf("%d\n", ans2);
for (int i = 1; i <= n; ++i)
if (getfa(i) == ans1) printf("%d ", i);
puts("");
return;
}
} // namespace case1
struct edge {
int u, v, next;
} e[MAXN];
void addedge(int x, int y) {
e[++cnt] = (edge){x, y, head[x]};
head[x] = cnt;
return;
}
struct edge1 {
int v, next;
} e1[MAXN];
void addedge1(int x, int y) {
e1[++cnt1] = (edge1){y, head[x]};
head[x] = cnt1;
return;
}
void Tarjan(int u) {
dfn[u] = low[u] = ++tim;
stac[++top] = u;
vis[u] = true;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].v;
if (!dfn[v]) {
Tarjan(v);
low[u] = min(low[u], low[v]);
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
++cnt;
int v;
do {
v = stac[top--];
vis[v] = false;
belog[v] = cnt;
++siz[cnt];
} while (u != v);
}
}
int main() {
n = read();
m = read();
h = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read();
tmp[i].first = min(x, y);
tmp[i].second = max(x, y);
}
sort(tmp + 1, tmp + 1 + m);
if (h == 2) return case1::solve(), 0;
for (int i = 1; i <= m; ++i) {
if (tmp[i].first == tmp[i - 1].first && tmp[i].second == tmp[i - 1].second)
continue;
int x = tmp[i].first, y = tmp[i].second;
if ((a[y] + 1) % h == a[x]) addedge(y, x);
if ((a[x] + 1) % h == a[y]) addedge(x, y);
}
cnt = 0;
for (int i = 1; i <= n; ++i)
if (!dfn[i]) Tarjan(i);
memset(head, 0, sizeof(head));
for (int i = 1; i <= m; ++i) {
if (!e[i].u) break;
if (belog[e[i].u] == belog[e[i].v]) continue;
addedge1(belog[e[i].u], belog[e[i].v]);
}
int ans1, ans2 = 0x3f3f3f3f;
for (int i = 1; i <= cnt; ++i) {
if (!head[i] && siz[i] < ans2) {
ans2 = siz[i];
ans1 = i;
}
}
printf("%d\n", ans2);
for (int i = 1; i <= n; ++i)
if (belog[i] == ans1) printf("%d ", i);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
vector<int> t;
vector<vector<int>> g, rev_g, cond_g;
vector<int> num_exit;
vector<char> used;
vector<int> color;
vector<int> count_v;
void find_num_exit(int v) {
used[v] = true;
for (auto u : g[v]) {
if (used[u]) continue;
find_num_exit(u);
}
num_exit.push_back(v);
}
void cond(int v, int k) {
color[v] = k;
for (auto u : rev_g[v]) {
if (color[u]) continue;
cond(u, k);
}
}
void make_cond_g(int v) {
used[v] = true;
count_v[color[v]]++;
for (auto u : g[v]) {
if (color[v] != color[u]) {
cond_g[color[v]].push_back(color[u]);
}
if (used[u]) continue;
make_cond_g(u);
}
}
int minn = 1e9, minn_k = 0;
void dfs_cond(int v) {
used[v] = true;
if (cond_g[v].size() == 0 && count_v[v] < minn) {
minn = count_v[v];
minn_k = v;
}
for (auto u : cond_g[v]) {
if (used[u]) continue;
dfs_cond(u);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> h;
t.resize(n + 1);
g.resize(n + 1);
rev_g.resize(n + 1);
for (int i = 1; i <= n; i++) {
cin >> t[i];
}
for (int i = 1; i <= m; i++) {
int c1, c2;
cin >> c1 >> c2;
if ((t[c1] + 1) % h == t[c2]) {
g[c1].push_back(c2);
rev_g[c2].push_back(c1);
}
if ((t[c2] + 1) % h == t[c1]) {
g[c2].push_back(c1);
rev_g[c1].push_back(c2);
}
}
used.resize(n + 1);
for (int i = 1; i <= n; i++) {
if (!used[i]) find_num_exit(i);
}
used.clear();
int k = 0;
color.resize(n + 1);
reverse(num_exit.begin(), num_exit.end());
for (auto i : num_exit) {
if (color[i] == 0) {
k++;
cond(i, k);
}
}
used.resize(n + 1);
count_v.resize(k + 1);
cond_g.resize(k + 1);
for (int i = 1; i <= n; i++) {
if (!used[i]) make_cond_g(i);
}
used.clear();
used.resize(k + 1);
for (int i = 1; i <= k; i++) {
if (!used[i]) dfs_cond(i);
}
cout << minn << "\n";
for (int i = 1; i <= n; i++) {
if (color[i] == minn_k) {
cout << i << " ";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, nxt;
} edge[100005 << 2];
int n, m, t, h[100005], head[100005], tot, d[100005][2];
int c[100005], low[100005], dfn[100005], stk[100005], ins[100005], ind, top;
int cnt;
vector<int> scc[100005];
void tarjan(int x) {
dfn[x] = low[x] = ++ind;
stk[++top] = x;
ins[x] = 1;
for (int i = head[x]; i != -1; i = edge[i].nxt) {
int y = edge[i].to;
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
} else if (ins[y])
low[x] = min(low[x], dfn[y]);
}
if (dfn[x] == low[x]) {
cnt++;
int y;
do {
y = stk[top--];
ins[y] = 0;
c[y] = cnt;
scc[cnt].push_back(y);
} while (x != y);
}
}
void init() {
tot = 0;
memset(head, -1, sizeof head);
}
void addedge(int u, int v) {
edge[tot].nxt = head[u];
edge[tot].to = v;
head[u] = tot++;
}
int in[100005], out[100005];
int main() {
init();
cin >> n >> m >> t;
for (int i = 1; i <= n; i++) scanf("%d", &h[i]);
for (int i = 1; i <= m; i++) scanf("%d%d", &d[i][0], &d[i][1]);
for (int i = 1; i <= m; i++) {
if ((h[d[i][0]] + 1) % t == h[d[i][1]]) addedge(d[i][0], d[i][1]);
if ((h[d[i][1]] + 1) % t == h[d[i][0]]) addedge(d[i][1], d[i][0]);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (int x = 1; x <= n; x++)
for (int i = head[x]; i != -1; i = edge[i].nxt) {
int y = edge[i].to;
if (c[x] == c[y]) continue;
in[c[y]]++;
out[c[x]]++;
}
int ans = 0x3f3f3f3f, k;
for (int i = 1; i <= cnt; i++)
if (out[i] == 0 && scc[i].size() < ans) k = i, ans = scc[i].size();
cout << ans << endl;
for (int i = 0; i < scc[k].size(); i++) printf("%d ", scc[k][i]);
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long gcd(long long a, long long b) {
while (b != 0) {
long long c = a % b;
a = b;
b = c;
}
return a;
}
inline long long lowbit(long long x) { return x & (-x); }
const double PI = 3.14159265358979323846;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long mod = 998244353;
inline long long rd() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const double eps = 1e-6;
const int M = 1e6 + 10;
const int N = 1e6 + 10;
struct Edge {
int to, next;
} e[N << 1];
int head[N], tot;
void add(int x, int y) {
e[++tot] = {y, head[x]};
head[x] = tot;
}
int n, m, h;
int stk[N], dfn[N], low[N], c[N];
int num, cnt, top;
bool ins[N];
vector<int> scc[N];
void tarjan(int x) {
dfn[x] = low[x] = ++num;
stk[++top] = x, ins[x] = 1;
for (int i = head[x]; i != -1; i = e[i].next) {
int y = e[i].to;
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
} else if (ins[y]) {
low[x] = min(low[x], dfn[y]);
}
}
if (dfn[x] == low[x]) {
cnt++;
int tmp;
do {
tmp = stk[top--], ins[tmp] = 0;
c[tmp] = cnt;
scc[cnt].push_back(tmp);
} while (x != tmp);
}
}
void init() {
tot = num = cnt = top = 0;
memset(head, -1, sizeof(int) * (n + 5));
}
int a[N];
int out[N];
int main() {
n = rd(), m = rd(), h = rd();
init();
for (int i = 1; i <= n; i++) a[i] = rd();
while (m--) {
int u = rd(), v = rd();
if ((a[u] + 1) % h == a[v]) add(u, v);
if ((a[v] + 1) % h == a[u]) add(v, u);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i);
}
for (int x = 1; x <= n; x++) {
for (int i = head[x]; i != -1; i = e[i].next) {
int y = e[i].to;
if (c[x] == c[y]) continue;
out[c[x]]++;
}
}
int ans = inf, pos = 0;
for (int i = 1; i <= n; i++) {
if (!out[c[i]] && scc[c[i]].size() < ans) {
ans = scc[c[i]].size();
pos = c[i];
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++) {
if (c[i] == pos) printf("%d ", i);
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
bool flag[MAXN];
int belg[MAXN];
int numb[MAXN];
int q[3 * MAXN];
int ne[3 * MAXN];
int s[MAXN];
int rs[MAXN];
int num;
int n;
int len[MAXN];
void inse(int x, int y) {
num++;
q[num] = y;
ne[num] = s[x];
s[x] = num;
num++;
q[num] = x;
ne[num] = rs[y];
rs[y] = num;
}
void VisitOne(int cur, int &sig) {
flag[cur] = true;
for (int k = s[cur]; k; k = ne[k])
if (!flag[q[k]]) VisitOne(q[k], sig);
numb[++sig] = cur;
}
void VisitTwo(int cur, int sig) {
flag[cur] = true;
belg[cur] = sig;
len[sig] += 1;
for (int k = rs[cur]; k; k = ne[k])
if (!flag[q[k]]) VisitTwo(q[k], sig);
}
void KK() {
int sig = 0;
memset(flag, 0, sizeof(flag));
for (int i = 1; i <= n; ++i)
if (!flag[i]) VisitOne(i, sig);
memset(flag, 0, sizeof(flag));
sig = 0;
for (int i = n; i > 0; --i)
if (!flag[numb[i]]) {
VisitTwo(numb[i], ++sig);
}
int ans = n + 1, wh = -1;
for (int i = 1; i <= n; i++) {
for (int k = s[i]; k; k = ne[k]) {
if (belg[q[k]] != belg[i]) {
len[belg[i]] = n + 1;
break;
}
}
}
for (int i = 1; i <= sig; i++) {
if (len[i] < ans) {
ans = len[i];
wh = i;
}
}
cout << ans << endl;
for (int i = 1; i <= n; i++) {
if (belg[i] == wh) {
printf("%d ", i);
}
}
cout << endl;
}
int a[MAXN];
int main() {
int m, h;
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
if (a[x] == (a[y] - 1 + h) % h) {
inse(x, y);
}
if (a[y] == (a[x] - 1 + h) % h) {
inse(y, x);
}
}
KK();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5;
int v[MAXN + 1], scc[MAXN + 1], seen[MAXN + 1], sz[MAXN + 1], out[MAXN + 1];
vector<int> g[MAXN + 1], gt[MAXN + 1], stk;
inline void add_edg(int x, int y, int h) {
if ((v[x] + 1) % h == v[y]) {
g[x].push_back(y);
gt[y].push_back(x);
}
}
void regular_dfs(int node) {
seen[node] = 1;
for (auto it : g[node])
if (seen[it] == 0) regular_dfs(it);
stk.push_back(node);
}
void trans_dfs(int node, int comp) {
seen[node] = 0;
for (auto it : gt[node])
if (seen[it]) trans_dfs(it, comp);
scc[node] = comp;
++sz[comp];
}
int main() {
int n, m, h;
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) cin >> v[i];
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
add_edg(x, y, h);
add_edg(y, x, h);
}
for (int i = 1; i <= n; ++i)
if (seen[i] == 0) regular_dfs(i);
int acc = 0;
while (stk.empty() == false) {
if (seen[stk.back()]) trans_dfs(stk.back(), ++acc);
stk.pop_back();
}
for (int i = 1; i <= n; ++i)
for (auto it : g[i])
if (scc[i] ^ scc[it]) ++out[scc[i]];
int comp = 0;
sz[0] = MAXN + 1;
for (int i = 1; i <= n; ++i)
if (sz[scc[i]] < sz[comp] && out[scc[i]] == 0) comp = scc[i];
cout << sz[comp] << '\n';
for (int i = 1; i <= n; ++i)
if (scc[i] == comp) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
} b[200005];
int i, j, k, l, s, n, m, r, q[200005], dfn[200005], low[200005], last[200005],
Next[200005], to[200005], in[200005], a[200005], B[200005], sum[200005], S,
tot, ans, x, y, P, T;
inline void add(int x, int y) {
Next[++tot] = last[x];
last[x] = tot;
to[tot] = y;
}
inline void tarjan(int x) {
dfn[x] = low[x] = ++tot;
in[x] = 1;
q[++r] = x;
for (int i = last[x]; i; i = Next[i]) {
if (!dfn[to[i]])
tarjan(to[i]), low[x] = min(low[x], low[to[i]]);
else if (in[to[i]])
low[x] = min(low[x], low[to[i]]);
}
if (dfn[x] == low[x]) {
++S;
while (q[r] != x) {
a[q[r]] = S;
sum[S]++;
in[q[r]] = 0;
r--;
}
a[q[r]] = S;
sum[S]++;
in[q[r]] = 0;
r--;
}
}
int main() {
scanf("%d%d%d", &n, &m, &P);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
if (((a[x] + 1) % P) == a[y]) add(x, y), b[++T].x = x, b[T].y = y;
if (((a[y] + 1) % P) == a[x]) add(y, x), b[++T].x = y, b[T].y = x;
}
tot = 0;
ans = n + 1;
for (i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (i = 1; i <= T; i++)
if (a[b[i].x] != a[b[i].y]) B[a[b[i].x]] = 1;
for (i = 1; i <= S; i++)
if (!B[i]) ans = min(ans, sum[i]);
printf("%d\n", ans);
for (i = 1; i <= S; i++)
if (!B[i] && (sum[i] == ans)) break;
for (j = 1; j <= n; j++)
if (a[j] == i) printf("%d ", j);
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 200005;
int n, m, h, u[N];
vector<int> g[N], gt[N];
void add(int x, int y) {
g[x].push_back(y);
gt[y].push_back(x);
}
vector<int> order;
int used[N];
void dfs(int v) {
used[v] = 1;
for (auto& to : g[v])
if (!used[to]) {
dfs(to);
}
order.push_back(v);
}
int color[N];
int clr;
int cnt[N];
void dfsr(int v) {
color[v] = clr;
++cnt[clr];
used[v] = 1;
for (auto& to : gt[v])
if (!used[to]) {
dfsr(to);
}
}
int deg[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> h;
for (int i = 0; i < (n); ++i) cin >> u[i];
for (int i = 0; i < (m); ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
if ((u[x] + 1) % h == u[y]) add(x, y);
if ((u[y] + 1) % h == u[x]) add(y, x);
}
for (int i = 0; i < (n); ++i)
if (!used[i]) dfs(i);
fill(used, used + n, 0);
reverse(order.begin(), order.end());
for (auto& v : order)
if (!used[v]) {
dfsr(v);
++clr;
}
for (int v = 0; v < (n); ++v)
for (auto& to : g[v])
if (color[to] != color[v]) ++deg[color[v]];
int mn = n + 1, col;
for (int c = 0; c < (clr); ++c)
if (!deg[c]) {
if (mn > cnt[c]) {
mn = cnt[c];
col = c;
}
}
vector<int> result;
for (int v = 0; v < (n); ++v)
if (color[v] == col) result.push_back(v);
cout << ((int)(result).size()) << '\n';
for (auto& e : result) cout << e + 1 << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
int a[300005];
int lv, comp;
int d[300005], low[300005], scc[300005];
bool vis[300005], nope[300005];
int cnt[300005];
stack<int> s;
namespace SCC {
struct S {
S(int n) : low(n, 0), comp(n, -1), time(0), ncomp(0) {}
int time;
int ncomp;
vector<int> low, comp;
stack<int> pool;
};
template <class G>
int dfs(const G &g, S &s, int v) {
int entry = s.low[v] = ++s.time;
s.pool.push(v);
for (auto &(u) : (g[v]))
if (s.comp[u] == -1) s.low[v] = min(s.low[v], (s.low[u]) ?: dfs(g, s, u));
if (entry == s.low[v]) {
int u;
do {
u = s.pool.top();
s.pool.pop();
s.comp[u] = s.ncomp;
} while (v != u);
s.ncomp++;
}
return s.low[v];
}
template <class G>
vector<int> scc(const G &g) {
int n = (int)(g).size();
S s = S(n);
for (int i = 0; i < n; i++)
if (s.comp[i] == -1) dfs(g, s, i);
return s.comp;
}
} // namespace SCC
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
scc[i] = -1;
d[i] = -1;
}
vector<vector<int>> edge(n);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
if ((a[x] + 1) % h == a[y]) edge[x].push_back(y);
if ((a[y] + 1) % h == a[x]) edge[y].push_back(x);
}
vector<int> scc = SCC::scc(edge);
for (int i = 0; i < n; i++) {
cnt[scc[i]]++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < edge[i].size(); j++) {
if (scc[i] != scc[edge[i][j]]) nope[scc[i]] = true;
}
}
int cid = -1;
for (int i = 0; i < n; i++) {
if (nope[scc[i]]) continue;
if (cid == -1 || cnt[scc[i]] < cnt[cid]) cid = scc[i];
}
printf("%d\n", cnt[cid]);
vector<int> ans_v;
for (int i = 0; i < n; i++) {
if (scc[i] == cid) {
ans_v.push_back(i + 1);
}
}
for (int i = 0; i < ans_v.size(); i++) {
if (i) printf(" ");
printf("%d", ans_v[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dfn[100009], low[100009], head[100009], tot, cnt, num, st[100009], top, x,
nu[100009], n, m, t[100009], a, b, h, c[100009], du[100009], ans, ji;
bool vis[100009];
struct fef {
int n, to, u;
} an[100009 << 1];
inline void add(int u, int v) {
an[++tot].n = head[u];
an[tot].to = v;
head[u] = tot;
an[tot].u = u;
}
void tarjan(int u) {
vis[u] = 1;
st[++top] = u;
dfn[u] = low[u] = ++cnt;
for (int i = head[u]; i; i = an[i].n) {
int v = an[i].to;
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
num++;
do {
x = st[top--];
vis[x] = 0;
nu[num]++;
c[x] = num;
} while (x != u);
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) scanf("%d", &t[i]);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
if ((t[a] + 1) % h == t[b]) add(a, b);
if ((t[b] + 1) % h == t[a]) add(b, a);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= tot; ++i)
if (c[an[i].u] != c[an[i].to]) du[c[an[i].u]]++;
ans = 0x3f3f3f3f;
for (int i = 1; i <= num; ++i)
if (!du[i] && nu[i] < ans) {
ans = nu[i];
ji = i;
}
cout << ans << endl;
for (int i = 1; i <= n; ++i)
if (c[i] == ji) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100000 + 100], g1[100000 + 100], g2[100000 + 100], ts;
vector<vector<int> > scc;
int vis1[100000 + 100], vis2[100000 + 100], lst, pos[100000 + 100],
mnt[100000 + 100];
void dfs1(int u) {
vis1[u] = 1;
for (auto it : g1[u]) {
if (!vis1[it]) {
dfs1(it);
}
}
ts.push_back(u);
}
void dfs2(int u) {
scc.back().push_back(u);
vis2[u] = 1;
pos[u] = lst;
for (auto it : g2[u]) {
if (!vis2[it]) {
dfs2(it);
}
}
}
int main() {
int n, m, h;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) {
scanf("%d", &mnt[i]);
}
for (int i = 1; i <= m; i++) {
int c1, c2;
scanf("%d%d", &c1, &c2);
graph[c1].push_back(c2);
graph[c2].push_back(c1);
}
for (int i = 1; i <= n; i++) {
for (auto it : graph[i]) {
int u = it;
if ((mnt[i] + 1) % h == mnt[u]) {
g1[i].push_back(it);
g2[it].push_back(i);
}
}
}
for (int i = 1; i <= n; i++) {
if (!vis1[i]) {
dfs1(i);
}
}
for (int i = n - 1; i >= 0; i--) {
if (!vis2[ts[i]]) {
scc.emplace_back();
lst++;
dfs2(ts[i]);
}
}
vector<int> ans;
int mn = 1e6;
for (int i = 0; i < lst; i++) {
bool flag = true;
for (auto it : scc[i]) {
for (auto cur : g1[it]) {
if (pos[cur] != i + 1) {
flag = false;
}
}
}
if (flag && (int)scc[i].size() < mn) {
ans.clear();
ans = scc[i];
mn = ans.size();
}
}
printf("%d\n", mn);
for (auto it : ans) {
printf("%d ", it);
}
printf("\n");
}
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
template <typename... Args>
void read(Args &...args) {
((cin >> args), ...);
}
template <typename... Args>
void write(Args... args) {
((cout << args << " "), ...);
}
template <typename... Args>
void writeln(Args... args) {
((cout << args << " "), ...);
cout << "\n";
}
template <typename T>
void read(vector<T> &a) {
for (auto &ele : a) cin >> ele;
}
template <typename T>
void writeln(vector<T> &a) {
for (auto &ele : a) cout << ele << ' ';
cout << "\n";
}
const pair<int, int> dxy[] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
const pair<int, int> fxy[] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1},
{1, 1}, {-1, -1}, {-1, 1}, {1, -1}};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n;
string s;
read(n, s);
map<string, int> m;
for (int i = 0; i < n - 1; ++i) {
string tmp = s.substr(i, 2);
m[tmp]++;
}
int cnt = 0;
string res;
for (auto it = m.begin(); it != m.end(); ++it) {
if (it->second > cnt) {
cnt = it->second;
res = it->first;
}
}
writeln(res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int MAX = 200001;
int An[MAX];
int book[MAX];
int main() {
string str;
char a = 'a', b = 'b';
int n;
cin >> n >> str;
int sum = 0;
int mmax = 0;
for (int i = 0; i < n - 1; i++) {
sum = 0;
for (int j = 0; j < n - 1; j++) {
if (str[i] == str[j] && str[i + 1] == str[j + 1]) sum++;
}
if (sum > mmax) {
mmax = sum;
a = str[i];
b = str[i + 1];
}
}
cout << a << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, sum;
string s, ans, tmp;
map<string, int> mp;
int main() {
cin >> n >> s;
for (int i = 0; i + 1 < n; i++) {
tmp = s[i];
tmp += s[i + 1];
mp[tmp]++;
if (sum < mp[tmp]) {
sum = mp[tmp];
ans = tmp;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[120];
int main() {
int n;
scanf("%d", &n);
scanf("%s", str);
int ans = -1;
char fin[5];
for (int i = 0; i < n - 1; i++) {
char s[5];
s[0] = str[i];
s[1] = str[i + 1];
int res = 0;
for (int j = 0; j < n - 1; j++) {
if (str[j] == s[0] && str[j + 1] == s[1]) res++;
}
if (res > ans) {
ans = res;
fin[0] = s[0];
fin[1] = s[1];
fin[2] = '\0';
}
}
printf("%s\n", fin);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Substr(string str, string sub) {
int nRet = 0, nStart = 0;
while (-1 != (nStart = str.find(sub, nStart))) {
nStart += sub.length();
++nRet;
}
return nRet;
}
int main() {
string s;
int n;
while (cin >> n >> s) {
map<string, int> mp;
set<string> st;
for (int a = 0; a < s.size() - 1; a++) {
string y = "";
y += s[a];
y += s[a + 1];
st.insert(y);
mp[y]++;
}
int maxn = 0;
for (auto &a : st)
if (mp[a] > maxn) s = a, maxn = mp[a];
cout << s << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
string s;
cin >> n >> s;
map<string, int> cnt;
for (int i = (0); (1) > 0 ? i < (n - 1) : i > (n - 1); i += (1)) {
++cnt[s.substr(i, 2)];
}
int max_val = -1;
string max_str = "";
for (auto x : cnt) {
if (x.second > max_val) {
max_val = x.second;
max_str = x.first;
}
}
cout << max_str;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace mod {
long long const modul = 1000000009;
long long sum(long long x, long long y) { return (x + y) % modul; }
long long sub(long long x, long long y) {
if (x > y) {
return (x - y) % modul;
} else {
return (modul + x - y) % modul;
}
}
long long mpl(long long x, long long y) { return (x * y) % modul; }
long long bin_pow(long long x, long long e) {
long long ans = 1;
while (e) {
if (e & 1) {
ans = mod::mpl(ans, x);
}
x = mod::mpl(x, x);
e >>= 1;
}
return ans;
}
long long rev(long long x) {
long long ans = bin_pow(x, modul - 2);
return ans;
}
long long div(long long x, long long y) {
assert(y != 0);
long long ans = x;
ans = mod::mpl(ans, mod::rev(y));
return ans;
}
} // namespace mod
void set_precise(int n) {
cout << fixed;
cout << setprecision(n);
}
vector<string> v;
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n - 1; ++i) {
string t = "";
t.push_back(s[i]);
t.push_back(s[i + 1]);
v.push_back(t);
}
sort(v.begin(), v.end());
string ans = "";
int ans_cnt = 0;
int cnt = 0;
for (int i = 0; i < v.size() + 1; ++i) {
if ((i == v.size()) || (i == 0) || (v[i] != v[i - 1])) {
if (cnt > ans_cnt) {
ans_cnt = cnt;
ans = v[i - 1];
}
cnt = 1;
} else {
++cnt;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Int() {
int x;
scanf("%d", &x);
return x;
}
int arr[100010];
int tree[100010 * 4];
void init(int node, int b, int e) {
if (b == e) {
tree[node] = arr[e];
return;
}
int lft = node * 2;
int rgt = lft + 1;
int mid = (b + e) / 2;
init(lft, b, mid);
init(rgt, mid + 1, e);
tree[node] = min(tree[lft], tree[rgt]);
}
int q(int node, int b, int e, int l, int r) {
if (l > e | r < b) {
return 100010;
}
if (b >= l && e <= r) {
return tree[node];
}
int lft = node * 2;
int rgt = lft + 1;
int mid = (b + e) / 2;
int x = q(lft, b, mid, l, r);
int y = q(rgt, mid + 1, e, l, r);
return min(x, y);
}
int main() {
long long n;
cin >> n;
string a;
cin >> a;
vector<string> v;
v.clear();
for (int i = 0; i < n - 1; i++) {
string tmp = "";
tmp += a[i];
tmp += a[i + 1];
v.push_back(tmp);
}
sort(v.begin(), v.end());
int c = 0;
int maxc = 0;
string ans = v[0];
for (int i = 0; i < n - 1; i++) {
if (v[i] == v[i + 1]) {
c++;
if (c > maxc) {
maxc = c;
ans = v[i];
}
} else
c = 0;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, ans = "";
int n;
cin >> n >> s;
int temp = 0;
for (int i = 1; i < n; i++) {
string k = "";
k += s[i - 1];
k += s[i];
int count = 0;
for (int j = 1; j < n; j++) {
string z = "";
z += s[j - 1];
z += s[j];
if (k == z) count++;
}
if (count > temp) {
ans.erase();
temp = count;
ans += k;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v[100000 + 1];
bool vis[100000 + 1] = {false};
double mod(double a, double b) { return a - (long long)(a / b) * b; }
double gcd(double x, double y) {
if (y <= 0.0001) return x;
return gcd(y, mod(x, y));
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
long long max = -1e9;
cin >> n;
string s, s1 = {};
char c1, c2;
cin >> s;
for (long long i = 0; i < n - 1; i++) {
long long x = 1;
for (long long j = i + 1; j < n - 1; j++) {
if (s[j] == s[i] && s[j + 1] == s[i + 1]) x++;
}
if (x > max) max = x, c1 = s[i], c2 = s[i + 1];
}
cout << c1 << c2;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-O3")
using namespace std;
mt19937 gen(chrono::system_clock::now().time_since_epoch().count());
const long long N = 2e5 + 32;
const long long M = 1e9 + 7;
const long long mod = 998244353;
const long long rx[4] = {0, 0, -1, 1};
const long long ry[4] = {-1, 1, 0, 0};
const double pi = acos(-1.0);
const long long kx[8] = {1, 1, -1, -1, 2, 2, -2, -2};
const long long ky[8] = {2, -2, 2, -2, 1, -1, 1, -1};
const long long MAXLL = 9223372036854775258LL;
const long long MAXINT = 21473098;
void solve() {
long long n;
cin >> n;
string a;
cin >> a;
map<string, long long> m;
for (long long i = 0; i < n - 1; ++i) {
string s = "";
s += a[i];
s += a[i + 1];
m[s]++;
}
long long ans = 0;
string an;
for (auto i : m) {
if (i.second > ans) {
ans = i.second;
an = i.first;
}
}
cout << an << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long q;
q = 1;
while (q--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, Hash[2005];
string st;
template <typename Drake>
void read(Drake &x) {
x = 0;
char ch = getchar();
bool f = 1;
while (!isdigit(ch)) {
if (ch == '-') f ^= 1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
x *= (2 * f - 1);
}
template <typename Drake>
void write(Drake x) {
if (x < 0) {
x = -x;
putchar('-');
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename Drake>
void writeln(Drake x) {
write(x);
puts("");
}
void init() {
read(n);
cin >> st;
}
int main() {
init();
int Max;
Max = -1;
memset(Hash, 0, sizeof Hash);
for (int i = 0; i <= st.size() - 2; i++) {
Hash[(st[i] - 'A' + 1) * 26 + (st[i + 1] - 'A' + 1)]++;
}
for (int i = 0; i <= 2000; ++i)
if (Max < Hash[i]) Max = Hash[i];
for (int i = 0; i <= st.size() - 2; ++i)
if (Hash[(st[i] - 'A' + 1) * 26 + (st[i + 1] - 'A' + 1)] == Max) {
cout << st[i] << st[i + 1] << endl;
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
char st[105];
int n, cnt = 0, a = 0;
scanf("%d", &n);
scanf("%s", st);
for (int i = 0; i < n - 1; i++) {
cnt = 0;
for (int j = i; j < n - 1; j++) {
if (st[i] == st[j] && st[i + 1] == st[j + 1]) cnt++;
}
if (cnt > a) {
st[0] = st[i];
st[1] = st[i + 1];
a = cnt;
}
}
printf("%c%c\n", st[0], st[1]);
return 0;
}
|
#include <bits/stdc++.h>
int main() {
char ch[200], s[4];
int i, n, k = 1, max = 0, j;
scanf("%d\n", &n);
gets(ch);
for (i = 0; i < n; i++) {
k = 1;
for (j = 0; j < n; j++) {
if (j != i) {
if (ch[i] == ch[j] && ch[i + 1] == ch[j + 1]) {
k++;
}
}
}
if (k > max) {
max = k;
s[1] = ch[i];
s[2] = ch[i + 1];
}
}
printf("%c%c\n", s[1], s[2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
map<string, int> m;
for (int i = 0; i < n - 1; i++) {
string semp;
semp += s[i];
semp += s[i + 1];
m[semp]++;
}
string sol;
int mx = INT_MIN;
for (auto u : m)
if (u.second > mx) {
mx = u.second;
sol = u.first;
}
cout << sol << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int kmp(char *s, char *t, int next[]) {
int ans = 0;
int i, j;
i = 0;
j = 0;
int slen = strlen(s);
while (i < slen) {
if (j == -1 || s[i] == t[j]) {
i++;
j++;
} else
j = next[j];
if (j == 2) {
ans++;
j = 0;
i = i - 1;
}
}
return ans;
}
int main() {
int n;
int next[2];
char a[105];
char b[2];
char c[2];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int k = 0;
c[0] = a[0];
c[1] = a[1];
next[0] = -1;
next[1] = 0;
for (int i = 0; i < n - 1; i++) {
b[0] = a[i];
b[1] = a[i + 1];
if (k < kmp(a, b, next)) {
c[0] = b[0];
c[1] = b[1];
k = kmp(a, b, next);
}
}
cout << c[0] << c[1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
map<string, int> m;
int i = 0, j = 1;
while (i < n - 1 && j < n) {
string s1 = " ";
s1 += s[i];
s1 += s[j];
m[s1]++;
i++;
j++;
}
int ma = 0;
for (auto x : m) {
ma = max(ma, x.second);
}
for (auto y : m) {
if (ma == y.second) {
cout << y.first;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, l, m, n, mx = 0;
char s[1000];
scanf("%d", &n);
getchar();
scanf("%s", s);
l = strlen(s);
char c, d, a, b;
for (i = 0; i < l - 1; i++) {
c = s[i];
d = s[i + 1];
k = 0;
for (j = 0; j < l - 1; j++) {
if (s[j] == c && s[j + 1] == d) k++;
}
if (k > mx) {
mx = k;
a = c;
b = d;
}
}
printf("%c%c\n", a, b);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ss = 0;
string s, kq;
map<string, int> kt;
int main() {
cin >> n;
cin >> s;
for (int i = 1; i < n; ++i) {
string c = "";
c = s[i - 1];
c += s[i];
++kt[c];
if (kt[c] > ss) {
ss = kt[c];
kq = c;
}
}
cout << kq;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.