text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double eps = 1e-6;
const int mod = (int)1e9 + 7;
const int N = 4 * (int)1e4 + 5;
const int sz = (int)1 << 19;
int cnt = 0, x, y, n, m, hm;
vector<int> g[500500];
int comp[200200];
int t[sz + sz + 100];
inline void upd(int x, int delta) {
for (t[x += sz] = delta; x >>= 1;) t[x] = min(t[x + x], t[x + x + 1]);
}
inline int get(int l, int r) {
int res = int(1e9);
for (l += sz, r += sz; l <= r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, t[l++]);
if (!(r & 1)) res = min(res, t[r--]);
if (l > r) break;
}
return res;
}
void dfs(int v) {
upd(v, int(1e9));
comp[cnt]++;
for (int i = get(1, n); i != int(1e9); i = get(i + 1, n)) {
if (binary_search(g[v].begin(), g[v].end(), i)) continue;
dfs(i);
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; ++i) upd(i, i);
for (int i = 1; i <= n; ++i) {
sort(g[i].begin(), g[i].end());
}
while (get(1, n) != int(1e9)) {
dfs(get(1, n));
++cnt;
}
cout << cnt << "\n";
sort(comp, comp + cnt);
for (int i = 0; i < cnt; ++i) {
cout << comp[i] << " ";
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int maxn = 2e5;
const int INF = 0x7fffffff;
const int mod = 1e9 + 7;
const double eps = 1e-7;
const double Pi = acos(-1.0);
inline int read_int() {
char c;
int ret = 0, sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
return sgn * ret;
}
inline long long read_ll() {
char c;
long long ret = 0, sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
return sgn * ret;
}
list<int> li;
vector<int> g[maxn + 5], res;
int n, m;
bool vis[maxn + 5], ban[maxn + 5];
int BFS(int u) {
int res = 0;
queue<int> q;
q.push(u);
while (!q.empty()) {
int now = q.front();
q.pop();
if (vis[now]) continue;
vis[now] = true, ++res;
for (int i = 0; i < g[now].size(); ++i) ban[g[now][i]] = true;
for (auto iter = li.begin(); iter != li.end();) {
int v = *iter;
if (!ban[v]) {
q.push(v);
li.erase(iter++);
} else
++iter;
}
for (int i = 0; i < g[now].size(); ++i) ban[g[now][i]] = false;
}
return res;
}
int main() {
n = read_int(), m = read_int();
for (int i = 1; i <= n; ++i) li.push_back(i);
for (int i = 1, u, v; i <= m; ++i) {
u = read_int(), v = read_int();
g[u].push_back(v), g[v].push_back(u);
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) res.push_back(BFS(i));
sort(res.begin(), res.end());
printf("%d\n", int(res.size()));
for (int i = 0; i < res.size(); ++i)
printf("%d%c", res[i], " \n"[i + 1 == res.size()]);
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 2e5 + 5;
struct edge {
int v, nxt;
} e[maxn << 1];
int n, m, cnt, fir[maxn], ans[maxn], ans_cnt, en[maxn], fa[maxn], root[maxn];
bool vis[maxn];
inline int find(int x) {
if (x != fa[x]) fa[x] = find(fa[x]);
return fa[x];
}
inline int read() {
char c = getchar();
int x = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
x = x * 10 + c - 48;
c = getchar();
}
return x;
}
inline void add_edge(int u, int v) {
e[++cnt].nxt = fir[u];
e[cnt].v = v;
fir[u] = cnt;
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
u = read(), v = read();
add_edge(u, v);
add_edge(v, u);
en[u]++, en[v]++;
}
int least = 0;
for (int i = 1; i <= n; i++) {
if (!least || en[least] > en[i]) least = i;
}
for (int i = fir[least]; i; i = e[i].nxt) {
vis[e[i].v] = 1;
}
for (int i = 1; i <= n; i++)
if (!vis[i]) fa[i] = least;
for (int i = 1; i <= n; i++) {
if (!vis[i]) continue;
int fx = find(i);
bool vis_t[maxn] = {};
for (int j = fir[i]; j; j = e[j].nxt) vis_t[e[j].v] = 1;
for (int j = 1; j <= n; j++) {
if (vis_t[j]) continue;
int fy = find(j);
fa[fy] = fx;
}
}
for (int i = 1; i <= n; i++)
if (fa[i] == i) root[i] = ++ans_cnt;
for (int i = 1; i <= n; i++) ans[root[find(i)]]++;
std::sort(ans + 1, ans + ans_cnt + 1);
printf("%d\n", ans_cnt);
for (int i = 1; i <= ans_cnt; i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, k;
int ans[2000010];
set<int> v;
set<pair<int, int> > e;
void dfs(int x, int k) {
if (x > n) return;
v.erase(x);
ans[k]++;
int y = 0;
while (y < n) {
set<int>::iterator it = v.upper_bound(y);
y = *it;
if (!e.count(make_pair(x, y))) dfs(y, k);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
e.insert(make_pair(x, y));
e.insert(make_pair(y, x));
}
for (int i = 1; i <= n + 1; i++) v.insert(i);
for (int i = 1; i <= n; i++)
if (v.count(i)) k++, dfs(i, k);
sort(ans + 1, ans + 1 + k);
printf("%d\n", k);
for (int i = 1; i <= k; i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, bool> mp[300000];
vector<int> q, ans;
int n, m, l[300000];
int read() {
int p = 0, q = 1;
char ch = getchar();
while (ch < '0' || ch > '9') (ch == '-' ? q = -1 : 0), ch = getchar();
while (ch >= '0' && ch <= '9') p = p * 10 + ch - '0', ch = getchar();
return p * q;
}
int bfs(int u) {
int le = 0, ri = 1, size = q.size();
l[1] = u;
while (le < ri) {
int v = l[++le];
for (int j = 0; j < size; j++)
if (!mp[v][q[j]]) {
l[++ri] = q[j];
q[j--] = q[--size];
q.pop_back();
}
}
return ri;
}
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
mp[u][v] = 1;
mp[v][u] = 1;
}
for (int i = 1; i <= n; i++) q.push_back(i);
while (!q.empty()) {
int v = q.back();
q.pop_back();
ans.push_back(bfs(v));
}
int cnt = ans.size();
sort(ans.begin(), ans.end());
cout << cnt << endl;
for (int i = 0; i < cnt; i++) printf("%d ", ans[i]);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long b, long long p, long long md) {
if (p == 0) return 1;
if (p % 2 == 1) {
return ((b % md) * bigmod(b, p - 1, md)) % md;
} else {
long long y = bigmod(b, p / 2, md);
return (y * y) % md;
}
}
set<int> vis;
set<int> st[200005];
vector<int> ans;
int cnt;
void dfs(int s) {
cnt++;
for (auto it = vis.begin(); it != vis.end();) {
if (st[s].find(*it) == st[s].end()) {
int node = *it;
vis.erase(node);
dfs(node);
it = vis.lower_bound(node);
} else
it++;
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
st[a].insert(b);
st[b].insert(a);
}
for (int i = 1; i <= n; i++) vis.insert(i);
for (int i = 1; i <= n; i++) {
if (vis.find(i) != vis.end()) {
cnt = 0;
vis.erase(i);
dfs(i);
ans.push_back(cnt);
}
}
cout << ans.size() << "\n";
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 69;
vector<int> vek, G[N], wyn;
vector<pair<int, int> > ve;
int zap[N], n, m, rep[N], roz[N], a, b;
queue<int> q;
set<int> S;
int re(int v) {
if (rep[v] != v) rep[v] = re(rep[v]);
return rep[v];
}
void uni(int a, int b) {
a = re(a);
b = re(b);
if (a == b) return;
rep[a] = b;
roz[b] += roz[a];
}
void gemacht2(int v) {
q.push(v);
int sv = v;
while (!q.empty()) {
v = q.front();
uni(v, sv);
q.pop();
for (int i = 0; i < vek.size(); i++) {
if ((*lower_bound(G[v].begin(), G[v].end(), vek[i])) != vek[i] ||
lower_bound(G[v].begin(), G[v].end(), vek[i]) == G[v].end()) {
q.push(vek[i]);
vek.erase(vek.begin() + i);
i--;
}
}
}
}
void gemacht1(int v) {
for (int i = 0; i < G[v].size(); i++)
zap[G[v][i]] = 1, vek.push_back(G[v][i]);
for (int i = 1; i <= n; i++)
if (zap[i] == 0) q.push(i);
gemacht2(v);
}
int32_t main(void) {
cin >> n >> m;
for (int i = 1; i <= n; i++) rep[i] = i, roz[i] = 1;
for (int i = 0; i < m; i++) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
ve.push_back(make_pair(G[i].size(), i));
sort(G[i].begin(), G[i].end());
}
sort(ve.begin(), ve.end());
gemacht1(ve[0].second);
reverse(ve.begin(), ve.end());
while (ve.empty() == false && vek.empty() == false) {
int zm = ve.back().second;
ve.pop_back();
if (lower_bound(vek.begin(), vek.end(), zm) != vek.end() &&
(*lower_bound(vek.begin(), vek.end(), zm)) == zm) {
q.push(zm);
vek.erase(lower_bound(vek.begin(), vek.end(), zm));
gemacht2(zm);
}
}
for (int i = 1; i <= n; i++) {
if (S.find(re(i)) != S.end()) continue;
S.insert(re(i));
wyn.push_back(roz[re(i)]);
}
sort(wyn.begin(), wyn.end());
cout << wyn.size() << "\n";
for (int i = 0; i < wyn.size(); i++) {
cout << wyn[i] << " ";
}
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
vector<int> g[maxn], grp[maxn];
int visit[maxn], degree[maxn], vdegree[maxn];
set<int> s1, c, nc;
map<pair<int, int>, int> m1;
vector<int> ans;
int gnum;
void dfs(int node) {
visit[node] = 1;
for (int i = 0; i <= (int)g[node].size() - 1; i++) {
if (visit[g[node][i]]) continue;
dfs(g[node][i]);
}
}
void dfs1(int node) {
visit[node] = 1;
grp[gnum].push_back(node);
for (auto it = c.begin(); it != c.end(); ++it) {
if (visit[*it]) continue;
if (!m1[{node, *it}]) dfs1(*it);
}
}
void solve() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int n1, n2;
scanf("%d", &n1);
scanf("%d", &n2);
g[n1].push_back(n2);
g[n2].push_back(n1);
m1[{n1, n2}] = 1;
m1[{n2, n1}] = 1;
degree[n1]++;
degree[n2]++;
}
dfs(1);
for (int i = 1; i <= n; i++) {
if (!visit[i]) {
puts("1");
printf("%d\n", n);
return;
}
}
int x = INT_MAX, element = -1;
for (int i = 1; i <= n; i++) {
if (x > degree[i]) {
x = degree[i];
element = i;
}
}
s1.insert(element);
for (int i = 0; i <= (int)g[element].size() - 1; i++) {
s1.insert(g[element][i]);
}
cerr << "sz(s1)"
<< ": " << (int)s1.size() << endl;
;
for (int i = 0; i <= (int)g[element].size() - 1; i++) {
for (int j = 0; j <= (int)g[g[element][i]].size() - 1; j++) {
if (s1.find(g[g[element][i]][j]) != s1.end()) {
vdegree[g[element][i]]++;
}
}
}
int siz = n - (int)g[element].size() - 1, cnt = 0;
for (int i = 0; i <= (int)g[element].size() - 1; i++) {
if ((degree[g[element][i]] - vdegree[g[element][i]]) == siz) {
c.insert(g[element][i]);
} else {
nc.insert(g[element][i]);
}
}
memset(visit, 0, sizeof(visit));
gnum = 1;
for (auto it = c.begin(); it != c.end(); ++it) {
if (visit[*it]) continue;
dfs1(*it);
gnum++;
}
memset(vdegree, 0, sizeof(vdegree));
if ((int)nc.size()) {
auto it = nc.begin();
while (it != nc.end()) {
for (auto it1 = c.begin(); it1 != c.end(); ++it1) {
if (m1[{(*it), (*it1)}]) vdegree[*it1]++;
}
it++;
}
}
for (int i = 1; i <= gnum - 1; i++) {
int flag = 0;
for (int j = 0; j <= (int)grp[i].size() - 1; j++) {
if (vdegree[grp[i][j]] != (int)nc.size()) {
flag = 1;
break;
}
}
if (!flag) {
ans.push_back((int)grp[i].size());
cnt += (int)grp[i].size();
}
}
if (n - cnt) ans.push_back(n - cnt);
printf("%d\n", (int)ans.size());
sort((ans).begin(), (ans).end());
for (int i = 0; i <= (int)ans.size() - 1; i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
set<pair<long long, long long> > s;
set<long long> cur;
cin >> n >> m;
for (__typeof(m) i = (0) - ((0) > (m)); i != (m) - ((0) > (m));
i += 1 - 2 * ((0) > (m))) {
long long x, y;
cin >> x >> y;
s.insert({x, y});
s.insert({y, x});
}
for (__typeof(n + 1) i = (1) - ((1) > (n + 1));
i != (n + 1) - ((1) > (n + 1)); i += 1 - 2 * ((1) > (n + 1)))
cur.insert(i);
vector<long long> v;
long long k = 0;
queue<long long> q;
while (k != n) {
if (q.empty()) {
q.push((*(cur.begin())));
continue;
}
cur.erase(q.front());
long long ans = 0;
while (!q.empty()) {
ans++;
long long p = q.front();
q.pop();
vector<long long> v;
for (long long i : cur)
if ((s.find({p, i}) == s.end()) && (s.find({i, p}) == s.end()))
v.emplace_back(i), q.push(i);
for (long long i : v) cur.erase(i);
}
k += ans;
v.emplace_back(ans);
}
cout << (long long)v.size() << '\n';
sort((v).begin(), (v).end());
for (long long i : v) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200009;
int n, m, a[MAXN];
vector<int> v[MAXN];
list<int> l;
bool vis[MAXN], con[MAXN];
int bfs(int x) {
queue<int> q;
q.push(x);
int tmp = 0;
while (!q.empty()) {
x = q.front();
q.pop();
if (vis[x]) continue;
vis[x] = 1;
++tmp;
for (auto i : v[x]) con[i] = 1;
for (auto j = l.begin(); j != l.end();) {
int y = *j;
if (y == x)
l.erase(j++);
else if (!con[y]) {
q.push(y);
l.erase(j++);
} else
j++;
}
for (auto i : v[x]) con[i] = 0;
}
return tmp;
}
int main() {
memset(vis, 0, sizeof(vis));
memset(con, 0, sizeof(con));
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= m; ++i) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= n; ++i) l.push_back(i);
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
a[++ans] = bfs(i);
}
printf("%d\n", ans);
sort(a + 1, a + 1 + ans);
for (int i = 1; i <= ans; ++i) {
printf("%d%c", a[i], i == ans ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int parent[200100];
int c = 0;
int find_set(int x) {
c++;
if (parent[x] == x) {
return x;
} else {
return find_set(parent[x]);
}
}
int rnk[200100];
void union_set(int x, int y) {
if (find_set(y) != find_set(x)) {
int a = find_set(y);
int b = find_set(x);
if (rnk[a] < rnk[b]) {
parent[a] = b;
} else if (rnk[b] < rnk[a]) {
parent[b] = a;
} else {
parent[a] = b;
rnk[b]++;
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++) {
rnk[i] = 0;
}
for (int i = 1; i <= n; i++) {
parent[i] = i;
}
parent[0] = 0;
bool a[n + 2];
if (n > 10000) {
list<int> no_edge[n + 1];
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
no_edge[x].push_back(y);
no_edge[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (n - no_edge[i].size() >= 250000 / n + 2) {
union_set(i, 0);
} else {
for (int j = 0; j <= n; j++) {
a[j] = false;
}
for (int &j : no_edge[i]) {
a[j] = true;
}
a[0] = true;
for (int j = 1; j <= n; j++) {
if (!a[j]) {
union_set(i, j);
}
}
}
}
} else {
bool adj[n + 1][n + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
adj[i][j] = true;
}
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
adj[x][y] = false;
adj[y][x] = false;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (adj[i][j]) {
union_set(i, j);
}
}
}
}
int counter[n + 1];
for (int i = 0; i <= n; i++) counter[i] = 0;
for (int i = 1; i <= n; i++) {
counter[find_set(i)]--;
}
sort(counter, counter + n + 1);
int k = 0;
while (counter[k] != 0) k++;
printf("%d\n", k);
for (int i = k - 1; i >= 0; i--) {
printf("%d ", -counter[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, u, v, sl, dem, kq[200001], tp;
set<int> s, a[200001];
set<int>::iterator it;
queue<int> kq2;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) s.insert(i);
for (int i = 1; i <= k; i++) {
cin >> u >> v;
a[u].insert(v);
a[v].insert(u);
}
while (!s.empty()) {
tp = *s.begin();
s.erase(tp);
queue<int> que;
que.push(tp);
dem = 1;
while (!que.empty()) {
u = que.front();
que.pop();
for (it = s.begin(); it != s.end(); it++) {
v = *it;
if (a[u].find(v) == a[u].end()) {
kq2.push(v);
dem++;
que.push(v);
}
}
while (!kq2.empty()) {
int w = kq2.front();
s.erase(w);
kq2.pop();
}
}
kq[++sl] = dem;
}
sort(kq + 1, kq + sl + 1);
cout << sl << "\n";
for (int i = 1; i <= sl; i++) cout << kq[i] << " ";
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
vector<int> adj[200000], vis(200000);
int n, m;
int search(int cur) {
int ret = 0;
vector<int> ad(n);
for (int i = 0; i < n; i++) ad[i] = i;
queue<int> q;
q.push(cur);
while (!q.empty()) {
ret++;
int tp = q.front();
q.pop();
vis[tp] = 1;
int ci = 0, ni = 0;
vector<int> temp;
while (ni < adj[tp].size() && ci < ad.size()) {
if (ad[ci] == adj[tp][ni]) {
temp.push_back(ad[ci]);
ci++;
ni++;
} else if (ad[ci] > adj[tp][ni])
ni++;
else {
if (!vis[ad[ci]]) q.push(ad[ci]);
ci++;
}
}
while (ci < ad.size()) {
if (!vis[ad[ci]]) q.push(ad[ci]);
ci++;
}
ad.swap(temp);
}
return ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 0; i < n; i++) sort(adj[i].begin(), adj[i].end());
vector<int> ans;
for (int i = 0; i < n; i++)
if (!vis[i]) ans.push_back(search(i));
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i : ans) cout << i << " ";
cin >> n;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
int n, m;
set<int> G[MAXN + 10];
int id[MAXN + 10], ii = 0;
set<int> nvis;
int cc[MAXN + 10];
void bfs(int S) {
++ii;
queue<int> qq;
qq.push(S);
id[S] = ii;
nvis.erase(S);
while (!qq.empty()) {
int u = qq.front();
qq.pop();
cc[ii]++;
for (auto it = nvis.begin(); it != nvis.end();) {
if (!G[u].count(*it)) {
auto jt = it;
++it;
id[*jt] = ii;
qq.push(*jt);
nvis.erase(jt);
} else
++it;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].insert(v);
G[v].insert(u);
}
for (int i = 1; i <= n; i++) nvis.insert(i);
for (int i = 1; i <= n; i++) {
if (!id[i]) bfs(i);
}
printf("%d\n", ii);
sort(cc + 1, cc + ii + 1);
for (int i = 1; i <= ii; i++) printf("%d ", cc[i]);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
set<long long int> v[200005], unvis;
long long int k = 0;
void dfs(long long int r) {
k++;
unvis.erase(r);
vector<long long int> nex;
for (auto i : unvis) {
if (v[r].find(i) == v[r].end()) nex.push_back(i);
}
for (auto i : nex) unvis.erase(i);
for (auto i : nex) dfs(i);
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, m, x, y;
cin >> n >> m;
for (long long int i = 1; i <= m; i++) {
cin >> x >> y;
v[x].insert(y);
v[y].insert(x);
}
for (long long int i = 1; i <= n; i++) unvis.insert(i);
vector<long long int> ans;
for (long long int i = 1; i <= n; i++)
if (unvis.find(i) != unvis.end()) {
k = 0;
dfs(i);
ans.push_back(k);
}
sort(ans.begin(), ans.end());
cout << (long long int)ans.size() << "\n";
for (auto i : ans) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const int N = 200010;
int n, m, l, r, curget, arr[N], seg[4 * N], lazy[4 * N], val, frq[N], tmp[N];
vector<int> g[N];
void build(int s, int e, int idx) {
if (s == e) {
seg[idx] = s;
return;
}
build(s, (s + e) / 2, idx * 2);
build((s + e) / 2 + 1, e, idx * 2 + 1);
}
void fix(int idx) {
if (lazy[idx] == -1) return;
lazy[idx * 2] = lazy[idx * 2 + 1] = seg[idx] = lazy[idx];
lazy[idx] = -1;
}
void get(int s, int e, int idx) {
if (s != e) fix(idx);
if (s > r || e < l) return;
if (s >= l && e <= r) {
if (lazy[idx] != -1) {
seg[idx] = lazy[idx];
lazy[idx] = -1;
}
curget = seg[idx];
return;
}
get(s, (s + e) / 2, idx * 2);
get((s + e) / 2 + 1, e, idx * 2 + 1);
}
void update(int s, int e, int idx) {
if (s != e) fix(idx);
if (s > r || e < l) return;
if (s >= l && e <= r) {
lazy[idx] = val;
return;
}
update(s, (s + e) / 2, idx * 2);
update((s + e) / 2 + 1, e, idx * 2 + 1);
}
int main() {
memset(lazy, -1, sizeof(lazy));
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
frq[i] = 1;
arr[i] = i;
}
build(0, n - 1, 1);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < g[i].size(); j++) {
l = g[i][j];
r = g[i][j];
get(0, n - 1, 1);
arr[g[i][j]] = curget;
tmp[arr[g[i][j]]]++;
}
l = i;
r = i;
get(0, n - 1, 1);
val = i;
frq[i] = n;
l = 0, r = n - 1;
update(0, n - 1, 1);
for (int j = 0; j < g[i].size(); j++) {
l = g[i][j];
r = g[i][j];
if (tmp[arr[g[i][j]]] < frq[arr[g[i][j]]]) continue;
frq[i]--;
val = arr[g[i][j]];
update(0, n - 1, 1);
}
for (int j = 0; j < g[i].size(); j++) {
tmp[arr[g[i][j]]]--;
}
}
memset(frq, 0, sizeof(frq));
for (int i = 0; i < n; i++) {
l = r = i;
get(0, n - 1, 1);
frq[curget]++;
}
vector<int> ans;
for (int i = 0; i < n; i++) {
if (frq[i] > 0) {
ans.push_back(frq[i]);
}
}
cout << ans.size() << endl;
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[200010];
set<int> s;
int sz[200010], cnt;
int nxt(int u) { return *s.upper_bound(u); }
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n + 1; ++i) s.insert(i);
for (int u = 1; u <= n; ++u) {
if (s.find(u) != s.end()) {
++cnt;
queue<int> q;
q.push(u);
s.erase(u);
while (!q.empty()) {
int u = q.front();
q.pop();
++sz[cnt];
vector<int> save;
for (auto v : adj[u]) {
if (s.find(v) == s.end()) continue;
s.erase(v);
save.push_back(v);
}
int v = *s.begin();
while (v <= n) {
q.push(v);
s.erase(v);
v = nxt(v);
}
for (auto v : save) s.insert(v);
}
}
}
cout << cnt << "\n";
sort(sz + 1, sz + cnt + 1);
for (int i = 1; i <= cnt; ++i) cout << sz[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, bool> mp[300000];
vector<int> q, ans;
int n, m, l[300000], x;
char s[3000000];
int read() {
int p = 0, q = 1;
char ch = getchar();
while (s[x] < '0' || s[x] > '9') x++;
while (s[x] >= '0' && s[x] <= '9') p = p * 10 + s[x++] - '0';
return p * q;
}
int bfs(int u) {
int le = 0, ri = 1, size = q.size();
l[1] = u;
while (le < ri) {
int v = l[++le];
for (int j = 0; j < size; j++)
if (!mp[v][q[j]]) {
l[++ri] = q[j];
q[j--] = q[--size];
q.pop_back();
}
}
return ri;
}
int main() {
fread(s, 1, 3000000 - 5, stdin);
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
mp[u][v] = 1;
mp[v][u] = 1;
}
for (int i = 1; i <= n; i++) q.push_back(i);
while (!q.empty()) {
int v = q.back();
q.pop_back();
ans.push_back(bfs(v));
}
int cnt = ans.size();
sort(ans.begin(), ans.end());
cout << cnt << endl;
for (int i = 0; i < cnt; i++) printf("%d ", ans[i]);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, cnt;
set<int> st1[200001], st2;
vector<int> ans;
void bfs(int s) {
queue<int> q;
q.push(s);
if (st2.find(s) != st2.end()) st2.erase(s);
while (!q.empty()) {
int v = q.front();
cnt++;
q.pop();
vector<int> aux;
for (auto it : st2) {
if (st1[v].find(it) == st1[v].end()) {
q.push(it);
aux.push_back(it);
}
}
for (auto it : aux) st2.erase(it);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
st1[x].insert(y);
st1[y].insert(x);
}
for (int i = 1; i <= n; i++) st2.insert(i);
for (int i = 1; i <= n; i++) {
if (st2.find(i) != st2.end()) {
cnt = 0;
bfs(i);
ans.push_back(cnt);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (auto it : ans) cout << it << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
map<int, int> G[maxn];
vector<int> ans;
set<int> s;
inline void dfs(int u) {
vector<int> tmp;
for (int v : s)
if (G[u].find(v) == G[u].end()) tmp.push_back(v);
for (int x : tmp) s.erase(x);
for (int v : tmp) dfs(v);
}
int n, m;
int main() {
cin >> n >> m;
for (int u, v, i = 1; i <= m; i++) cin >> u >> v, G[u][v] = G[v][u] = 1;
for (int i = 1; i <= n; i++) s.insert(i);
while (!s.empty()) {
int u = *s.begin(), pre = s.size();
dfs(u);
ans.push_back(pre - s.size());
}
cout << ans.size() << '\n';
sort(ans.begin(), ans.end());
for (int x : ans) cout << x << " ";
return 0 - 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<set<int>> neighbors;
vector<bool> visited;
set<int> unvisited;
int current;
void dfs(int i) {
++current;
visited[i] = true;
unvisited.erase(i);
int last = 0;
for (auto& neighbor : neighbors[i]) {
while (true) {
auto next = unvisited.upper_bound(last);
if (next == unvisited.end() || *next >= neighbor) break;
dfs(*next);
}
last = neighbor;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
neighbors.resize(n);
for (int i = 0; i < n; ++i) unvisited.insert(i), neighbors[i].insert(n);
while (m--) {
int x, y;
cin >> x >> y;
--x;
--y;
neighbors[x].insert(y);
neighbors[y].insert(x);
}
visited.resize(n, false);
vector<int> answers;
for (int i = 0; i < n; ++i)
if (!visited[i]) {
current = 0;
dfs(i);
answers.push_back(current);
}
sort(answers.begin(), answers.end());
cout << answers.size() << '\n';
for (auto& answer : answers) cout << answer << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200010;
const int MOD = 1000000007;
const int INF = (int)1e9;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const long double EPS = 1e-7;
set<int> vert;
set<int> g[MAX];
struct DSU {
int n;
vector<int> parent, size;
DSU(int n) {
this->n = n;
parent.assign(n + 1, 0);
size.assign(n + 1, 1);
for (int i = 0; i <= n; i++) parent[i] = i;
}
int find(int v) {
if (v == parent[v]) return v;
return parent[v] = find(parent[v]);
}
void join(int a, int b) {
a = find(a);
b = find(b);
if (a != b) {
if (size[a] < size[b]) swap(a, b);
parent[b] = a;
size[a] += size[b];
}
}
int sz(int v) { return size[find(v)]; }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].insert(b);
g[b].insert(a);
}
for (int i = 1; i <= n; i++) {
vert.insert(i);
}
DSU dsu = DSU(n + 50);
for (int i = 1; i <= n; i++) {
if (!vert.count(i)) continue;
queue<int> q;
q.push(i);
vert.erase(i);
while (!q.empty()) {
int v = q.front();
q.pop();
vector<int> apagar;
for (int u : vert) {
if (!g[v].count(u)) {
q.push(u);
dsu.join(dsu.find(u), dsu.find(v));
apagar.push_back(u);
}
}
for (auto u : apagar) {
vert.erase(u);
}
}
}
vector<int> res, foi(n + 50, 0);
for (int i = 1; i <= n; i++) {
int v = dsu.find(i);
if (!foi[v]) {
foi[v] = 1;
res.push_back(dsu.sz(v));
}
}
sort(res.begin(), res.end());
cout << res.size() << '\n';
for (auto r : res) cout << r << " ";
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("avx,avx2,fma")
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int a, k, nc = 0, isz = 0;
vector<unordered_set<int>> n, l;
vector<int> cmp, vrt;
void dfs(int v) {
cmp[v] = nc;
vrt.push_back(v);
for (int i : l[v]) {
if (cmp[i] == -1)
dfs(i);
else if (cmp[i] != nc) {
assert(cmp[i] == 0);
isz = 1;
}
}
}
int main() {
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
;
cin >> a >> k;
cmp = vector<int>(a, -1);
l = vector<unordered_set<int>>(a, unordered_set<int>());
n = vector<unordered_set<int>>(a, unordered_set<int>());
for (int q = 0; q < k; q++) {
int x, y;
cin >> x >> y;
x--, y--;
n[x].insert(y);
n[y].insert(x);
}
for (int q = 0; q < a; q++) {
int sos = (a - 1) - n[q].size();
if (sos > a / 2) cmp[q] = 0;
}
for (int q = 0; q < a; q++) {
if (cmp[q] != -1) continue;
for (int w = 0; w < a; w++) {
if (w == q || n[q].count(w)) continue;
l[q].insert(w);
}
}
for (int q = 0; q < a; q++) {
if (cmp[q] != -1) continue;
nc = q + 1;
vrt.clear();
isz = 0;
dfs(q);
if (isz) {
for (int i : vrt) cmp[i] = 0;
}
}
map<int, int> mp;
for (int i : cmp) mp[i]++;
vector<int> u;
for (pair<int, int> p : mp) u.push_back(p.second);
sort(u.begin(), u.end());
cout << u.size() << "\n";
for (int i : u) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 7;
int N, M, head[maxN], cnt;
struct LIST {
int pre, nex;
LIST(int a = 0, int b = 0) : pre(a), nex(b) {}
} lst[maxN];
inline void Del(int id) {
lst[lst[id].pre].nex = lst[id].nex;
lst[lst[id].nex].pre = lst[id].pre;
lst[id] = LIST();
}
struct Eddge {
int nex, to;
Eddge(int a = -1, int b = 0) : nex(a), to(b) {}
} edge[maxN << 1];
inline void addEddge(int u, int v) {
edge[cnt] = Eddge(head[u], v);
head[u] = cnt++;
}
inline void _add(int u, int v) {
addEddge(u, v);
addEddge(v, u);
}
bool vis[maxN] = {false};
int siz[maxN], KK = 0;
void bfs() {
int it;
while (lst[0].nex != N + 1) {
siz[++KK] = 1;
it = lst[0].nex;
Del(it);
queue<int> Q;
Q.push(it);
int u, now, nex;
while (!Q.empty()) {
u = Q.front();
Q.pop();
for (int i = head[u], v; ~i; i = edge[i].nex) {
v = edge[i].to;
vis[v] = true;
}
now = lst[0].nex;
while (now != N + 1) {
nex = lst[now].nex;
if (vis[now])
vis[now] = false;
else {
Del(now);
Q.push(now);
siz[KK]++;
}
now = nex;
}
}
}
}
inline void init() {
cnt = 0;
for (int i = 1; i <= N; i++) {
head[i] = -1;
lst[i] = LIST(i - 1, i + 1);
}
lst[0].nex = 1;
lst[N + 1].pre = N;
}
int main() {
scanf("%d%d", &N, &M);
init();
for (int i = 1, u, v; i <= M; i++) {
scanf("%d%d", &u, &v);
_add(u, v);
}
bfs();
printf("%d\n", KK);
sort(siz + 1, siz + KK + 1);
for (int i = 1; i <= KK; i++) printf("%d%c", siz[i], i == KK ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<pair<int, int> > S;
int L[4040][4040];
int p[200020];
int Find(int x) { return p[x] == x ? x : p[x] = Find(p[x]); }
int z[200020];
int deg[200020];
void Uni(int x, int y) {
int pi = Find(x), pj = Find(y);
if (pi != pj) p[pi] = pj, z[pj] += z[pi];
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x > y) swap(x, y);
if (n <= 4000) L[x][y] = 1;
S.insert(pair<int, int>(x, y));
deg[x]--;
deg[y]--;
}
for (int i = 1; i <= n; i++) p[i] = i, z[i] = 1, deg[i] += n - 1;
if (n <= 4000) {
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (L[i][j] == 0) {
Uni(i, j);
}
} else {
vector<int> o, u;
for (int i = 1; i <= n; i++) {
if (deg[i] > 70)
o.push_back(i);
else
u.push_back(i);
}
for (int i = 1; i < ((int)(o).size()); i++) {
Uni(o[0], o[i]);
}
for (int e : u) {
for (int i = 1; i <= n; i++) {
if (S.find(pair<int, int>(min(e, i), max(e, i))) == S.end()) {
Uni(e, i);
}
}
}
}
vector<int> v;
for (int i = 1; i <= n; i++)
if (p[i] == i) v.push_back(z[i]);
sort((v).begin(), (v).end());
printf("%d\n", ((int)(v).size()));
for (int e : v) printf("%d ", e);
puts("");
}
int main() {
int Tc = 1;
for (int tc = 1; tc <= Tc; tc++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
set<int> e[N], s;
int dfs(int u) {
int res = 1;
for (auto it = s.begin(); it != s.end();)
if (!e[u].count(*it)) {
int x = *it;
s.erase(it);
res += dfs(x);
it = s.lower_bound(x);
} else
it++;
return res;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
e[u].insert(v);
e[v].insert(u);
}
for (int i = 1; i <= n; ++i) s.insert(i);
vector<int> ans;
for (int i = 1; i <= n; ++i) {
if (s.empty()) break;
if (s.count(i)) {
s.erase(s.find(i));
ans.push_back(dfs(i));
}
}
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (auto &x : ans) printf("%d ", x);
return !printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<set<int> > ar(n);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
ar[a].insert(b);
ar[b].insert(a);
}
vector<int> sizes;
vector<bool> used(n, false);
set<int> need;
for (int i = 0; i < n; ++i) need.insert(i);
vector<int> q(n);
for (int i = 0; i < n; ++i) {
if (used[i]) continue;
need.erase(i);
int beg = 0;
int end = 1;
q[0] = i;
while (beg < end) {
int cur = q[beg++];
used[cur] = true;
for (set<int>::iterator it = need.begin(); it != need.end();) {
if (ar[cur].find(*it) == ar[cur].end()) {
q[end++] = *it;
need.erase(it++);
} else {
it++;
}
}
}
sizes.push_back(end);
}
sort(sizes.begin(), sizes.end());
cout << sizes.size() << endl;
for (int i = 0; i < sizes.size(); ++i) {
cout << sizes[i] << " ";
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
int dx[] = {2, 2, -2, -2, 1, 1, -1, -1};
int dy[] = {-1, 1, 1, -1, 2, -2, 2, -2};
int dxx[] = {1, 0, 0, -1};
int dyy[] = {0, 1, -1, 0};
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void add(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
int poww(int x, int y) {
if (y == 0) return 1;
if (y == 1) return x;
return x * poww(x, y - 1);
}
long long int strtoint(string s) {
int l = s.length();
long long int temp = 0;
for (int i = 0; i < l; i++) {
if (i != l - 1)
temp = temp + (s[i] - '0') * poww(10, l - i - 1);
else
temp = temp + (s[i] - '0');
}
return temp;
}
int isprime(long long int x) {
if (x == 1) return 1;
if (x == 2) return 1;
if (x == 3) return 1;
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
void cpgod() {}
int lexbig(string s1, string s2) {
int n1, n2;
n1 = s1.length();
n2 = s2.length();
for (int i = 0; i < n1; i++) {
if (s1[i] - 'a' > s2[i] - 'a')
return 1;
else if (s1[i] - 'a' < s2[i] - 'a')
return 0;
else
continue;
}
if (n1 == n2)
return 1;
else
return 0;
}
long long int fast_pow(long long int a, long long int p) {
long long int res = 1;
while (p) {
if (p % 2 == 0) {
a = a * 1ll * a % 1000000007;
p /= 2;
} else {
res = res * 1ll * a % 1000000007;
p--;
}
}
return res;
}
long long int lcm(long long int x, long long int y) {
long long int t = x * y;
t = t / (gcd(x, y));
return t;
}
long long int modadd(long long int a, long long int b) {
a = a % 1000000007;
b = b % 1000000007;
return (a + b) % 1000000007;
}
int binaryToDecimal(string n) {
string num = n;
int dec_value = 0;
int base = 1;
int len = num.length();
for (int i = len - 1; i >= 0; i--) {
if (num[i] == '1') dec_value += base;
base = base * 2;
}
return dec_value;
}
long long int ncr(long long int x, long long int y) {
long long int mul = 1;
for (int i = x; i > x - y; i--)
mul = (mul % 1000000007 * i % 1000000007) % 1000000007;
long long int rem = 1;
for (int i = 2; i <= y; i++)
rem = (rem % 1000000007 * i % 1000000007) % 1000000007;
rem = fast_pow(rem, 1000000007 - 2);
return (mul % 1000000007 * rem % 1000000007) % 1000000007;
}
vector<set<long long int>> adj(200020);
set<long long int> notused;
int con[200020];
int temp = 0;
vector<int> vaa;
void dfs(int src) {
temp++;
notused.erase(src);
int cur = -1;
while (1) {
auto it = notused.upper_bound(cur);
if (it == notused.end()) break;
cur = *it;
if (adj[src].count(cur)) continue;
dfs(cur);
}
}
int main() {
cpgod();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) notused.insert(i);
long long int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
adj[a].insert(b);
adj[b].insert(a);
}
int sum = 0;
while (notused.size() != 0) {
int ta = *(notused.begin());
temp = 0;
dfs(ta);
vaa.push_back(temp);
sum++;
}
cout << sum << endl;
sort(vaa.begin(), vaa.end());
for (auto u : vaa) cout << u << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 1;
set<int> adj[MX], not_vstd;
int dfs(int u) {
not_vstd.erase(u);
int res = 1;
int i = 0;
for (auto it = not_vstd.begin(); it != not_vstd.end();
it = not_vstd.upper_bound(i)) {
i = *it;
if (!adj[u].count(i)) {
res += dfs(i);
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
while (m--) {
int u, v;
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
}
for (int i = 1; i <= n; ++i) {
not_vstd.insert(i);
}
vector<int> ans;
for (int i = 1; i <= n; ++i) {
if (not_vstd.count(i)) {
ans.push_back(dfs(i));
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (auto i : ans) {
cout << i << ' ';
}
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 3;
set<int> s, g[N];
int m, n;
int cnt = 0;
vector<int> ans;
void DFS(int u) {
++cnt;
vector<int> vt;
for (int v : s) {
if (!g[u].count(v) && (s.count(v))) {
vt.push_back(v);
}
}
for (int v : vt) {
s.erase(v);
}
for (int v : vt) {
DFS(v);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) s.insert(i);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].insert(v);
g[v].insert(u);
}
for (int i = 1; i <= n; ++i) {
if (s.count(i)) {
cnt = 0;
s.erase(i);
DFS(i);
ans.push_back(cnt);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (int i : ans) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> adj[200000];
set<int> unvis;
int sz[200000];
int cur = 0;
void dfs(int x) {
sz[cur]++;
auto it = unvis.begin();
while (it != unvis.end()) {
if (adj[x].count(*it)) {
it++;
} else {
int last = *it;
unvis.erase(it);
dfs(last);
it = unvis.upper_bound(last);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].insert(b);
adj[b].insert(a);
}
for (int i = 0; i < n; i++) {
unvis.insert(i);
}
for (int i = 0; i < n; i++) {
auto it = unvis.find(i);
if (it != unvis.end()) {
unvis.erase(it);
dfs(i);
cur++;
}
}
cout << cur << endl;
sort(sz, sz + cur);
for (int i = 0; i < cur; i++) {
cout << sz[i] << ' ';
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200043;
set<int> g[N];
set<int> mas;
int cc = 0;
vector<int> comp;
void dfs(int x) {
mas.erase(x);
comp[cc]++;
int cur = -1;
while (true) {
auto it = mas.upper_bound(cur);
if (it == mas.end()) break;
cur = *it;
if (g[x].count(cur)) continue;
dfs(cur);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
--x;
--y;
g[x].insert(y);
g[y].insert(x);
}
for (int i = 0; i < n; i++) mas.insert(i);
for (int i = 0; i < n; i++)
if (mas.count(i)) {
comp.push_back(0);
dfs(i);
cc++;
}
sort(comp.begin(), comp.end());
printf("%d\n", cc);
for (int i = 0; i < cc; i++) printf("%d ", comp[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void INPUT() {}
const int N = 200005;
set<int> s;
map<pair<int, int>, bool> h;
int tot, n, x, y, m;
void dfs(int node) {
tot++;
s.erase(node);
set<int>::iterator it = s.begin();
int id;
while (it != s.end()) {
id = *it;
if (!h.count(make_pair(node, id))) {
dfs(id);
it = (s.begin());
} else
it++;
}
}
void solve() {
cin >> n >> m;
h.clear();
s.clear();
while (m--) {
cin >> x >> y;
x--;
y--;
h[make_pair(x, y)] = 1;
h[make_pair(y, x)] = 1;
}
for (int i = 0; i <= n - 1; i++) s.insert(i);
vector<int> ans;
int node;
while (!s.empty()) {
node = *(s.begin());
tot = 0;
dfs(node);
ans.push_back(tot);
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (auto &i : ans) cout << i << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
INPUT();
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt;
set<int> gr[200005];
set<int> st;
set<int>::iterator it;
void dfs(int u) {
st.erase(u);
int v = 0;
cnt++;
while (1) {
it = st.upper_bound(v);
if (it == st.end()) break;
v = *it;
if (gr[u].find(v) == gr[u].end()) dfs(v);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
gr[u].insert(v);
gr[v].insert(u);
}
for (int i = 1; i <= n; i++) st.insert(i);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (st.find(i) != st.end()) {
cnt = 0;
dfs(i);
ans.push_back(cnt);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < (int)ans.size(); i++) {
printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct DSU {
int n;
vector<int> par, sz;
set<int> roots;
void assign(int n_) {
n = n_;
par.assign(n, 0);
iota(par.begin(), par.end(), 0);
sz.assign(n, 1);
roots = set<int>(par.begin(), par.end());
}
int get_par(int v) { return par[v] == v ? v : par[v] = get_par(par[v]); }
void unite(int v, int u) {
v = get_par(v);
u = get_par(u);
if (v != u) {
if (sz[v] < sz[u]) {
swap(u, v);
}
par[u] = v;
sz[v] += sz[u];
roots.erase(u);
}
}
vector<int> get_sizes() {
vector<int> sizes;
for (int i = 0; i < n; i++) {
if (par[i] == i) {
sizes.push_back(sz[i]);
}
}
sort(sizes.begin(), sizes.end());
return sizes;
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int>> G;
G.assign(n, vector<int>());
for (int i = 0; i < m; i++) {
int v, u;
cin >> v >> u;
v--, u--;
G[max(v, u)].push_back(min(v, u));
}
DSU dsu;
dsu.assign(n);
for (int i = 0; i < n; i++) {
unordered_map<int, int> cnts;
for (auto &root : dsu.roots) {
if (root >= i) {
break;
}
cnts[root] = 0;
}
for (auto &j : G[i]) {
cnts[dsu.get_par(j)]++;
}
vector<int> need;
for (auto &[root, cnt] : cnts) {
if (cnt < dsu.sz[root]) {
need.push_back(root);
}
}
for (auto &root : need) {
dsu.unite(root, i);
}
}
vector<int> sizes = dsu.get_sizes();
cout << sizes.size() << '\n';
for (auto &el : sizes) {
cout << el << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long read() {
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 * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
long long quickmod(long long x, long long y) {
long long Ans = 1;
while (y) {
if (y & 1) Ans = (Ans * x) % mod;
x = (x * x) % mod;
y >>= 1;
}
return Ans;
}
struct st {
long long v, e, id;
st() {}
st(long long A, long long B, long long C) { v = A, e = B, id = C; }
};
vector<st> G[200005];
long long fa[200005], siz[200005];
void makeSet(long long x) {
for (long long i = 1; i <= x; i++) fa[i] = i, siz[i] = 1;
}
long long findSet(long long x) {
if (x == fa[x]) return x;
fa[x] = findSet(fa[x]);
return fa[x];
}
long long tot = 0;
struct Edge {
long long u, v, e;
} q[1000005];
bool cmp(Edge A, Edge B) { return A.e < B.e; }
long long vis[200005], vis2[200005];
vector<long long> V;
signed main() {
long long n = read(), m = read();
long long sum = 0;
for (long long i = 1; i <= m; i++) {
long long u = read(), v = read();
long long e = 0;
sum ^= e;
G[u].push_back(st(v, e, i));
G[v].push_back(st(u, e, i));
}
long long Ans = n;
long long pl = 1;
for (long long i = 1; i <= n; i++)
if (G[i].size() < G[pl].size()) pl = i;
makeSet(n);
for (long long i = 0; i < (long long)G[pl].size(); i++) vis[G[pl][i].v] = 1;
for (long long i = 1; i <= n; i++)
if (vis[i] == 0)
if (findSet(i) != findSet(pl))
siz[findSet(pl)] += siz[findSet(i)], fa[findSet(i)] = findSet(pl),
Ans--;
for (long long i = 1; i <= n; i++) {
if (vis[i]) {
for (long long j = 0; j < (long long)G[i].size(); j++)
vis2[G[i][j].v] = 1;
for (long long j = 1; j <= n; j++) {
if (vis2[j] == 0 && findSet(i) != findSet(j)) {
siz[findSet(j)] += siz[findSet(i)];
fa[findSet(i)] = findSet(j);
Ans--;
}
}
for (long long j = 0; j < (long long)G[i].size(); j++)
vis2[G[i][j].v] = 0;
}
}
memset(vis, 0, sizeof vis);
printf("%lld\n", Ans);
for (long long i = 1; i <= n; i++) {
if (vis[findSet(i)] == 0) {
vis[findSet(i)] = 1;
V.push_back(siz[findSet(i)]);
}
}
sort(V.begin(), V.end());
for (long long i = 0; i < V.size(); i++) printf("%lld ", V[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m, cnt;
set<int> S;
bool vis[maxn];
int ans[maxn];
set<int> adj[maxn];
void DFS(int u) {
int v;
vis[u] = 1;
S.erase(u);
ans[cnt]++;
for (set<int>::iterator si = S.begin(); si != S.end();) {
if (adj[u].find(v = *si) == adj[u].end()) {
DFS(v);
si = S.upper_bound(v);
} else {
si++;
}
}
}
int main() {
int i, j, k, u, v;
scanf("%d%d", &n, &m);
for (i = (1); i <= (m); i++) {
scanf("%d%d", &u, &v);
adj[u].insert(v);
adj[v].insert(u);
}
for (i = (1); i <= (n); i++) {
S.insert(i);
}
for (i = (1); i <= (n); i++) {
if (!vis[i]) {
cnt++;
DFS(i);
}
}
sort(ans + 1, ans + cnt + 1);
printf("%d\n", cnt);
for (i = (1); i <= (cnt - 1); i++) {
printf("%d ", ans[i]);
}
printf("%d\n", ans[cnt]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<int> nv;
set<int> adj[1000006];
int cnt = 0;
vector<int> ans;
bool vstd[1000006];
void dfs(int x) {
cnt++;
vstd[x] = 1;
nv.erase(x);
for (auto i = nv.begin(); i != nv.end();) {
if (adj[x].count(*i)) {
i++;
continue;
}
int t = *i;
dfs(t);
i = nv.lower_bound(t);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
adj[x].insert(y);
adj[y].insert(x);
}
for (int i = 1; i <= n; i++) {
nv.insert(i);
}
for (int i = 1; i <= n; i++) {
if (!vstd[i]) {
cnt = 0;
dfs(i);
ans.push_back(cnt);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (auto i : ans) {
printf("%d ", i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long lit = 2000;
long long enough = 200;
vector<vector<long long> > rev(200500), con(200500);
vector<long long> color(200500, 0);
vector<bool> used(200500, false);
bool a[2002][2002];
void dfs(long long start, long long c) {
used[start] = true;
color[start] = c;
for (long long i = 1; i <= n; i++) {
if ((a[start][i]) && (!used[i]) && (color[i] == 0)) {
dfs(i, c);
}
}
}
void dfs2(long long start, long long c) {
used[start] = true;
color[start] = c;
for (long long i = 0; i < con[start].size(); i++) {
long long Next = con[start][i];
if ((!used[Next]) && (color[Next] == 0))
dfs2(Next, c);
else if (!used[Next] && color[Next] != 0 && color[Next] != c) {
for (long long j = 1; j <= n; j++)
if (color[j] == c) color[j] = color[Next];
}
}
}
int main() {
cin >> n >> m;
long long i, j;
if (n <= lit) {
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
a[i][j] = true;
}
}
for (i = 0; i < m; i++) {
long long q, w;
cin >> q >> w;
a[q][w] = false;
a[w][q] = false;
}
long long cl = 0;
for (i = 1; i <= n; i++) {
if (color[i] == 0) {
cl++;
dfs(i, cl);
}
}
cout << cl << endl;
vector<long long> rez(cl + 1, 0);
for (i = 1; i <= n; i++) {
rez[color[i]]++;
}
sort(rez.begin() + 1, rez.end());
for (i = 1; i < rez.size(); i++) cout << rez[i] << " ";
return 0;
}
for (i = 0; i < m; i++) {
long long q, w;
cin >> q >> w;
rev[q].push_back(w);
rev[w].push_back(q);
}
long long col = 1;
for (i = 1; i <= n; i++) {
if (rev[i].size() < enough) color[i] = 1;
}
for (i = 1; i <= n; i++) {
if (rev[i].size() >= enough) {
vector<long long> temp(n + 2, 1);
temp[i] = 0;
for (j = 0; j < rev[i].size(); j++) {
long long cur = rev[i][j];
temp[cur] = 0;
}
for (j = 1; j <= n; j++) {
if (temp[j]) {
if (color[j] == 1) {
color[i] = 1;
con[i].clear();
break;
} else
con[i].push_back(j);
}
}
}
}
for (i = 1; i <= n; i++) {
if (rev[i].size() == n - 1 && (color[i] == 0)) {
col++;
color[i] = col;
} else if (rev[i].size() == 0) {
cout << 1 << endl;
cout << n;
return 0;
} else if ((rev[i].size() >= enough) && (color[i] == 0)) {
col++;
dfs2(i, col);
}
}
bool need = false;
for (i = 1; i <= n; i++) {
if (color[i] == 0) need = true;
}
if (need) {
col++;
for (i = 1; i <= n; i++)
if (color[i] == 0) color[i] = col;
}
vector<long long> ans(col + 1, 0);
for (i = 1; i <= n; i++) {
ans[color[i]]++;
}
sort(ans.begin() + 1, ans.end());
long long cnt = 0;
for (i = 1; i < ans.size(); i++)
if (ans[i] > 0) cnt++;
cout << cnt << endl;
for (i = 1; i < ans.size(); i++)
if (ans[i] > 0) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
list<int> vec;
list<int>::iterator it;
vector<int> a[N];
queue<int> q;
bool flag[N];
bool f[N];
int ans[N];
int n, m;
void bfs(int x, int e) {
while (!q.empty()) q.pop();
q.push(x);
while (!q.empty()) {
int v = q.front();
q.pop();
if (flag[v]) continue;
flag[v] = 1;
ans[e]++;
int len = a[v].size();
for (int i = 0; i < len; i++) f[a[v][i]] = 1;
for (it = vec.begin(); it != vec.end();) {
int u = (*it);
if (!f[u]) {
q.push(u);
vec.erase(it++);
} else
it++;
}
for (int i = 0; i < len; i++) f[a[v][i]] = 0;
}
return;
}
int main() {
ios::sync_with_stdio(false);
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) vec.push_back(i);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (!flag[i]) {
cnt++;
bfs(i, cnt);
}
}
printf("%d\n", cnt);
sort(ans + 1, ans + cnt + 1);
for (int i = 1; i < cnt; i++) {
printf("%d ", ans[i]);
}
printf("%d\n", ans[cnt]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
map<int, int> G[maxn];
vector<int> ans;
set<int> s;
inline void dfs(int u) {
vector<int> tmp;
for (int v : s)
if (G[u].find(v) == G[u].end()) tmp.push_back(v);
for (int x : tmp) s.erase(x);
for (int v : tmp) dfs(v);
}
int n, m;
int main() {
cin >> n >> m;
for (int u, v, i = 1; i <= m; i++) cin >> u >> v, G[u][v] = G[v][u] = 1;
for (int i = 1; i <= n; i++) s.insert(i);
while (!s.empty()) {
int u = *s.begin();
int pre = s.size();
dfs(u);
ans.push_back(pre - s.size());
}
cout << ans.size() << '\n';
sort(ans.begin(), ans.end());
for (int x : ans) cout << x << " ";
return 0 - 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
const int N = 100000 + 10;
struct data {
int to, next;
} tu[N * 2];
int head[N];
int ip;
int dfn[N], low[N];
int sccno[N];
int step;
int scc_cnt;
void init() {
ip = 0;
memset(head, -1, sizeof(head));
}
void add(int u, int v) { tu[ip].to = v, tu[ip].next = head[u], head[u] = ip++; }
vector<int> scc[N];
stack<int> S;
void dfs(int u) {
dfn[u] = low[u] = ++step;
S.push(u);
for (int i = head[u]; i != -1; i = tu[i].next) {
int v = tu[i].to;
if (!dfn[v]) {
dfs(v);
low[u] = min(low[u], low[v]);
} else if (!sccno[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
scc_cnt += 1;
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 tarjan(int n) {
memset(sccno, 0, sizeof(sccno));
memset(dfn, 0, sizeof(dfn));
step = scc_cnt = 0;
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i);
}
int u[100000 + 10];
bool ou[100000 + 10];
int main() {
init();
int n, m, h;
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 a, b;
scanf("%d%d", &a, &b);
if ((u[a] + 1) % (h) == u[b]) {
add(a, b);
}
if ((u[b] + 1) % (h) == u[a]) {
add(b, a);
}
}
tarjan(n);
memset(ou, true, sizeof(ou));
for (int i = 1; i <= n; ++i) {
for (int j = head[i]; j != -1; j = tu[j].next) {
if (sccno[i] != sccno[tu[j].to]) {
ou[sccno[i]] = false;
}
}
}
int ans = 0;
for (int i = 1; i <= scc_cnt; ++i) {
if (ou[i]) {
if (ans == 0 || scc[ans].size() > scc[i].size()) {
ans = i;
}
}
}
printf("%d\n", int(scc[ans].size()));
for (auto i : scc[ans]) {
printf("%d ", i);
}
return 0;
}
|
#include <bits/stdc++.h>
const bool DEBUG = false;
using namespace std;
const long long maxn = 100000 + 5;
const long long INF = 4e18;
const long long M = 1e9 + 7;
const long long M2 = 311;
const int lg = 21;
int n, m, last, h, y, ans, a[maxn], id[maxn], sz[maxn];
vector<int> com[maxn], ko[maxn], vo[maxn];
vector<int> t;
bool mark[maxn], ok[maxn];
void dfsback(int v) {
mark[v] = 1;
id[v] = last;
com[last].push_back(v);
sz[last]++;
for (auto u : vo[v])
if (!mark[u]) dfsback(u);
}
void dfsfor(int v, int p = -1) {
mark[v] = 1;
for (auto u : ko[v]) {
if (!mark[u]) dfsfor(u);
}
t.push_back(v);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> h;
ans = n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y, x--, y--;
if (a[x] == ((a[y] + 1) % h)) {
ko[y].push_back(x);
vo[x].push_back(y);
}
if (a[y] == ((a[x] + 1) % h)) {
ko[x].push_back(y);
vo[y].push_back(x);
}
}
for (int i = 0; i < n; i++)
if (!mark[i]) dfsfor(i);
fill(mark, mark + maxn, 0);
for (int j = n - 1; j >= 0; j--)
if (!mark[t[j]]) {
dfsback(t[j]);
last++;
}
for (int i = 0; i < last; i++) {
bool flag = 1;
for (auto u : com[i]) {
for (auto p : ko[u])
if (id[p] != i) flag = 0;
}
if (flag and ans > sz[i]) ans = sz[i], y = i;
}
cout << ans << endl;
for (auto u : com[y]) cout << u + 1 << " ";
cout << endl;
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;
const double pi =
3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
const int MR = 1e5 + 10;
vector<int> g[MR], g1[MR], rev[MR];
pair<int, int> t[2 * MR];
int u[MR];
int srt[MR], cnt;
int done[MR];
void dfs(int nr, vector<int> *g) {
done[nr] = 1;
for (int i : g[nr])
if (!done[i]) dfs(i, g);
srt[cnt++] = nr;
}
int sccNr, scc[MR], sz[MR];
void dfs(int nr) {
scc[nr] = sccNr;
for (int i : rev[nr])
if (!scc[i]) dfs(i);
}
int main() {
int n, mm, h;
scanf("%d%d%d", &n, &mm, &h);
for (int i = 0; i < (n); ++i) scanf("%d", &u[i]);
int m = 0;
for (int i = 0; i < (mm); ++i) {
int c0, c1;
scanf("%d%d", &c0, &c1);
c0--;
c1--;
if (u[c0] == (u[c1] - 1 + h) % h) {
g[c0].push_back(c1);
rev[c1].push_back(c0);
t[m++] = make_pair(c0, c1);
}
if (u[c0] == (u[c1] + 1) % h) {
g[c1].push_back(c0);
rev[c0].push_back(c1);
t[m++] = make_pair(c1, c0);
}
}
for (int i = 0; i < (n); ++i)
if (!done[i]) dfs(i, g);
reverse(srt, srt + n);
for (int i = 0; i < (n); ++i)
if (!scc[srt[i]]) {
sccNr++;
dfs(srt[i]);
}
for (int i = 0; i < (n); ++i) scc[i]--;
for (int i = 0; i < (n); ++i) sz[scc[i]]++;
for (int i = 0; i < (m); ++i)
if (scc[t[i].first] != scc[t[i].second])
g1[scc[t[i].first]].push_back(scc[t[i].second]);
int res = MR, wsk = -1;
for (int i = 0; i < (sccNr); ++i)
if (g1[i].empty() && sz[i] < res) {
res = sz[i];
wsk = i;
}
printf("%d\n", sz[wsk]);
for (int i = 0; i < (n); ++i)
if (scc[i] == wsk) printf("%d ", i + 1);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 9;
const int Mod = 1000000007;
int n, m, h;
int T[N];
vector<int> V[N];
int dfn[N], low[N], Bcnt, Dindex, stop, stap[N], instack[N], belong[N];
void tarjin(int i) {
dfn[i] = low[i] = ++Dindex;
instack[i] = 1;
stap[++stop] = i;
for (int u : V[i]) {
if (!dfn[u]) {
tarjin(u);
low[i] = min(low[u], low[i]);
} else if (instack[u]) {
low[i] = min(low[i], dfn[u]);
}
}
if (dfn[i] == low[i]) {
Bcnt++;
int j;
do {
j = stap[stop--];
instack[j] = 0;
belong[j] = Bcnt;
} while (j != i);
}
}
int out[N], sz[N];
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &T[i]);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if ((T[u] + 1) % h == T[v]) {
V[u].push_back(v);
}
if ((T[v] + 1) % h == T[u]) {
V[v].push_back(u);
}
}
for (int i = 1; i <= n; i++) {
sort(V[i].begin(), V[i].end());
V[i].resize(unique(V[i].begin(), V[i].end()) - V[i].begin());
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
tarjin(i);
}
}
for (int i = 1; i <= n; i++) {
sz[belong[i]]++;
for (int j : V[i]) {
if (belong[i] != belong[j]) {
out[belong[i]]++;
}
}
}
int res = N + N, id = 0;
for (int i = 1; i <= Bcnt; i++) {
if (out[i] == 0 && sz[i] > 0 && sz[i] <= res) res = sz[i], id = i;
}
cout << res << endl;
for (int i = 1; i <= n; i++)
if (belong[i] == id) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100010];
int visited[100010], num[100010], low[100010], A[100010], part[100010];
vector<int> st, comp[100010];
int ct = 1, comp_no = 0;
void tarjan(int s) {
num[s] = low[s] = ct++;
st.push_back(s);
visited[s] = 1;
for (int i = 0; i < graph[s].size(); i++) {
if (!num[graph[s][i]]) tarjan(graph[s][i]);
if (visited[graph[s][i]]) low[s] = min(low[s], low[graph[s][i]]);
}
if (low[s] == num[s]) {
while (1) {
int x = st.back();
comp[comp_no].push_back(st.back());
visited[st.back()] = 0;
st.pop_back();
part[x] = comp_no;
if (x == s) break;
}
comp_no++;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m, h;
cin >> n >> m >> h;
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
if ((A[a] + 1) % h == A[b]) graph[a].push_back(b);
if ((A[b] + 1) % h == A[a]) graph[b].push_back(a);
}
for (int i = 0; i < n; i++) {
if (!num[i]) tarjan(i);
}
int mini = 1000000000, ind = -1;
for (int i = 0; i < comp_no; i++) {
int mk = 0;
for (int j = 0; j < comp[i].size(); j++) {
for (int k = 0; k < graph[comp[i][j]].size(); k++) {
if (part[graph[comp[i][j]][k]] != part[comp[i][j]]) {
mk = 1;
break;
}
}
if (mk) break;
}
if (!mk) {
if (mini > comp[i].size()) {
mini = comp[i].size();
ind = i;
}
}
}
cout << mini << '\n';
for (int i = 0; i < comp[ind].size(); i++) cout << comp[ind][i] + 1 << " ";
cout << '\n';
}
|
#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, u;
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]) {
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;
const int MAXN = 100001;
int fir[MAXN], nxt[MAXN << 1], to[MAXN << 1], from[MAXN << 1], cnt;
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;
inline int read() {
int k = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
return k * f;
}
inline void add_edge(int a, int b) {
from[++cnt] = a;
to[cnt] = b;
nxt[cnt] = fir[a];
fir[a] = cnt;
}
void Tarjan(int u) {
dfn[u] = low[u] = ++tim;
S.push(u), vis[u] = true;
for (int i = fir[u]; i != -1; i = nxt[i]) {
int v = to[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() {
memset(fir, -1, sizeof(fir));
int n = read(), m = read(), h = read(), rec;
for (int i = 1; i <= n; i++) t[i] = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
if ((t[u] + 1) % h == t[v]) add_edge(u, v);
if ((t[v] + 1) % h == t[u]) add_edge(v, u);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) Tarjan(i);
for (int i = 1; i <= n; i++) {
for (int j = fir[i]; j != -1; j = nxt[j]) {
int x = to[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 read() {
int res = 0;
char c;
bool flag = true;
c = getchar();
while (!isdigit(c)) {
flag = (c != '-');
c = getchar();
}
while (isdigit(c)) {
res = res * 10 + (c ^ 48);
c = getchar();
}
return flag ? res : -res;
}
inline void write(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int Max_n = 1e5 + 5;
int bel[Max_n], dfn[Max_n], low[Max_n], siz[Max_n], c1, c2, ans, head[Max_n],
tot, st[Max_n], tp, top, in[Max_n], tim;
bool vis[Max_n];
struct node {
int nex, to;
node(int a, int b) { nex = a, to = b; }
node() {}
} edge[Max_n * 2];
inline void add_edge(int x, int y) {
edge[++tot] = node(head[x], y);
head[x] = tot;
}
void tarjan(int now) {
dfn[now] = low[now] = ++tim;
st[++tp] = now;
vis[now] = true;
for (int i = head[now]; i; i = edge[i].nex) {
int nex = edge[i].to;
if (!dfn[nex]) {
tarjan(nex);
low[now] = min(low[now], low[nex]);
} else if (vis[nex])
low[now] = min(low[now], dfn[nex]);
}
if (low[now] == dfn[now]) {
++top;
while (st[tp] != now) {
bel[st[tp]] = top;
vis[st[tp]] = false;
++siz[top];
--tp;
}
bel[st[tp]] = top;
vis[st[tp]] = false;
++siz[top];
--tp;
}
}
int main() {
int n, m, h, u[Max_n];
n = read(), m = read(), h = read();
for (int i = 1; i <= n; ++i) u[i] = read();
for (int i = 1; i <= m; ++i) {
c1 = read(), c2 = read();
if ((u[c1] + 1) % h == u[c2]) add_edge(c1, c2);
if ((u[c2] + 1) % h == u[c1]) add_edge(c2, c1);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i);
for (int now = 1; now <= n; ++now)
for (int i = head[now]; i; i = edge[i].nex) {
int nex = edge[i].to;
if (bel[now] == bel[nex]) continue;
++in[bel[now]];
}
siz[0] = Max_n;
for (int i = 1; i <= top; ++i) {
if (in[i]) continue;
if (siz[i] < siz[ans]) ans = i;
}
write(siz[ans]);
putchar('\n');
for (int i = 1; i <= n; ++i)
if (bel[i] == ans) write(i), putchar(' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int U[1111111];
vector<int> edges[1111111];
int foundat;
vector<vector<int> > scc;
vector<int> disc, low;
bool onstack[2551555];
stack<int> st;
void tarjan(int u) {
disc[u] = low[u] = foundat++;
st.push(u);
onstack[u] = true;
for (auto i : edges[u]) {
if (disc[i] == -1) {
tarjan(i);
low[u] = min(low[u], low[i]);
} else if (onstack[i])
low[u] = min(low[u], disc[i]);
}
if (disc[u] == low[u]) {
vector<int> scctem;
while (1) {
int v = st.top();
st.pop();
onstack[v] = false;
scctem.push_back(v);
if (u == v) break;
}
scc.push_back(scctem);
}
}
long long dp[1555155];
int ids[1551555];
set<int> edges_comp[1155555];
int outdegree[1555155];
long long Solve(int u) {
if (dp[u] != -1) return dp[u];
long long ret = scc[u].size();
for (int v : edges_comp[u]) {
ret += Solve(v);
}
return dp[u] = ret;
}
bool done[122222];
void dfs(int u) {
if (done[u]) return;
done[u] = true;
for (int v : edges[u]) {
if (!done[v]) dfs(v);
}
}
int main() {
int N, m, h;
cin >> N >> m >> h;
for (int i = 1; i <= N; i++) {
cin >> U[i];
onstack[i] = false;
}
for (int i = 1; i <= m; i++) {
int c1, c2;
cin >> c1 >> c2;
if ((U[c1] + 1) % h == U[c2]) edges[c1].push_back(c2);
if ((U[c2] + 1) % h == U[c1]) edges[c2].push_back(c1);
}
foundat = 1;
disc.clear();
disc.resize(N + 1, -1);
low.clear();
low.resize(N + 1);
scc.clear();
for (int i = 1; i <= N; i++) {
if (disc[i] == -1) tarjan(i);
}
for (int j = 0; j < scc.size(); j++) {
for (int y : scc[j]) {
ids[y] = j;
}
}
int numscc = scc.size();
for (int i = 0; i < numscc; i++) {
edges_comp[i].clear();
outdegree[i] = 0;
}
for (int i = 1; i <= N; i++) {
for (int j : edges[i]) {
if (ids[i] != ids[j]) {
edges_comp[ids[i]].insert(ids[j]);
outdegree[ids[i]]++;
}
}
}
long long ans = 1111111111111111ll;
int id = -1;
for (int i = 0; i < numscc; i++) {
if (outdegree[i] == 0 && ans > (long long)scc[i].size()) {
ans = scc[i].size();
id = i;
}
}
cout << ans << endl;
for (int u : scc[id]) printf("%d ", u);
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353ll;
const long long int P = 1000000007ll;
const long long int N = 100005ll;
bool cmp(long long int x, long long int y) { return x > y; }
vector<int> g[N], gg[N];
long long int c[N], cc, vis[N], a[N], p[N], cnt[N], w[N], n, m, h, tot, res;
void dfs(int x) {
vis[x] = 1;
for (auto v : g[x])
if (!vis[v]) dfs(v);
p[++tot] = x;
}
void dfss(int x) {
c[x] = cc;
cnt[cc]++;
for (auto v : gg[x])
if (!c[v]) dfss(v);
}
void solve() {
cin >> n >> m >> h;
for (long long int i = (1); i <= (n); ++i) cin >> a[i];
for (long long int i = (1); i <= (m); ++i) {
long long int x, y;
cin >> x >> y;
if ((a[x] + 1) % h == a[y]) g[x].push_back(y), gg[y].push_back(x);
if ((a[y] + 1) % h == a[x]) g[y].push_back(x), gg[x].push_back(y);
}
for (long long int i = (1); i <= (n); ++i)
if (!vis[i]) dfs(i);
for (int i = tot; i; --i)
if (!c[p[i]]) {
++cc;
dfss(p[i]);
}
for (long long int i = (1); i <= (n); ++i) {
for (auto v : g[i])
if (c[i] != c[v]) w[c[i]] = 1;
}
for (long long int i = (1); i <= (cc); ++i)
if (!w[i] && (!res | cnt[i] < cnt[res])) res = i;
cout << cnt[res] << "\n";
for (long long int i = (1); i <= (n); ++i)
if (c[i] == res) cout << i << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) {
long long z = y;
while (x % y != 0) {
z = x % y;
x = y;
y = z;
}
return z;
}
int h, u[100005], dp[100005];
vector<int> mp[100005];
set<pair<int, int> > cs;
void add(int x, int y) {
if (cs.count({x, y})) return;
cs.insert({x, y});
mp[x].push_back(y);
}
int dfn[100005], sta[100005], low[100005], color, ii, cnt, belong[100005];
bool ins[100005];
int sz[100005];
void tarjan(int x) {
dfn[x] = low[x] = ++ii;
sta[++cnt] = x;
ins[x] = 1;
for (auto child : mp[x]) {
if (!dfn[child]) {
tarjan(child);
low[x] = min(low[x], low[child]);
} else if (ins[child]) {
low[x] = min(low[x], dfn[child]);
}
}
if (dfn[x] == low[x]) {
++color;
int t;
do {
t = sta[cnt];
cnt--;
ins[t] = 0;
belong[t] = color;
sz[color]++;
} while (dfn[t] != low[t]);
}
}
bool del[100005];
void fmain(int ID) {
scanf("%d%d%d", &n, &m, &h);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%d", u + i);
}
for (int(i) = 1; (i) <= (int)(m); (i)++) {
int x, y;
scanf("%d%d", &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) = 1; (i) <= (int)(n); (i)++)
if (belong[i] == 0) tarjan(i);
for (auto p : cs) {
int x = belong[p.first], y = belong[p.second];
if (x == y) continue;
del[x] = 1;
}
int ans = -1;
for (int(i) = 1; (i) <= (int)(color); (i)++)
if (!del[i]) {
if (ans == -1 || sz[ans] > sz[i]) ans = i;
}
printf("%d\n", sz[ans]);
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (belong[i] == ans) printf("%d ", i);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 5;
vector<int> mp[MAX_N], sons[MAX_N];
stack<int> stk;
int low[MAX_N], belong[MAX_N], dfn[MAX_N];
bool vis[MAX_N];
int cnt, dfs_index;
int pre[MAX_N], judge[MAX_N], t[MAX_N];
void tarjan(int x, int dad) {
pre[x] = dad, dfs_index++;
dfn[x] = low[x] = dfs_index;
vis[x] = true;
stk.push(x);
for (auto y : mp[x]) {
if (dfn[y] == 0) {
tarjan(y, x);
low[x] = min(low[x], low[y]);
} else if (vis[y]) {
low[x] = min(low[x], dfn[y]);
}
}
if (dfn[x] == low[x]) {
int y;
cnt++;
do {
y = stk.top();
stk.pop();
vis[y] = false;
belong[y] = cnt;
sons[cnt].push_back(y);
} while (x != y);
}
}
void solve(int n) {
memset(dfn, 0, sizeof(dfn)), memset(vis, 0, sizeof(vis));
cnt = dfs_index = 0;
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, 0);
}
int main() {
int n, m, h, ans, x, y, num;
ans = 0, num = n;
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", &x, &y);
if (t[x] == (t[y] + 1) % h) mp[y].push_back(x);
if (t[y] == (t[x] + 1) % h) mp[x].push_back(y);
}
solve(n);
for (int i = 1; i <= n; i++) {
for (auto x : mp[i]) {
if (belong[i] != belong[x]) {
judge[belong[i]] = true;
}
}
}
for (int i = 1; i <= cnt; i++) {
if (!judge[i]) {
if (sons[i].size() <= num) {
num = sons[i].size();
ans = i;
}
}
}
printf("%d\n", num);
for (int i = 0; i < sons[ans].size(); i++) {
printf("%d%c", sons[ans][i], i == num - 1 ? '\n' : ' ');
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int inf = (int)1e9 + 5;
const long long INF = (long long)1e18 + 5;
long long n, N;
vector<vector<long long>> a, ar, g, components;
vector<long long> order, comp;
vector<bool> vis;
void dfs(long long v) {
vis[v] = true;
for (auto to : a[v])
if (!vis[to]) dfs(to);
order.push_back(v);
}
void dfs2(long long v) {
vis[v] = true;
for (auto to : ar[v])
if (!vis[to]) dfs2(to);
comp.push_back(v);
}
void dfs3(long long v) {
vis[v] = true;
for (auto to : g[v])
if (!vis[to]) dfs3(to);
order.push_back(v);
}
void init() {
a.resize(n);
ar.resize(n);
vis.assign(n, false);
}
void solve() {
long long m, h;
cin >> n >> m >> h;
init();
vector<long long> times(n);
for (long long i = 0; i < n; i++) cin >> times[i];
long long x, y;
for (long long i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
if ((times[x] + 1) % h == times[y]) {
a[x].push_back(y);
ar[y].push_back(x);
}
if ((times[y] + 1) % h == times[x]) {
a[y].push_back(x);
ar[x].push_back(y);
}
}
for (long long i = 0; i < n; i++)
if (!vis[i]) dfs(i);
reverse(order.begin(), order.end());
(void)0;
fill(vis.begin(), vis.end(), false);
vector<long long> comp_id(n);
for (long long i = 0; i < n; i++) {
x = order[i];
if (vis[x]) continue;
comp.clear();
dfs2(x);
for (auto v : comp) comp_id[v] = components.size();
components.push_back(comp);
}
(void)0;
N = components.size();
g.resize(N);
for (long long i = 0; i < n; i++) {
for (auto j : a[i]) {
long long v = comp_id[i], to = comp_id[j];
if (v == to) continue;
g[v].push_back(to);
}
}
long long best_ind = -1;
vis.assign(N, false);
for (long long i = 0; i < N; i++) {
if (vis[i]) continue;
order.clear();
dfs3(i);
for (auto cur_ind : order) {
if (g[cur_ind].size() != 0) continue;
if (best_ind == -1 ||
components[cur_ind].size() < components[best_ind].size())
best_ind = cur_ind;
}
}
cout << components[best_ind].size() << endl;
for (auto e : components[best_ind]) cout << e + 1 << " ";
}
int main() {
string filename = "acm";
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(15);
solve();
(void)0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h, a[200009], b[200009], t[100009], cmp[100009], num[100009], cnts;
bool used[100009];
vector<int> x[100009], y[100009], z[100009], G;
void dfs(int pos) {
if (used[pos] == true) return;
used[pos] = true;
for (int i = 0; i < x[pos].size(); i++) dfs(x[pos][i]);
G.push_back(pos);
}
void rdfs(int pos) {
if (cmp[pos] >= 1) return;
cmp[pos] = cnts;
num[cnts]++;
for (int i = 0; i < y[pos].size(); i++) rdfs(y[pos][i]);
}
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> t[i];
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i];
if (t[a[i]] == (t[b[i]] + h - 1) % h) {
x[a[i]].push_back(b[i]);
y[b[i]].push_back(a[i]);
}
if (t[b[i]] == (t[a[i]] + h - 1) % h) {
x[b[i]].push_back(a[i]);
y[a[i]].push_back(b[i]);
}
}
for (int i = 1; i <= n; i++) {
if (used[i] == true) continue;
dfs(i);
}
reverse(G.begin(), G.end());
for (int i = 0; i < G.size(); i++) {
if (cmp[G[i]] >= 1) continue;
cnts++;
rdfs(G[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < x[i].size(); j++) {
if (cmp[i] == cmp[x[i][j]]) continue;
z[cmp[i]].push_back(cmp[x[i][j]]);
}
}
int minx = (1 << 30), minid = 0;
for (int i = 1; i <= cnts; i++) {
if (minx > num[i] && z[i].size() == 0) {
minx = num[i];
minid = i;
}
}
cout << minx << endl;
vector<int> Y;
for (int i = 1; i <= n; i++) {
if (cmp[i] == minid) Y.push_back(i);
}
for (int i = 0; i < Y.size(); i++) {
if (i) cout << " ";
cout << Y[i];
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, m, h, u[MAXN];
vector<int> G[MAXN];
vector<int> G2[MAXN];
namespace SCC {
stack<int> S;
vector<int> SCC[MAXN];
int cnt, tot;
int dfn[MAXN], low[MAXN], fa[MAXN];
bool vis[MAXN], instack[MAXN];
void addEdge(int x, int y) { G[x].push_back(y); }
void tarjan(int cur) {
S.push(cur);
dfn[cur] = low[cur] = ++cnt;
vis[cur] = instack[cur] = 1;
for (int i = 0; i < G[cur].size(); i++) {
int nx = G[cur][i];
if (!vis[nx]) {
tarjan(nx);
low[cur] = min(low[cur], low[nx]);
} else if (instack[nx]) {
low[cur] = min(low[cur], dfn[nx]);
}
}
if (dfn[cur] == low[cur]) {
tot++;
int tp;
do {
tp = S.top();
S.pop();
instack[tp] = 0;
fa[tp] = tot;
SCC[tot].push_back(tp);
} while (tp != cur);
}
}
void getNewGraph() {
for (int i = 1; i <= n; i++) {
if (!vis[i]) tarjan(i);
}
for (int i = 1; i <= n; i++) {
int x = i;
for (int j = 0; j < G[i].size(); j++) {
int y = G[i][j];
if (fa[x] != fa[y]) {
G2[fa[x]].push_back(fa[y]);
}
}
}
}
} // namespace SCC
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++) {
int x, y;
scanf("%d %d", &x, &y);
if ((u[x] + 1) % h == u[y]) {
SCC::addEdge(x, y);
}
if ((u[y] + 1) % h == u[x]) {
SCC::addEdge(y, x);
}
}
SCC::getNewGraph();
int ans = n + 1;
int id = -1;
for (int i = 1; i <= SCC::tot; i++) {
if (G2[i].empty()) {
if ((int)SCC::SCC[i].size() < ans) {
ans = (int)SCC::SCC[i].size();
id = i;
}
}
}
printf("%d\n", ans);
sort(SCC::SCC[id].begin(), SCC::SCC[id].end());
for (int i = 0; i < SCC::SCC[id].size(); i++) {
if (i) putchar(' ');
printf("%d", SCC::SCC[id][i]);
}
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, h;
const int N = 1e5 + 10;
int A[N];
int ans[N];
int k;
int Low[N], DFN[N], Stack[N], Belong[N];
int Index, top;
int scc;
bool Instack[N];
int num[N];
int outdegree[N];
vector<int> G[N];
void init() {
for (int i = 1; i <= n; i++) G[i].clear();
memset(outdegree, 0, sizeof(outdegree));
}
void Tanjan(int u) {
int v;
Low[u] = DFN[u] = ++Index;
Stack[top++] = u;
Instack[u] = true;
for (int i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (!DFN[v]) {
Tanjan(v);
if (Low[u] > Low[v]) Low[u] = Low[v];
} else if (Instack[v] && Low[u] > DFN[v])
Low[u] = DFN[v];
}
if (Low[u] == DFN[u]) {
scc++;
do {
v = Stack[--top];
Instack[v] = false;
Belong[v] = scc;
num[scc]++;
} while (v != u);
}
}
void solve(int n) {
memset(DFN, 0, sizeof(DFN));
memset(Instack, 0, sizeof(Instack));
memset(num, 0, sizeof(num));
Index = scc = top = 0;
for (int i = 1; i <= n; i++)
if (!DFN[i]) Tanjan(i);
}
int main() {
while (cin >> n >> m >> h) {
init();
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
int aa, bb;
aa = A[a];
bb = A[b];
if ((aa - bb) == 1) {
G[b].push_back(a);
} else if ((bb - aa) == 1) {
G[a].push_back(b);
}
if ((aa - bb) == (h - 1)) {
G[a].push_back(b);
} else if ((bb - aa) == (h - 1)) {
G[b].push_back(a);
}
}
solve(n);
for (int u = 1; u <= n; u++) {
int v;
int uu, vv;
uu = Belong[u];
for (int j = 0; j < G[u].size(); j++) {
v = G[u][j];
vv = Belong[v];
if (uu != vv) {
outdegree[uu]++;
}
}
}
int k, cnt;
cnt = n + 1;
for (int i = 1; i <= scc; i++) {
if (outdegree[i] == 0 && num[i] < cnt) {
cnt = num[i];
k = i;
}
}
int tt = 0;
for (int i = 1; i <= n; i++)
if (Belong[i] == k) ans[tt++] = i;
cout << cnt << endl;
for (int i = 0; i < tt; i++) cout << ans[i] << (i == tt - 1 ? "\n" : " ");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100005;
int n;
vector<int> g[MAX_N];
int siz[MAX_N];
namespace Tarjan {
int n, m, H;
int A[MAX_N];
stack<int> stc;
int dfn[MAX_N], low[MAX_N];
bool vis[MAX_N], in_stack[MAX_N];
int Index;
int com[MAX_N];
int tot;
vector<int> g[MAX_N];
void tarjan(int u) {
dfn[u] = low[u] = ++Index;
vis[u] = true;
stc.push(u);
in_stack[u] = true;
int v;
for (int i = 0; i < (int)g[u].size(); i++) {
v = g[u][i];
if (!vis[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (in_stack[v]) {
low[u] = min(low[u], dfn[v]);
}
}
if (dfn[u] == low[u]) {
tot++;
do {
v = stc.top();
stc.pop();
in_stack[v] = false;
com[v] = tot;
} while (u != v);
}
}
void init() {
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 ((A[u] + 1) % H == A[v]) {
g[u].push_back(v);
}
if ((A[v] + 1) % H == A[u]) {
g[v].push_back(u);
}
}
}
void get_new_graph(int &nn, vector<int> ng[]) {
for (int i = 1; i <= n; i++)
if (!vis[i]) tarjan(i);
nn = tot;
for (int i = 1; i <= n; i++) {
siz[com[i]]++;
for (int j = 0; j < (int)g[i].size(); j++) {
int u = i, v = g[i][j];
if (com[u] != com[v]) {
ng[com[u]].push_back(com[v]);
}
}
}
}
void print(int color) {
for (int i = 1; i <= n; i++)
if (com[i] == color) cout << i << ' ';
cout << endl;
}
} // namespace Tarjan
int main() {
Tarjan::init();
Tarjan::get_new_graph(n, g);
int cnt = 0;
for (int i = 1; i <= n; i++)
if (g[i].empty()) cnt++;
int mi = 1e9, pos = 0;
for (int i = 1; i <= n; i++) {
if (g[i].empty()) {
if (mi > siz[i]) {
mi = siz[i];
pos = i;
}
}
}
cout << mi << endl;
Tarjan::print(pos);
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 {
int time;
int ncomp;
vector<int> disc, low, comp;
vector<bool> on;
stack<int> s;
template <class G>
int dfs(int v, G &g) {
disc[v] = low[v] = ++time;
s.push(v);
for (auto &(u) : (g[v]))
if (comp[u] == -1) low[v] = min(low[v], (low[u]) ?: dfs(u, g));
if (disc[v] == low[v]) {
int u;
do {
u = s.top();
s.pop();
comp[u] = ncomp;
} while (v != u);
ncomp++;
}
return low[v];
}
template <class G>
vector<int> scc(G &g) {
int n = (int)(g).size();
time = 0, ncomp = 0;
disc.assign(n, 0);
low.assign(n, 0);
on.assign(n, 0);
comp.assign(n, -1);
for (int i = 0; i < n; i++) {
if (comp[i] == -1) {
dfs(i, g);
}
}
return 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;
const double eps = 1e-7;
const long double PI = acos(0.0) * 2.0;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
vector<int> G[maxn];
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++;
for (;;) {
int x = S.top();
S.pop();
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 = 0; i < n; i++)
if (!pre[i]) dfs(i);
}
int n, m, h;
int u[maxn];
int c[maxn][2];
inline void add(int u, int v) { G[u].push_back(v); }
vector<int> sc[maxn];
int in[maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> h;
for (int t = (1); t < (n + 1); ++t) cin >> u[t];
for (int t = (1); t < (m + 1); ++t) {
for (int e = (0); e < (2); ++e) cin >> c[t][e];
for (int e = (0); e < (2); ++e) {
if ((u[c[t][e]] + 1) % h == u[c[t][e ^ 1]])
add(c[t][e] - 1, c[t][e ^ 1] - 1);
}
}
find_scc(n);
for (int t = (0); t < (n); ++t) {
sc[sccno[t]].push_back(t);
}
for (int t = (1); t < (m + 1); ++t) {
for (int e = (0); e < (2); ++e) {
if (sccno[c[t][e] - 1] == sccno[c[t][e ^ 1] - 1]) continue;
if ((u[c[t][e]] + 1) % h == u[c[t][e ^ 1]]) ++in[sccno[c[t][e] - 1]];
}
}
long long ans = 1e8;
int y;
for (int i = 1; i <= scc_cnt; ++i) {
if (!in[i]) {
if (ans > sc[i].size()) {
ans = sc[i].size();
y = i;
}
}
}
cout << ans << "\n";
for (auto e : sc[y]) cout << e + 1 << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 200005;
const int mod = (int)1e9 + 7;
const int inf = (int)1e9;
const int N = 200005;
vector<int> adj[N];
int t[N], mini[N], counter, id[N], scc;
vector<int> s;
vector<int> sol[maxN];
bool valid[maxN];
void dfs(int u) {
t[u] = mini[u] = ++counter;
s.push_back(u);
for (int j = 0; j < adj[u].size(); ++j) {
int where = adj[u][j];
if (t[where] == 0) dfs(where);
if (t[where] != -1) mini[u] = min(mini[u], mini[where]);
}
if (mini[u] == t[u]) {
int v;
do {
v = s.back();
t[v] = -1;
s.pop_back();
id[v] = scc;
sol[scc].push_back(v);
} while (v != u);
scc++;
}
}
vector<int> G[maxN];
set<int> datas[maxN];
int out[maxN];
bool used[maxN];
int main() {
int n, m, h;
scanf("%d %d %d", &n, &m, &h);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
datas[x].insert(i);
}
while (m--) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
G[x].push_back(y);
G[y].push_back(x);
}
memset(valid, true, sizeof valid);
for (int i = 0; i < h; ++i) {
if (datas[i].size() == 0) {
valid[i] = false;
continue;
}
int to = (i + 1) % h;
for (auto elem : datas[i]) {
for (int nei : G[elem]) {
if (datas[to].find(nei) != datas[to].end()) {
adj[elem].push_back(nei);
}
}
}
}
for (int i = 0; i < n; ++i) {
if (t[i] == 0) {
dfs(i);
}
}
int who = -1;
for (int i = 0; i < n; ++i) {
if (used[id[i]]) {
continue;
}
used[id[i]] = true;
bool ok = true;
for (int vertex : sol[id[i]]) {
for (int nei : adj[vertex]) {
if (id[nei] != id[i]) {
ok = false;
}
}
}
if (ok && (who == -1 || sol[id[i]].size() < sol[who].size())) {
who = id[i];
}
}
cout << sol[who].size() << endl;
for (int e : sol[who]) {
printf("%d ", e + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m, h;
cin >> n >> m >> h;
vector<int> mh(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> mh[i];
}
auto conf = [&](int a, int b) {
return mh[b] == mh[a] + 1 || mh[a] == h - 1 && mh[b] == 0;
};
vector<vector<int>> edges(n + 1);
vector<vector<int>> rdges(n + 1);
for (int i = 0; i < m; ++i) {
int c, d;
cin >> c >> d;
if (conf(c, d)) {
edges[d].push_back(c);
rdges[c].push_back(d);
}
if (conf(d, c)) {
edges[c].push_back(d);
rdges[d].push_back(c);
}
}
int cur = 0;
vector<int> post(n + 1);
vector<bool> vis(n + 1);
vector<int> scc;
function<void(int)> dfs = [&](int v) {
vis[v] = true;
scc.push_back(v);
for (auto i : edges[v]) {
if (!vis[i]) {
dfs(i);
}
}
post[v] = ++cur;
};
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
dfs(i);
}
}
auto cmp = [&](int a, int b) { return post[a] > post[b]; };
vector<int> possibleSinks(n);
iota(possibleSinks.begin(), possibleSinks.end(), 1);
sort(possibleSinks.begin(), possibleSinks.end(), cmp);
fill(vis.begin(), vis.end(), false);
vector<int> sinks;
for (int i : possibleSinks) {
if (!vis[i]) {
sinks.push_back(i);
dfs(i);
}
}
swap(edges, rdges);
fill(vis.begin(), vis.end(), false);
vector<int> ans(n + 1);
for (int i : sinks) {
scc.clear();
dfs(i);
if (scc.size() < ans.size()) {
ans = scc;
}
}
cout << ans.size() << endl;
for (int i : ans) {
cout << i << ' ';
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, m, h, u[maxn];
int tot, fro[2 * maxn], go[2 * maxn], nxt[2 * maxn], f1[maxn];
void ins(int x, int y) {
fro[++tot] = x;
go[tot] = y;
nxt[tot] = f1[x];
f1[x] = tot;
}
int sum, dfn[maxn], low[maxn], z[maxn], z0, bz[maxn], rt[maxn], num[maxn];
void tarjan(int k) {
dfn[k] = low[k] = ++sum;
bz[k] = 1;
z[++z0] = k;
for (int p = f1[k]; p; p = nxt[p])
if (!bz[go[p]]) {
tarjan(go[p]);
low[k] = min(low[k], low[go[p]]);
} else if (bz[go[p]] == 1)
low[k] = min(low[k], dfn[go[p]]);
if (dfn[k] == low[k]) {
do {
bz[z[z0]] = 2;
rt[z[z0]] = k;
num[k]++;
} while (z[z0--] != k);
}
}
int cd[maxn];
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++) {
int x, y;
scanf("%d %d", &x, &y);
if ((u[x] + 1) % h == u[y]) ins(x, y);
if ((u[y] + 1) % h == u[x]) ins(y, x);
}
for (int i = 1; i <= n; i++)
if (!bz[i]) tarjan(i);
for (int p = 1; p <= tot; p++)
if (rt[fro[p]] != rt[go[p]]) cd[rt[fro[p]]]++;
int ans = n + 1, wz = 0;
for (int i = 1; i <= n; i++)
if (rt[i] == i && !cd[i] && num[i] < ans) ans = num[i], wz = i;
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (rt[i] == wz) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100005];
vector<int> v[100005];
vector<int> g[100005];
vector<int> z[100005];
stack<int> s;
bool vi[100005];
int p[100005];
void dfs(int i) {
vi[i] = 1;
for (int j = 0; j < v[i].size(); j++)
if (!vi[v[i][j]]) dfs(v[i][j]);
s.push(i);
}
void dfs2(int i, int x) {
p[i] = x;
z[x].push_back(i);
for (int j = 0; j < g[i].size(); j++)
if (p[g[i][j]] == 0) dfs2(g[i][j], x);
}
int main() {
ios::sync_with_stdio(false);
int n, x, y, m, h;
cin >> n >> m >> h;
for (int i = 0; i < n; i++) cin >> a[1 + i];
while (m--) {
cin >> x >> y;
if (a[x] == (a[y] + 1) % h) {
v[y].push_back(x);
g[x].push_back(y);
}
if (a[y] == (a[x] + 1) % h) {
v[x].push_back(y);
g[y].push_back(x);
}
}
for (int i = 1; i <= n; i++)
if (vi[i] == 0) {
dfs(i);
}
y = n;
int an = 1;
while (!s.empty()) {
x = s.top();
s.pop();
if (p[x] == 0) {
dfs2(x, x);
bool b = 1;
for (int i = 0; i < z[x].size(); i++)
for (int j = 0; j < v[z[x][i]].size(); j++)
if (p[v[z[x][i]][j]] != x) {
b = 0;
break;
}
if (b && y >= z[x].size()) {
y = z[x].size();
an = x;
}
}
}
cout << y << endl;
for (int i = 0; i < z[an].size(); i++) cout << z[an][i] << ' ';
cout << endl;
;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
struct edge {
int la, b;
} con[N];
int tot, fir[N];
void add(int from, int to) {
con[++tot] = (edge){fir[from], to};
fir[from] = tot;
}
int dfn[N], sta[N], top, low[N], deg[N], col[N], n, cnt, m, h, tms[N];
vector<int> gro[N];
void dfs(int pos) {
dfn[pos] = low[pos] = ++top;
sta[top] = pos;
for (int i = fir[pos]; i; i = con[i].la) {
if (!dfn[con[i].b]) {
dfs(con[i].b);
low[pos] = min(low[pos], low[con[i].b]);
} else if (!col[con[i].b])
low[pos] = min(low[pos], low[con[i].b]);
}
if (low[pos] == dfn[pos]) {
cnt++;
while (top >= dfn[pos]) {
gro[cnt].push_back(sta[top]);
col[sta[top--]] = cnt;
}
}
}
int main() {
int a, b, ans;
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; ++i) scanf("%d", &tms[i]);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
if ((tms[a] + 1) % h == tms[b]) add(a, b);
if (tms[a] == (tms[b] + 1) % h) add(b, a);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) dfs(i);
for (int pos = 1; pos <= n; ++pos)
for (int i = fir[pos]; i; i = con[i].la)
if (col[con[i].b] != col[pos]) deg[col[pos]]++;
ans = 1;
for (int i = 2; i <= cnt; ++i)
if (!deg[i]) {
if (gro[i].size() < gro[ans].size()) ans = i;
}
printf("%d\n", gro[ans].size());
for (int i = 0; i < (int)gro[ans].size(); ++i) printf("%d ", gro[ans][i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
sum = (sum << 1) + (sum << 3) + (c ^ 48);
c = getchar();
}
return sum;
}
int const maxn = 100005;
int n, m, h, cnt, num, top, col, H[maxn], a[maxn], dfn[maxn], low[maxn],
size[maxn], co[maxn], s[maxn], f[maxn], ru[maxn];
queue<int> q;
struct Edge {
int next, to;
} E[maxn << 1];
struct edge {
int from, to;
} E2[maxn << 1];
inline void add(int a, int b) {
E[++cnt] = (Edge){H[a], b};
E2[cnt] = (edge){a, b};
H[a] = cnt;
}
void tarjan(int x) {
dfn[x] = low[x] = ++num;
s[++top] = x;
for (int i = H[x]; i; i = E[i].next) {
int y = E[i].to;
if (!dfn[y]) {
tarjan(y);
low[x] = min(low[x], low[y]);
} else if (!co[y])
low[x] = min(low[x], dfn[y]);
}
if (low[x] == dfn[x]) {
co[x] = ++col;
size[col] = 1;
while (s[top] != x) {
co[s[top]] = col;
size[col]++;
top--;
}
top--;
}
}
inline bool cmp(edge x, edge y) {
if (x.from == y.from) return x.to < y.to;
return x.from < y.from;
}
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]) add(x, y);
if ((a[y] + 1) % h == a[x]) add(y, x);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
int edge_num = cnt;
memset(H, 0, sizeof(H));
cnt = 0;
for (int i = 1; i <= edge_num; i++)
E2[i].from = co[E2[i].from], E2[i].to = co[E2[i].to];
sort(E2 + 1, E2 + edge_num + 1, cmp);
for (int i = 1; i <= edge_num; i++)
if (E2[i].from != E2[i].to &&
(E2[i].from != E2[i - 1].from || E2[i].to != E2[i - 1].to))
add(E2[i].to, E2[i].from), ru[E2[i].from]++;
for (int i = 1; i <= col; i++) {
if (ru[i] == 0) q.push(i);
f[i] = size[i];
}
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = H[x]; i; i = E[i].next) {
int y = E[i].to;
f[y] += f[x];
ru[y]--;
if (ru[y] == 0) q.push(y);
}
}
int ans = 0x3f3f3f3f, ansnum = 0;
for (int i = 1; i <= col; i++)
if (f[i] < ans) ans = f[i], ansnum = i;
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (co[i] == ansnum) printf("%d ", i);
putchar('\n');
}
|
#include <bits/stdc++.h>
using namespace std;
struct SCC {
int V, group_cnt;
vector<vector<int> > adj, radj;
vector<int> group_num, vis;
stack<int> stk;
SCC(int V) : V(V), group_cnt(0), group_num(V), vis(V), adj(V), radj(V) {}
void add_edge(int v1, int v2) {
adj[v1].push_back(v2);
radj[v2].push_back(v1);
}
void fill_forward(int x) {
vis[x] = true;
for (int i = 0; i < adj[x].size(); i++) {
if (!vis[adj[x][i]]) {
fill_forward(adj[x][i]);
}
}
stk.push(x);
}
void fill_backward(int x) {
vis[x] = false;
group_num[x] = group_cnt;
for (int i = 0; i < radj[x].size(); i++) {
if (vis[radj[x][i]]) {
fill_backward(radj[x][i]);
}
}
}
int get_scc() {
for (int i = 0; i < V; i++) {
if (!vis[i]) fill_forward(i);
}
group_cnt = 0;
while (!stk.empty()) {
if (vis[stk.top()]) {
fill_backward(stk.top());
group_cnt++;
}
stk.pop();
}
return group_cnt;
}
};
const int max_N = 1e5 + 10;
set<int> E[max_N];
int u[max_N];
vector<int> comp[max_N];
bool outgoing[max_N];
int solve(int x);
int main() {
do {
ios_base::sync_with_stdio(false);
cin.tie(0);
} while (0);
int N, M, H;
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;
if ((u[c1] + 1) % H == u[c2]) {
E[c1].insert(c2);
}
if ((u[c2] + 1) % H == u[c1]) {
E[c2].insert(c1);
}
}
SCC scc(N);
for (int u = 1; u <= N; ++u) {
for (auto& v : E[u]) {
scc.add_edge(u - 1, v - 1);
}
}
int n = scc.get_scc();
for (int u = 1; u <= N; ++u) {
int id = scc.group_num[u - 1];
comp[id].push_back(u);
;
}
for (int u = 1; u <= N; ++u) {
for (auto& v : E[u]) {
int idu = scc.group_num[u - 1];
int idv = scc.group_num[v - 1];
if (idu != idv) {
outgoing[idu] = true;
}
}
}
int best = -1;
for (int u = 0; u < n; ++u) {
if (!outgoing[u] && (best == -1 || comp[u].size() < comp[best].size())) {
best = u;
}
}
assert(best != -1);
cout << comp[best].size() << endl;
for (auto& x : comp[best]) {
cout << x << ' ';
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 100010;
int n, m, h, tot, num, cnt, top;
int c[M], head[M], dfn[M], low[M], a[M], vis[M], siz[M];
int color[M * 2], flg, minn, du[M * 2];
struct Edge {
int y, nxt;
} side[M * 2];
void add(int x, int y) {
side[++tot].nxt = head[x];
side[tot].y = y;
head[x] = tot;
}
void tarjan(int x) {
dfn[x] = low[x] = ++cnt;
a[++top] = x;
vis[x] = 1;
for (int i = head[x]; i; i = side[i].nxt) {
int y = side[i].y;
if (!dfn[y])
tarjan(y), low[x] = min(low[x], low[y]);
else if (vis[y])
low[x] = min(low[x], dfn[y]);
}
if (dfn[x] == low[x]) {
num++;
int y;
do {
y = a[top--];
vis[y] = 0;
color[y] = num;
siz[num]++;
} while (x != y);
}
}
int main() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &c[i]);
for (int i = 1, xx, yy; i <= m; i++) {
scanf("%d%d", &xx, &yy);
if ((c[xx] + 1) % h == c[yy]) add(xx, yy);
if ((c[yy] + 1) % h == c[xx]) add(yy, xx);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= n; i++)
for (int j = head[i]; j; j = side[j].nxt) {
int y = side[j].y;
if (color[i] != color[y]) du[color[i]]++;
}
minn = 646584864;
for (int i = 1; i <= num; i++)
if (!du[i] && siz[i] < minn) {
minn = siz[i];
flg = i;
}
printf("%d\n", minn);
for (int i = 1; i <= n; i++)
if (color[i] == flg) cout << i << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
int inStack[100001];
int low[100001];
int disc[100001];
int SCC_ID[100001];
int out[100001];
vector<int> G[100001];
void dfs(int c, stack<int>& S, vector<vector<int>>& SCC) {
static int tm = 1;
disc[c] = low[c] = tm++;
S.push(c);
inStack[c] = 1;
for (auto& u : G[c])
if (disc[u] == 0) {
dfs(u, S, SCC);
low[c] = min(low[c], low[u]);
} else if (inStack[u])
low[c] = min(low[c], disc[u]);
if (low[c] == disc[c]) {
vector<int> comp;
inStack[c] = 0;
comp.push_back(c);
while (S.top() != c) {
comp.push_back(S.top());
inStack[S.top()] = 0;
S.pop();
}
S.pop();
SCC.push_back(comp);
}
}
int main() {
ios::sync_with_stdio(0);
int n, m, h;
cin >> n >> m >> h;
vector<int> A(n + 1);
for (int i = 1; i <= n; i++) cin >> A[i];
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
int tm1 = A[u];
int tm2 = A[v];
if ((tm1 + 1) % h == tm2) G[u].push_back(v);
if ((tm2 + 1) % h == tm1) G[v].push_back(u);
}
vector<vector<int>> SCC;
stack<int> S;
for (int i = 1; i <= n; i++)
if (disc[i] == 0) dfs(i, S, SCC);
for (int i = 0; i < SCC.size(); i++)
for (int j = 0; j < SCC[i].size(); j++) SCC_ID[SCC[i][j]] = i + 1;
for (int i = 1; i <= n; i++)
for (auto& u : G[i])
if (SCC_ID[i] != SCC_ID[u]) out[SCC_ID[i]]++;
int ats = -1;
for (int i = 0; i < SCC.size(); i++)
if (out[i + 1] == 0 && (ats == -1 || SCC[ats].size() > SCC[i].size()))
ats = i;
cout << SCC[ats].size() << "\n";
for (auto& u : SCC[ats]) cout << u << " ";
}
|
#include <bits/stdc++.h>
using std::min;
const int maxn = 100005;
int n, m, h;
int t[maxn];
struct asd {
int a, b;
} q[maxn];
int up(int x) {
x++;
if (x == h)
return 0;
else
return x;
}
struct qwe {
int next, to;
} edge[maxn * 4];
int etot = 0;
int node[maxn * 2];
void add(int x, int y) {
edge[++etot].next = node[x];
edge[etot].to = y;
node[x] = etot;
}
int siz[maxn];
int belong[maxn];
bool use[maxn];
int tot = 0, cnt = 0;
int dfn[maxn], low[maxn];
std::stack<int> sk;
void tarjan(int s) {
tot++;
dfn[s] = low[s] = tot;
use[s] = true;
sk.push(s);
for (int i = node[s]; i; i = edge[i].next) {
int too = edge[i].to;
if (!dfn[too]) {
tarjan(too);
low[s] = min(low[s], low[too]);
} else if (use[too])
low[s] = min(low[s], dfn[too]);
}
if (low[s] == dfn[s]) {
belong[s] = ++cnt;
siz[cnt] = 1;
use[s] = false;
while (!sk.empty() && sk.top() != s) {
belong[sk.top()] = cnt;
siz[cnt]++;
use[sk.top()] = false;
sk.pop();
}
sk.pop();
}
}
int nowval = 100000007;
;
int nowlc = 0;
int du[maxn];
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", &q[i].a, &q[i].b);
int tp = up(t[q[i].a]);
if (tp == t[q[i].b]) add(q[i].a, q[i].b);
tp = up(t[q[i].b]);
if (tp == t[q[i].a]) add(q[i].b, q[i].a);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i);
}
for (int k = 1; k <= n; k++)
for (int i = node[k]; i; i = edge[i].next)
if (belong[k] != belong[edge[i].to]) du[belong[k]]++;
for (int i = 1; i <= cnt; i++)
if (!du[i])
if (siz[i] < nowval) nowlc = i, nowval = siz[i];
printf("%d\n", siz[nowlc]);
for (int i = 1; i <= n; i++)
if (belong[i] == nowlc) printf("%d ", 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;
namespace SCC {
struct State {
State(int n) : disc(n, 0), low(n, 0), comp(n, -1), time(0), ncomp(0) {}
int time;
int ncomp;
vector<int> disc, low, comp;
stack<int> pool;
};
template <class G>
int dfs(const G &g, State &s, int v) {
s.disc[v] = 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 (s.disc[v] == 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();
State s = State(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;
const int N = 2e5 + 5;
int u[N];
int c[N][2];
int n, m, h;
int dp[N];
vector<vector<int> > SCCs;
vector<int> compIndex, ind, lowLink;
stack<int> st;
vector<bool> inst;
vector<vector<int> > adj;
int idx = 0;
void tarjanSCC(int i) {
lowLink[i] = ind[i] = idx++;
st.push(i);
inst[i] = true;
for (int j = 0; j < adj[i].size(); j++) {
int k = adj[i][j];
if (ind[k] == -1) {
tarjanSCC(k);
lowLink[i] = min(lowLink[i], lowLink[k]);
} else if (inst[k]) {
lowLink[i] = min(lowLink[i], lowLink[k]);
}
}
if (lowLink[i] == ind[i]) {
vector<int> comp;
int n = -1;
while (n != i) {
n = st.top();
st.pop();
comp.push_back(n);
inst[n] = 0;
compIndex[n] = SCCs.size();
}
SCCs.push_back(comp);
}
}
void SCC() {
SCCs.clear();
compIndex.resize(adj.size());
ind.clear();
ind.resize(adj.size(), -1);
lowLink.resize(adj.size());
inst.resize(adj.size());
idx = 0;
for (int i = int(1); i <= int(n); i++)
if (ind[i] == -1) tarjanSCC(i);
}
int cntSrc, cntSnk;
vector<vector<int> > cmpAdj;
vector<int> inDeg, outDeg;
void computeNewGraph() {
outDeg.clear();
outDeg.resize(SCCs.size());
inDeg.clear();
inDeg.resize(SCCs.size());
cntSrc = cntSnk = SCCs.size();
cmpAdj.clear();
cmpAdj.resize(SCCs.size());
for (int i = int(1); i <= int(n); i++) {
for (int k : adj[i]) {
if (compIndex[k] != compIndex[i]) {
cmpAdj[compIndex[i]].push_back(compIndex[k]);
if (!(inDeg[compIndex[k]]++)) cntSrc--;
if (!(outDeg[compIndex[i]]++)) cntSnk--;
}
}
}
}
bool check(int a, int b) {
a = u[a], b = u[b];
return min(a, b) + 1 == max(a, b) || max(a, b) == h - 1 && min(a, b) == 0;
}
void add(int a, int b) {
if (u[a] + 1 == u[b] || u[a] == h - 1 && u[b] == 0) adj[a].push_back(b);
swap(a, b);
if (u[a] + 1 == u[b] || u[a] == h - 1 && u[b] == 0) adj[a].push_back(b);
}
int main() {
scanf("%d %d %d", &n, &m, &h);
adj.resize(n + 1);
for (int i = int(1); i <= int(n); i++) scanf("%d", &u[i]);
for (int i = int(1); i <= int(m); i++) scanf("%d %d", &c[i][0], &c[i][1]);
for (int i = int(1); i <= int(m); i++) {
if (check(c[i][0], c[i][1])) {
add(c[i][0], c[i][1]);
}
}
for (int i = int(1); i <= int(n); i++) {
if (!int(adj[i].size())) {
puts("1");
cout << i << endl;
return 0;
}
}
int ans = N, idx = -1;
SCC();
computeNewGraph();
memset(dp, -1, sizeof dp);
for (int i = 0; i < int(int(SCCs.size())); i++) {
if (int(cmpAdj[i].size()) == 0 && ans > int(SCCs[i].size())) {
ans = int(SCCs[i].size());
idx = i;
}
}
printf("%d\n", int(SCCs[idx].size()));
for (int nxt : SCCs[idx]) printf("%d ", nxt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using db = double;
using pii = pair<int, int>;
const int mxn = 100006;
using ai = int[mxn];
int n, m, h;
vi e[mxn];
int u[mxn];
ai dfn, low, scc;
int cnt, scnt;
stack<int, vi> sta;
bool ins[mxn];
int tarjan(int x) {
dfn[x] = low[x] = ++cnt;
sta.push(x);
ins[x] = true;
for (auto i : e[x])
low[x] = min(low[x], dfn[i] ? dfn[ins[i] ? i : x] : tarjan(i));
if (low[x] == dfn[x]) {
++scnt;
int t;
do {
t = sta.top();
sta.pop();
ins[t] = false;
scc[t] = scnt;
} while (t != x);
}
return low[x];
}
int deg[mxn];
vi S[mxn];
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) scanf("%d", &u[i]);
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if ((u[x] + 1) % h == u[y]) e[x].push_back(y);
swap(x, y);
if ((u[x] + 1) % h == u[y]) e[x].push_back(y);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= n; ++i) S[scc[i]].push_back(i);
for (int i = 1; i <= n; ++i)
for (auto j : e[i])
if (scc[i] != scc[j]) ++deg[scc[i]];
int t = 0;
for (int i = 1; i <= scnt; ++i)
if (!deg[i])
if (!t || S[t].size() > S[i].size()) t = i;
cout << S[t].size() << endl;
for (auto i : S[t]) printf("%d ", i);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool visited[100005];
int hrs[100005];
stack<int> stk;
vector<int> adjlist[100005], revlist[100005], sccs[100005];
int scccnt = 0, sccof[100005];
void dfs(int node) {
visited[node] = true;
for (int i = 0; i < adjlist[node].size(); i++) {
int child = adjlist[node][i];
if (!visited[child]) {
dfs(child);
}
}
stk.push(node);
}
void dfs2(int node, bool scc) {
visited[node] = true;
sccof[node] = scccnt;
if (scc) sccs[scccnt].push_back(node);
for (int i = 0; i < revlist[node].size(); i++) {
int child = revlist[node][i];
if (!visited[child]) {
dfs2(child, scc);
}
}
}
int n, m, h;
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
cin >> hrs[i];
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
if (hrs[u] + 1 == hrs[v] || (hrs[u] == h - 1 && hrs[v] == 0)) {
adjlist[u].push_back(v);
revlist[v].push_back(u);
}
if (hrs[v] + 1 == hrs[u] || (hrs[v] == h - 1 && hrs[u] == 0)) {
adjlist[v].push_back(u);
revlist[u].push_back(v);
}
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
dfs(i);
}
}
for (int i = 1; i <= n; i++) {
visited[i] = 0;
}
int mn = 1e9, mnind = 1e9;
while (stk.size() > 0) {
int node = stk.top();
if (!visited[node]) {
scccnt++;
dfs2(node, 1);
bool check = true;
for (int i = 0; i < sccs[scccnt].size(); i++) {
int nd = sccs[scccnt][i];
for (int j = 0; j < adjlist[nd].size(); j++) {
if (sccof[adjlist[nd][j]] != scccnt) {
check = false;
break;
}
}
if (!check) break;
}
if (sccs[scccnt].size() < mn && check) {
mn = sccs[scccnt].size();
mnind = scccnt;
}
}
stk.pop();
}
cout << mn << "\n";
for (int i = 0; i < sccs[mnind].size(); i++) {
cout << sccs[mnind][i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 100;
const int INF = (int)1e9;
int h[N], sz[N], sn[N], ok[N], st[N], used[N];
vector<int> g[N], gr[N];
int scnt;
int cnt = 0;
void dfs1(int v) {
if (used[v]) return;
used[v] = true;
for (size_t i = 0; i < g[v].size(); ++i) dfs1(g[v][i]);
st[++cnt] = v;
}
void dfs2(int v) {
if (sn[v]) {
if (sn[v] != scnt) ok[sn[v]] = 1;
return;
}
sn[v] = scnt;
sz[scnt]++;
for (size_t i = 0; i < gr[v].size(); ++i) dfs2(gr[v][i]);
}
int n, m, u, v, to, k;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) cin >> h[i];
for (int i = 1; i <= m; i++) {
cin >> u >> v;
if ((h[v] - h[u] + k) % k == 1) {
g[u].push_back(v);
gr[v].push_back(u);
}
if ((h[u] - h[v] + k) % k == 1) {
g[v].push_back(u);
gr[u].push_back(v);
}
}
for (int i = 1; i <= n; ++i) dfs1(i);
for (int i = n; i >= 1; --i) {
if (!sn[st[i]]) {
scnt++;
dfs2(st[i]);
}
}
int res = INF;
int vv = 0;
sz[0] = n + 1;
for (int i = 1; i <= scnt; i++) {
if (!ok[i] && res > sz[i]) res = sz[i], vv = i;
}
cout << res << endl;
for (int i = 1; i <= n; i++)
if (vv == sn[i]) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[101010], vi[101010];
vector<int> ord;
int z1[101010], z2[101010];
void h1(int i) {
if (z1[i]) return;
z1[i] = 1;
for (int j : vi[i]) {
h1(j);
}
ord.push_back(i);
}
vector<int> memb;
int oedg = 0;
int h2(int i, int uq) {
if (z2[i]) return 0;
z2[i] = uq + 1;
int s = 1;
memb.push_back(i);
for (int j : v[i]) {
s += h2(j, uq);
if (z2[j] != uq + 1) oedg++;
}
return s;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, h;
cin >> n >> m >> h;
int u[n];
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]) {
v[a].push_back(b);
vi[b].push_back(a);
}
if ((u[b] + 1) % h == u[a]) {
v[b].push_back(a);
vi[a].push_back(b);
}
}
for (int i = 0; i < n; ++i) {
h1(i);
}
reverse(ord.begin(), ord.end());
int result = 1e9;
vector<int> rmemb;
for (int i : ord) {
memb.clear();
oedg = 0;
int x = h2(i, i);
if (x > 0 && !oedg && x < result) {
result = x;
rmemb = memb;
}
}
cout << result << endl;
for (int i : rmemb) cout << i + 1 << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int maxm = 200005;
int n, m, h;
int u[maxn];
int head[2][maxn], point[2][maxm], nxt[2][maxm], size[2];
int t, scccnt;
int stx[maxn], low[maxn], scc[maxn];
stack<int> S;
int szn[maxn];
bool out[maxn];
void init() {
memset(head, -1, sizeof(head));
size[0] = size[1] = 0;
}
void add(int a, int b, int c = 0) {
point[c][size[c]] = b;
nxt[c][size[c]] = head[c][a];
head[c][a] = size[c]++;
}
void dfs(int s) {
stx[s] = low[s] = ++t;
S.push(s);
for (int i = head[0][s]; ~i; i = nxt[0][i]) {
int j = point[0][i];
if (!stx[j]) {
dfs(j);
low[s] = min(low[s], low[j]);
} else if (!scc[j]) {
low[s] = min(low[s], stx[j]);
}
}
if (low[s] == stx[s]) {
scccnt++;
while (1) {
int u = S.top();
S.pop();
scc[u] = scccnt;
szn[scccnt]++;
if (s == u) break;
}
}
}
void setscc() {
memset(stx, 0, sizeof(stx));
memset(scc, 0, sizeof(scc));
t = scccnt = 0;
for (int i = 1; i <= n; ++i)
if (!stx[i]) dfs(i);
for (int i = 1; i <= n; ++i) {
for (int j = head[0][i]; ~j; j = nxt[0][j]) {
int k = point[0][j];
if (scc[i] != scc[k]) {
add(scc[i], scc[k], 1);
out[scc[i]] = 1;
}
}
}
}
int main() {
int i, x, y;
scanf("%d%d%d", &n, &m, &h);
init();
for (i = 1; i <= n; i++) scanf("%d", &u[i]);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
if ((u[x] + 1) % h == u[y]) add(x, y);
if ((u[y] + 1) % h == u[x]) add(y, x);
}
setscc();
int ans = n + 1, pp;
for (i = 1; i <= scccnt; i++) {
if (!out[i] && szn[i] < ans) {
ans = szn[i];
pp = i;
}
}
printf("%d\n", ans);
for (i = 1; i <= n; i++)
if (scc[i] == pp) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void dfs1(vector<vector<int64_t>>& g, vector<bool>& used,
vector<int64_t>& topsort, int64_t v) {
used[v] = true;
for (int64_t i = 0; i < g[v].size(); ++i) {
if (!used[g[v][i]]) {
dfs1(g, used, topsort, g[v][i]);
}
}
topsort.push_back(v);
}
void dfs2(vector<vector<int64_t>>& g, vector<int64_t>& component, int64_t v,
int64_t k) {
component[v] = k;
for (int64_t i = 0; i < g[v].size(); ++i) {
if (component[g[v][i]] == 0) {
dfs2(g, component, g[v][i], k);
}
}
}
int main() {
int64_t n, m, h;
cin >> n >> m >> h;
vector<int64_t> color(n);
vector<vector<int64_t>> g(n);
vector<vector<int64_t>> gr(n);
for (int64_t i = 0; i < n; ++i) {
cin >> color[i];
}
vector<pair<int64_t, int64_t>> edge;
for (int64_t i = 0; i < m; ++i) {
int64_t v, u;
cin >> v >> u;
--v;
--u;
if ((color[v] + 1) % h == color[u]) {
g[v].push_back(u);
gr[u].push_back(v);
edge.push_back(make_pair(v, u));
}
if ((color[u] + 1) % h == color[v]) {
g[u].push_back(v);
gr[v].push_back(u);
edge.push_back(make_pair(u, v));
}
}
vector<int64_t> topsort;
vector<bool> used(n);
for (int64_t i = 0; i < n; ++i) {
if (!used[i]) {
dfs1(g, used, topsort, i);
}
}
vector<int64_t> component(n);
int64_t k = 1;
for (int64_t i = n - 1; i >= 0; --i) {
if (component[topsort[i]] == 0) {
dfs2(gr, component, topsort[i], k);
++k;
}
}
vector<int64_t> cnt(k + 1);
vector<bool> isStok(k + 1, true);
for (int64_t i = 0; i < n; ++i) {
++cnt[component[i]];
}
for (int64_t i = 0; i < edge.size(); ++i) {
if (component[edge[i].first] != component[edge[i].second]) {
isStok[component[edge[i].first]] = false;
}
}
int64_t mn = 1e9;
for (int64_t i = 1; i < k; ++i) {
if (isStok[i] && cnt[i] < mn) {
mn = cnt[i];
}
}
for (int64_t i = 1; i < k; ++i) {
if (isStok[i] && cnt[i] == mn) {
cout << mn << endl;
for (int j = 0; j < n; ++j) {
if (component[j] == i) {
cout << j + 1 << " ";
}
}
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
enum Color { white, grey, black };
class Vertex {
public:
vector<int> edges;
set<int> checkEdge;
int color, sssID;
int answer;
void addEdge(int v);
Vertex() {
color = Color::white;
answer = 1;
}
};
void Vertex::addEdge(int v) {
if (!checkEdge.count(v)) {
edges.push_back(v);
}
}
class StronglyConnected {
private:
vector<int> topoSortVec;
int currentSSS;
int DFSAnswer(int u, set<int> &SSSCountedSet);
void DFSPrintAnswer(int u);
void clearGraph(vector<Vertex> &G);
int DFS(vector<Vertex> &G, function<void(int)> &preFun,
function<void(int)> &inFun, function<void(int)> &postFun, int u);
public:
vector<Vertex> G;
vector<Vertex> GT;
vector<int> SSSRepresentant;
vector<int> SSSAnswer;
int minAnswerSSID;
StronglyConnected(size_t n) : G(n), GT(n) { currentSSS = 0; }
void addPath(int u, int v);
void topoSort();
void findSSS();
void findAnswer();
void printAnswer();
};
void StronglyConnected::addPath(int u, int v) {
G[u].addEdge(v);
GT[v].addEdge(u);
}
void StronglyConnected::topoSort() {
function<void(int)> preFun, inFun, postFun;
auto DFSTopoSort = [this, &preFun, &inFun, &postFun](int u) {
DFS(G, preFun, inFun, postFun, u);
};
preFun = [this](int u) {};
inFun = [&DFSTopoSort, this](int u) {
if (G[u].color == Color::white) {
DFSTopoSort(u);
}
};
postFun = [this](int u) { topoSortVec.push_back(u); };
for (int u = 0; u < G.size(); u++) {
if (G[u].color == Color::white) {
DFSTopoSort(u);
}
}
reverse(topoSortVec.begin(), topoSortVec.end());
}
void StronglyConnected::findSSS() {
currentSSS = 0;
function<void(int)> preFun, inFun, postFun;
auto DFSFindSSS = [this, &preFun, &inFun, &postFun](int u) {
DFS(GT, preFun, inFun, postFun, u);
};
preFun = [this](int u) {
GT[u].sssID = currentSSS;
G[u].sssID = currentSSS;
};
inFun = [&DFSFindSSS, this](int u) {
if (GT[u].color == Color::white) {
DFSFindSSS(u);
}
};
postFun = [this](int u) {};
for (auto u : topoSortVec) {
if (GT[u].color == Color::white) {
SSSRepresentant.push_back(u);
DFSFindSSS(u);
currentSSS++;
}
}
}
void StronglyConnected::clearGraph(vector<Vertex> &G) {
for (auto &vertex : G) {
vertex.color = Color::white;
}
}
int StronglyConnected::DFSAnswer(int u, set<int> &SSSCountedSet) {
G[u].color = Color::grey;
int myAnswer = 1;
SSSCountedSet.insert(G[u].sssID);
for (auto v : G[u].edges) {
if (G[v].color == Color::white) {
myAnswer += DFSAnswer(v, SSSCountedSet);
} else if (G[v].color == Color::black && !SSSCountedSet.count(G[v].sssID)) {
myAnswer += SSSAnswer[G[v].sssID];
SSSCountedSet.insert(v);
}
}
SSSAnswer[G[u].sssID] = max(SSSAnswer[G[u].sssID], myAnswer);
G[u].color = Color::black;
return myAnswer;
}
void StronglyConnected::findAnswer() {
clearGraph(G);
SSSAnswer = vector<int>(currentSSS, 0);
for (auto u : topoSortVec) {
if (G[u].color == Color::white) {
set<int> tmpSet;
DFSAnswer(u, tmpSet);
}
}
int minAnsw = 100000000;
for (int i = 0; i < currentSSS; i++) {
if (SSSAnswer[i] < minAnsw) {
minAnsw = SSSAnswer[i];
minAnswerSSID = i;
}
}
}
void StronglyConnected::DFSPrintAnswer(int u) {
G[u].color = Color::grey;
cout << (u + 1) << " ";
for (auto v : G[u].edges) {
if (G[v].color == Color::white) {
DFSPrintAnswer(v);
}
}
G[u].color = Color::black;
}
void StronglyConnected::printAnswer() {
clearGraph(G);
cout << SSSAnswer[minAnswerSSID] << endl;
DFSPrintAnswer(SSSRepresentant[minAnswerSSID]);
cout << endl;
}
int StronglyConnected::DFS(vector<Vertex> &G, function<void(int)> &preFun,
function<void(int)> &inFun,
function<void(int)> &postFun, int u) {
G[u].color = Color::grey;
preFun(u);
for (auto v : G[u].edges) {
inFun(v);
}
postFun(u);
G[u].color = Color::black;
return 0;
}
class Solution {
public:
int n, m, k;
vector<int> centerUpdateTime;
shared_ptr<StronglyConnected> stronglyConnected;
Solution() {}
void addEdge(int centerA, int centerB) {
if (centerUpdateTime[centerA] > centerUpdateTime[centerB]) {
swap(centerA, centerB);
}
if (centerUpdateTime[centerB] == k - 1 && centerUpdateTime[centerA] == 0) {
stronglyConnected->addPath(centerB, centerA);
}
if (centerUpdateTime[centerB] - centerUpdateTime[centerA] == 1) {
stronglyConnected->addPath(centerA, centerB);
}
}
void readData() {
cin >> n >> m >> k;
centerUpdateTime = vector<int>(n);
stronglyConnected = make_shared<StronglyConnected>(n);
for (int i = 0; i < n; i++) {
cin >> centerUpdateTime[i];
}
int centerA, centerB;
for (int i = 0; i < m; i++) {
cin >> centerA >> centerB;
addEdge(centerA - 1, centerB - 1);
}
}
void findSolution() {
readData();
stronglyConnected->topoSort();
stronglyConnected->findSSS();
stronglyConnected->findAnswer();
stronglyConnected->printAnswer();
}
};
int main() {
Solution solution;
solution.findSolution();
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:336777216")
using namespace std;
int IT_MAX = 1 << 17;
int MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double ERR = 1e-10;
vector<int> conn[100050];
vector<int> rconn[100050];
int in[100050];
bool dchk[100050];
int G[100050];
int gsz[100050];
vector<int> Vstk;
vector<int> Vl[100050];
void DFS1(int n) {
dchk[n] = true;
for (auto it : conn[n])
if (!dchk[it]) DFS1(it);
Vstk.push_back(n);
}
void DFS2(int n, int g) {
G[n] = g;
gsz[g]++;
Vl[g].push_back(n);
for (auto it : rconn[n])
if (!G[it]) DFS2(it, g);
}
bool vchk[100050];
int main() {
int N, M, H, i, j, k;
scanf("%d %d %d", &N, &M, &H);
for (i = 1; i <= N; i++) scanf("%d", &in[i]);
for (i = 1; i <= M; i++) {
int t1, t2;
scanf("%d %d", &t1, &t2);
if ((in[t1] + 1) % H == in[t2]) {
conn[t1].push_back(t2);
rconn[t2].push_back(t1);
}
if ((in[t2] + 1) % H == in[t1]) {
conn[t2].push_back(t1);
rconn[t1].push_back(t2);
}
}
for (i = 1; i <= N; i++)
if (!dchk[i]) DFS1(i);
int gc = 0;
reverse((Vstk).begin(), (Vstk).end());
for (auto it : Vstk)
if (!G[it]) DFS2(it, ++gc);
for (i = 1; i <= N; i++)
for (auto it : conn[i])
if (G[i] != G[it]) vchk[G[i]] = true;
int ans = INF, ap = -1;
for (i = 1; i <= gc; i++) {
if (vchk[i]) continue;
if (ans > gsz[i]) {
ans = gsz[i];
ap = i;
}
}
printf("%d\n", ans);
sort((Vl[ap]).begin(), (Vl[ap]).end());
for (auto it : Vl[ap]) printf("%d ", it);
return !printf("\n");
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize(4)
using namespace std;
const int N = 1e5 + 5;
int a[N], n, m, h, u, v, out[N];
int low[N], dfn[N], stk[N], bl[N], top = 0, cnt = 0, tot = 0;
bool vis[N];
vector<int> cmp[N], g[N];
void dfs(int u) {
low[u] = dfn[u] = ++cnt;
stk[++top] = u;
vis[u] = true;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (!dfn[v])
dfs(v), low[u] = min(low[u], low[v]);
else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
++tot;
while (stk[top] != u)
vis[stk[top]] = false, bl[stk[top]] = tot, cmp[tot].push_back(stk[top--]);
vis[u] = false;
bl[u] = tot;
top--;
cmp[tot].push_back(u);
}
}
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) {
scanf("%d %d", &u, &v);
if ((a[u] + 1) % h == a[v]) g[u].push_back(v);
if ((a[v] + 1) % h == a[u]) g[v].push_back(u);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) dfs(i);
int mn = n, id = -1;
for (int i = 1; i <= n; ++i) {
for (int v : g[i]) {
if (bl[v] != bl[i]) {
out[bl[i]]++;
}
}
}
for (int i = 1; i <= tot; ++i) {
if (out[i] == 0 && cmp[i].size() <= mn) {
id = i;
mn = cmp[i].size();
}
}
printf("%d\n", cmp[id].size());
for (int x : cmp[id]) printf("%d ", x);
return 0;
}
|
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
inline void read(int &x) {
x = 0;
register char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 3) + (x << 1) + (c - '0');
}
inline void write(int x) {
register char buffor[35];
register int i = 0;
do {
buffor[i++] = (x % 10) + '0';
x /= 10;
} while (x);
i--;
while (i >= 0) putchar(buffor[i--]);
putchar('\n');
}
inline int in() {
int x;
read(x);
return x;
}
void solve();
int dbg = 1;
using namespace std;
int main() {
int t = 1;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
vector<int> vec[300005], vec2[300005], stk, com[300005];
int arr[300005], vis[300005], tot, comp[300005];
void dfs(int cu) {
if (vis[cu]) return;
vis[cu] = 1;
for (int i = 0; i < vec[cu].size(); i++) dfs(vec[cu][i]);
stk.push_back(cu);
}
void dfs2(int cu) {
vis[cu] = 1;
com[tot].push_back(cu);
comp[cu] = tot;
for (int i = 0; i < vec2[cu].size(); i++)
if (!vis[vec2[cu][i]]) dfs2(vec2[cu][i]);
}
void solve() {
int n, m, h, x, y, ans, fans;
cin >> n >> m >> h;
ans = n + 1;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
if ((arr[x] + 1) % h == arr[y]) {
vec2[y].push_back(x);
vec[x].push_back(y);
}
if ((arr[y] + 1) % h == arr[x]) {
vec2[x].push_back(y);
vec[y].push_back(x);
}
}
for (int i = 0; i < n; i++) dfs(i);
for (int i = 0; i < n; i++) vis[i] = 0;
while (stk.size()) {
int a = stk.back();
stk.pop_back();
if (vis[a]) continue;
dfs2(a);
tot++;
}
for (int i = 0; i < tot; i++) {
int fl = 0;
for (int j = 0; j < com[i].size() && !fl; j++)
for (int k = 0; k < vec[com[i][j]].size() && !fl; k++)
if (comp[vec[com[i][j]][k]] != i) fl = 1;
if (fl == 0 && com[i].size() < ans) {
ans = com[i].size();
fans = i;
}
}
cout << ans << endl;
for (int i = 0; i < com[fans].size(); i++) cout << com[fans][i] + 1 << " ";
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long int inf = 2e18;
const long double eps = 1e-9;
const int NN = 1e5 + 2;
vector<vector<int> > adj;
int u[NN];
int curr[NN];
bool vis[NN];
vector<vector<int> > scc;
stack<int> STACK;
void DFS(int source, bool second_DFS) {
vis[source] = true;
if (second_DFS) scc[scc.size() - 1].push_back(source);
for (auto v : adj[source])
if (!vis[v]) DFS(v, second_DFS);
if (!second_DFS) STACK.push(source);
}
void solve() {
int i = 0, j = 0, k = 0, n = 0, m = 0;
cin >> n >> m >> k;
;
for (i = 1; i < (n + 1); i++) {
cin >> u[i];
}
vector<int> tmp;
adj.assign(n + 2, tmp);
set<pair<int, int> > taken;
while (m--) {
cin >> i >> j;
if (i < j) swap(i, j);
if (taken.find({i, j}) == taken.end()) {
taken.insert({i, j});
if ((u[j] + 1) % k == u[i]) {
adj[j].push_back(i);
}
if ((u[i] + 1) % k == u[j]) {
adj[i].push_back(j);
};
}
}
for (i = 1; i <= n; i++) {
for (auto u : adj[i])
;
}
for (i = 0; i < (n); i++) {
if (adj[i + 1].size() == 0) {
;
cout << 1 << '\n';
cout << i + 1;
return;
}
}
int min_sz = 1e9;
vector<int> ans;
for (i = 1; i <= n; i++) {
if (!vis[i]) {
DFS(i, 0);
}
}
vector<vector<int> > orig = adj;
adj.clear();
adj.assign(n + 1, tmp);
for (auto p : taken) {
j = p.second;
i = p.first;
if ((u[j] + 1) % k == u[i]) {
adj[i].push_back(j);
}
if ((u[i] + 1) % k == u[j]) {
adj[j].push_back(i);
}
}
fill(vis, vis + n + 1, 0);
while (!STACK.empty()) {
int source = STACK.top();
STACK.pop();
if (!vis[source]) {
scc.emplace_back(tmp);
DFS(source, 1);
}
}
for (auto& vvv : scc) {
bool out_edge = 0;
set<int> curr_comp;
for (auto node : vvv) {
curr_comp.insert(node);
}
for (auto node : vvv) {
for (auto x : orig[node]) {
if (curr_comp.find(x) == curr_comp.end()) {
out_edge = 1;
break;
}
}
if (out_edge) break;
}
if (!out_edge && vvv.size() < min_sz) {
ans = vvv;
min_sz = vvv.size();
}
}
cout << min_sz << '\n';
for (auto x : ans) {
cout << x << ' ';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T = 1, tc;
for (tc = 1; tc <= T; tc++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void upmin(T &x, T y) {
y < x ? x = y : 0;
}
template <typename T>
inline void upmax(T &x, T y) {
x < y ? x = y : 0;
}
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long OO = 1e18;
const int N = 2e5 + 100;
int gi() {
int w = 0;
bool q = 1;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') q = 0, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return q ? w : -w;
}
int val[N];
int head[N], nxt[N], to[N], cnt;
int st[N], top;
bool in[N];
int rt[N], siz[N], scc;
int dfn[N], low[N];
void dfs(int k) {
dfn[k] = low[k] = ++cnt;
in[k] = true;
st[++top] = k;
for (int i = head[k]; i; i = nxt[i])
if (!dfn[to[i]])
dfs(to[i]), upmin(low[k], low[to[i]]);
else if (in[to[i]])
upmin(low[k], dfn[to[i]]);
if (low[k] == dfn[k]) {
rt[k] = ++scc;
while (st[top] != k) in[st[top]] = false, rt[st[top--]] = scc;
in[st[top--]] = false;
}
}
int main() {
int n = gi(), m = gi(), h = gi(), i, a, b, tot = 0, k, ans = n;
for (i = 1; i <= n; i++) val[i] = gi();
while (m--) {
a = gi(), b = gi();
if ((val[b] + 1) % h == val[a])
to[++tot] = a, nxt[tot] = head[b], head[b] = tot;
if ((val[a] + 1) % h == val[b])
to[++tot] = b, nxt[tot] = head[a], head[a] = tot;
}
for (i = 1; i <= n; i++)
if (!rt[i]) dfs(i);
for (i = 1; i <= n; i++) ++siz[rt[i]];
for (k = 1; k <= n; k++)
for (i = head[k]; i; i = nxt[i])
if (rt[k] != rt[to[i]]) in[rt[k]] = true;
for (i = 1; i <= scc; i++)
if (!in[i]) upmin(ans, siz[i]);
cout << ans << endl;
for (i = 1; i <= scc; i++)
if (!in[i] && siz[i] == ans) {
for (k = 1; k <= n; k++)
if (rt[k] == i) printf("%d ", k);
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> e[500010];
int n, m, h, a, b, no_sc, tot;
int t[500010];
int dfn[500010], low[500010], num[500010], scc[500010], out[500010];
stack<int> s;
void tarjan(int u) {
dfn[u] = low[u] = ++tot;
s.push(u);
for (int i : e[u]) {
if (dfn[i] == 0) tarjan(i);
low[u] = min(low[u], low[i]);
}
if (dfn[u] == low[u]) {
no_sc++;
while (1) {
int x = s.top();
s.pop();
scc[x] = no_sc;
num[no_sc]++;
if (x == u) break;
}
}
}
int main() {
no_sc = 0;
tot = 0;
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) cin >> t[i];
for (int i = 1; i <= m; i++) {
cin >> a >> b;
if ((t[a] + 1) % h == t[b]) e[a].push_back(b);
if ((t[b] + 1) % h == t[a]) e[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (dfn[i] == 0) tarjan(i);
for (int i = 1; i <= n; i++) {
for (int j : e[i]) {
if (scc[i] != scc[j]) out[scc[i]]++;
}
}
int ans = 100010, flag;
for (int i = 1; i <= no_sc; i++) {
if (num[i] < ans && out[i] == 0) {
ans = num[i];
flag = i;
}
}
cout << ans << endl;
for (int i = 1; i <= n; i++)
if (scc[i] == flag) cout << i << ' ';
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 1000 * 1000 * 1000 + 7;
const int N = 200005;
const double PI = acos(-1.0);
const double eps = 1e-9;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
int n, m, h, a[N], d[N], x, y, z, ans = oo;
vector<int> V[N], ret;
const int _N = 1e6 + 5, _M = 1e6 + 5;
struct Tu {
int head[_N], nxt[_M], e[_M], n, tot;
long long v[_N], w[_M];
void Init(int _n) { n = _n, memset(head, 0, sizeof(head)), tot = 0; }
void I(int x, int y, long long _w) {
e[++tot] = y, w[tot] = _w;
nxt[tot] = head[x], head[x] = tot;
}
};
struct Tarjan {
int id[_N], dfn[_N], low[_N], s[_N], n, r, t, tot;
bool in[_N];
void dfs(Tu &A, int x) {
dfn[x] = low[x] = ++t, in[x] = 1, s[++r] = x;
for (int i = A.head[x], y; i; i = A.nxt[i])
if (!dfn[y = A.e[i]])
dfs(A, y), low[x] = ((low[x]) < (low[y]) ? (low[x]) : (low[y]));
else if (in[y])
low[x] = ((low[x]) < (dfn[y]) ? (low[x]) : (dfn[y]));
if (low[x] == dfn[x]) {
++tot;
while (r && s[r + 1] != x) id[s[r]] = tot, in[s[r--]] = 0;
}
}
void solve(Tu &A, Tu &B) {
n = A.n;
memset(dfn, 0, sizeof(dfn));
memset(low, 0, sizeof(low));
memset(in, 0, sizeof(in));
r = tot = t = 0;
for (int x = (1); x <= (n); ++x)
if (!dfn[x]) dfs(A, x);
B.Init(tot);
memset(B.v, 0, sizeof(B.v));
for (int x = (1); x <= (n); ++x)
for (int i = A.head[x]; i; i = A.nxt[i])
if (id[x] == id[A.e[i]])
B.v[id[x]] += A.w[i];
else
B.I(id[x], id[A.e[i]], A.w[i]), d[id[x]]++;
for (int x = (1); x <= (n); ++x) V[id[x]].push_back(x);
}
};
Tu A, B;
Tarjan T;
int main() {
scanf("%d%d%d", &n, &m, &h), A.Init(n);
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]);
for (int i = (1); i <= (m); ++i) {
scanf("%d%d", &x, &y);
if ((a[x] + 1) % h == a[y]) A.I(x, y, 0);
if ((a[y] + 1) % h == a[x]) A.I(y, x, 0);
}
T.solve(A, B);
for (int i = (1); i <= (B.n); ++i)
if (!d[i] && V[i].size() < ans) ans = V[i].size(), ret.swap(V[i]);
printf("%d\n", ans);
for (__typeof((ret).begin()) it = (ret).begin(); it != (ret).end(); it++)
printf("%d ", *it);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, h;
int a[N];
vector<int> v[N];
vector<int> g[N];
int deg[N];
int root[N];
int parent[N];
int s[N];
int vidjen[N];
int tren[N];
stack<int> ss;
vector<int> pom;
int timee;
vector<int> ww;
int momenat[N];
int res = 1000000000;
int q;
int ciklus[N];
vector<int> gg[N];
vector<int> rev[N];
vector<int> qqq;
int num[N];
int cnt[N];
int next(int s) {
if (s == h - 1) return 0;
return s + 1;
}
void dfs(int u) {
vidjen[u] = 1;
for (int x : g[u]) {
if (vidjen[x]) continue;
dfs(x);
}
ss.push(u);
}
void revdfs(int u, int ind) {
vidjen[u] = 1;
for (int x : rev[u]) {
if (vidjen[x]) continue;
revdfs(x, ind);
}
num[u] = ind;
cnt[ind]++;
}
int out[N];
int main() {
for (int i = 0; i < N; i++) parent[i] = i, s[i] = 1;
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cerr.tie(NULL);
}
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
cerr << "----------"
<< "\n";
for (int i = 1; i <= n; i++) {
for (int x : v[i]) {
int aa = a[i];
int b = a[x];
aa = next(aa);
if (b == aa) g[i].push_back(x), root[i] = 1, rev[x].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
if (vidjen[i]) continue;
dfs(i);
}
for (int i = 1; i <= n; i++) vidjen[i] = 0;
int val = 0;
while ((int)ss.size()) {
int x = ss.top();
ss.pop();
if (vidjen[x]) continue;
revdfs(x, ++val);
}
for (int i = 1; i <= n; i++) {
for (int x : g[i]) {
if (num[x] ^ num[i]) out[num[i]] = 1;
}
}
int ind;
for (int i = 1; i <= n; i++) {
if (out[num[i]] == 0 && cnt[num[i]] < res) {
res = cnt[num[i]];
ind = num[i];
}
}
cout << res << "\n";
for (int i = 1; i <= n; i++)
if (num[i] == ind) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int si[N], a[N], id[N], cnt, dfn[N], low[N], times, stk[N], top;
bool st[N];
vector<int> h[N];
void tarjan(int u) {
stk[top++] = u, dfn[u] = low[u] = ++times, st[u] = true;
for (int i = 0; i < h[u].size(); i++) {
int j = h[u][i];
if (!dfn[j]) {
tarjan(j);
low[u] = min(low[u], low[j]);
} else if (st[j])
low[u] = min(low[u], dfn[j]);
}
if (low[u] == dfn[u]) {
int y;
cnt++;
do {
y = stk[--top], st[y] = false;
id[y] = cnt, si[cnt]++;
} while (u != y);
}
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
int as, b;
scanf("%d%d", &as, &b);
if ((a[as] + 1) % k == a[b]) h[as].push_back(b);
if ((a[b] + 1) % k == a[as]) h[b].push_back(as);
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i);
}
static int d[N];
for (int i = 1; i <= n; i++)
for (int j = 0; j < h[i].size(); j++) {
int k = h[i][j];
int x = id[i], y = id[k];
if (x != y) d[x]++;
}
int Min = 1e9, temp = -1;
for (int i = 1; i <= cnt; i++) {
if (!d[i] && Min > si[i]) Min = si[i], temp = i;
}
printf("%d\n", Min);
for (int i = 1; i <= n; i++)
if (id[i] == temp) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000 + 10;
int n, m, h, u[MAXN];
vector<int> G[MAXN];
bool ins[MAXN], odg[MAXN];
int dfn[MAXN], low[MAXN], cnt, label;
int sz[MAXN], idx[MAXN];
vector<int> sta;
int dfs(int u) {
low[u] = dfn[u] = ++label;
ins[u] = 1;
sta.push_back(u);
for (auto v : G[u]) {
if (!dfn[v]) {
low[u] = min(low[u], dfs(v));
} else if (ins[v]) {
low[u] = min(low[u], low[v]);
}
}
if (low[u] == dfn[u]) {
++cnt;
int v;
do {
v = sta.back();
++sz[cnt];
ins[v] = 0;
idx[v] = cnt;
sta.pop_back();
} while (v != u);
}
return low[u];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> h;
for (int i = 1; i <= n; ++i) {
cin >> u[i];
}
for (int c1, c2, i = 1; i <= m; ++i) {
cin >> c1 >> c2;
if ((u[c1] + 1) % h == u[c2]) {
G[c1].push_back(c2);
}
if ((u[c2] + 1) % h == u[c1]) {
G[c2].push_back(c1);
}
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) {
dfs(i);
}
for (int u = 1; u <= n; ++u) {
for (auto v : G[u])
if (idx[u] != idx[v]) {
odg[idx[u]] = 1;
}
}
int nod = -1, ans = 0x7fffffff;
for (int i = 1; i <= cnt; ++i)
if (!odg[i]) {
if (sz[i] < ans) {
ans = sz[i];
nod = i;
}
}
cout << ans << '\n';
for (int i = 1; i <= n; ++i)
if (idx[i] == nod) {
cout << i << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g, t;
deque<int> cmp, obh;
vector<bool> vis;
pair<int, int> operator+(pair<int, int> l, pair<int, int> r) {
return make_pair(l.first + r.first, l.second + r.second);
}
void dfs1(int v) {
vis[v] = 1;
for (auto& it : g[v])
if (!vis[it]) dfs1(it);
obh.push_front(v);
}
void dfs2(int v, int cur) {
vis[v] = 0;
cmp[v] = cur;
for (auto& it : t[v])
if (vis[it]) dfs2(it, cur);
}
pair<int, int> dfs3(int v) {
vis[v] = 1;
pair<int, int> ans = {0, 1};
for (auto& it : g[v]) {
if (!vis[it] && cmp[it] == cmp[v]) ans = ans + dfs3(it);
if (cmp[it] != cmp[v]) ans.first++;
}
return ans;
}
signed main() {
int n, m, h;
cin >> n >> m >> h;
vector<int> tms(n);
for (auto& it : tms) cin >> it;
g.resize(n);
t.resize(n);
while (m--) {
int a, b;
cin >> a >> b;
a--;
b--;
if ((tms[a] + 1) % h == tms[b]) {
g[a].push_back(b);
t[b].push_back(a);
}
if ((tms[b] + 1) % h == tms[a]) {
g[b].push_back(a);
t[a].push_back(b);
}
}
vis.resize(n, false);
for (int i = 0; i < n; ++i)
if (!vis[i]) dfs1(i);
cmp.resize(n);
int cur = 0;
for (int i = 0; i < n; ++i)
if (vis[obh[i]]) dfs2(obh[i], cur++);
int mn = 1e9, curcur = -1;
for (int i = 0; i < n; ++i)
if (!vis[i]) {
pair<int, int> kk = dfs3(i);
if (kk.first == 0 && kk.second < mn) {
mn = kk.second;
curcur = cmp[i];
}
}
cout << mn << '\n';
for (int i = 0; i < n; ++i)
if (cmp[i] == curcur) cout << i + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
int n, m, h, u[maxn], out[maxn], sz[maxn], cnt;
vector<int> g[maxn];
stack<int> S;
int low[maxn], pre[maxn], sccno[maxn], ins[maxn], clk;
void dfs(int p) {
low[p] = pre[p] = ++clk;
S.push(p);
ins[p] = 1;
for (int i = 0; i < g[p].size(); i++) {
int v = g[p][i];
if (!pre[v]) {
dfs(v);
low[p] = min(low[p], low[v]);
} else if (ins[v])
low[p] = min(low[p], pre[v]);
}
if (low[p] == pre[p]) {
cnt++;
while (1) {
int x = S.top();
ins[x] = 0;
sccno[x] = cnt;
sz[cnt]++;
S.pop();
if (x == p) break;
}
}
}
void findscc() {
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++) {
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);
}
findscc();
for (int 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, num;
for (int i = 1; i <= cnt; i++)
if (!out[i] && sz[i] < ans) {
ans = sz[i];
num = i;
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (sccno[i] == num) printf("%d ", i);
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 100228;
int n, m, h;
int tme[SIZE];
vector<int> gr[SIZE], rgr[SIZE];
vector<int> topsort;
vector<bool> used;
vector<int> gr_comp[SIZE];
int comps[SIZE];
vector<int> vert[SIZE];
void dfsts(int v) {
used[v] = true;
for (int i : gr[v]) {
if (!used[i]) {
dfsts(i);
}
}
topsort.push_back(v);
}
void dfs(int v, int comp) {
comps[v] = comp;
vert[comp].push_back(v);
used[v] = true;
for (int i : rgr[v]) {
if (!used[i]) {
dfs(i, comp);
} else if (used[i] && comps[i] != comps[v]) {
gr_comp[comps[i]].push_back(comps[v]);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> h;
for (int i = 0; i < n; ++i) {
cin >> tme[i];
}
for (int i = 0; i < m; ++i) {
int c1, c2;
cin >> c1 >> c2;
c1--;
c2--;
if ((tme[c1] + 1) % h == tme[c2]) {
gr[c1].push_back(c2);
rgr[c2].push_back(c1);
}
if ((tme[c2] + 1) % h == tme[c1]) {
gr[c2].push_back(c1);
rgr[c1].push_back(c2);
}
}
used.resize(n);
for (int i = 0; i < n; ++i) {
if (!used[i]) {
dfsts(i);
}
}
reverse(topsort.begin(), topsort.end());
used.assign(n, false);
int cur_comp = 0;
for (int i = 0; i < n; ++i) {
if (!used[topsort[i]]) {
dfs(topsort[i], cur_comp);
cur_comp++;
}
}
int pos = -1;
for (int i = 0; i < cur_comp; ++i) {
if (gr_comp[i].size() == 0 &&
(pos == -1 || vert[i].size() < vert[pos].size())) {
pos = i;
}
}
cout << vert[pos].size() << endl;
for (int i : vert[pos]) {
cout << i + 1 << ' ';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1E9;
std::vector<long long> g[100005], gg[100005];
long long N, M;
long long vis[100005];
std::stack<long long> order;
std::vector<long long> components;
void dfs1(long long at) {
if (vis[at]) return;
vis[at] = 1;
for (auto it : g[at])
if (vis[it] == 0) dfs1(it);
order.push(at);
}
long long dfs2(long long root, long long at) {
if (vis[at] == root) return 0;
if (vis[at] != -1) return inf;
vis[at] = root;
long long ret = 1;
for (auto it : gg[at]) {
if (vis[it] != root) {
ret = ret + dfs2(root, it);
}
}
components.push_back(at);
return ret;
}
int main() {
long long h;
cin >> N >> M >> h;
std::vector<long long> a(N);
for (auto &it : a) cin >> it;
while (M--) {
long long x, y;
cin >> x >> y;
x--;
y--;
if ((a[x] + 1) % h == a[y]) {
g[y].push_back(x);
gg[x].push_back(y);
}
if ((a[y] + 1) % h == a[x]) {
g[x].push_back(y);
gg[y].push_back(x);
}
}
memset(vis, 0, sizeof(vis));
for (long long i = 0; i < N; i++)
if (vis[i] == 0) dfs1(i);
memset(vis, -1, sizeof(vis));
long long ans = inf;
std::vector<long long> cc;
while (order.empty() == false) {
long long x = order.top();
order.pop();
if (vis[x] == -1) {
components = std::vector<long long>();
if (ans >= dfs2(x, x)) {
cc = components;
ans = cc.size();
}
}
}
cout << cc.size() << endl;
;
for (auto it : cc) cout << it + 1 << " ";
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-Ofast", "-funroll-all-loops")
using namespace std;
const int N = 1e5 + 10;
int n, m, h, a[N], dfn[N], vis[N], deg[N], num[N], low[N], scc[N], cnt, co, res;
vector<int> g[N];
stack<int> s;
void Tarjan(int x) {
low[x] = dfn[x] = ++cnt;
vis[x] = 1;
s.push(x);
for (int to : g[x]) {
if (!dfn[to])
Tarjan(to), low[x] = min(low[x], low[to]);
else if (vis[to])
low[x] = min(low[x], dfn[to]);
}
if (dfn[x] == low[x]) {
int u;
co++;
do {
u = s.top();
s.pop();
scc[u] = co;
num[co]++;
vis[u] = 0;
} while (u != x);
}
}
signed main() {
cin >> n >> m >> h;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1, x, y; i <= m; i++) {
scanf("%d %d", &x, &y);
if ((a[x] + 1) % h == a[y]) g[x].push_back(y);
if ((a[y] + 1) % h == a[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++)
for (int to : g[i])
if (scc[i] != scc[to]) deg[scc[i]]++;
for (int i = 1; i <= co; i++)
if (!deg[i] && (!res || num[i] < num[res])) res = i;
cout << num[res] << endl;
for (int i = 1; i <= n; i++)
if (scc[i] == res) printf("%d ", i);
return 0;
}
|
#include <bits/stdc++.h>
const int max_n = 200000;
std::vector<int> G[max_n];
int C[max_n];
int update[max_n];
int n, c, m;
std::vector<std::vector<int>> solution;
std::vector<int> current;
int D[max_n], S[max_n], InS[max_n];
int top, ile, tt;
int delta[max_n], eta[max_n];
int best;
void dfs(std::vector<int> *G, int v, int *C) {
S[top++] = v;
InS[v] = 1;
delta[v] = eta[v] = ++tt;
D[v] = 1;
for (int i = 0; i < G[v].size(); ++i) {
if (D[G[v][i]] == 0) {
dfs(G, G[v][i], C);
eta[v] = std::min(eta[v], eta[G[v][i]]);
} else if (delta[G[v][i]] < delta[v] && InS[G[v][i]])
eta[v] = std::min(eta[v], delta[G[v][i]]);
}
if (delta[v] == eta[v]) {
++ile;
current.clear();
while (top > 0 && delta[v] <= delta[S[top - 1]]) {
--top;
InS[S[top]] = 0;
C[S[top]] = ile;
current.push_back(S[top] + 1);
}
solution.push_back(current);
}
}
int lmSCCTarjanAlgo(std::vector<int> *G, int n, int *C) {
for (int i = 0; i < n; ++i) D[i] = InS[i] = 0;
top = ile = tt = 0;
for (int i = 0; i < n; ++i)
if (!D[i]) dfs(G, i, C);
return ile;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin >> n >> c >> m;
for (int i = 0; i < n; ++i) {
std::cin >> update[i];
}
for (int i = 0; i < c; ++i) {
int a, b;
std::cin >> a >> b;
--a, --b;
if ((update[a] + 1) % m == update[b]) {
G[a].push_back(b);
}
if ((update[b] + 1) % m == update[a]) {
G[b].push_back(a);
}
}
best = n + 1;
lmSCCTarjanAlgo(G, n, C);
best = n + 1;
int indeks = -1;
for (int i = 0; i < solution.size(); ++i) {
bool good = true;
for (int j = 0; j < solution[i].size(); ++j) {
int v = solution[i][j] - 1;
for (int k = 0; k < G[v].size(); ++k) {
if (C[v] != C[G[v][k]]) good = false;
}
}
if (good && solution[i].size() < best) {
best = solution[i].size();
indeks = i;
}
}
std::cout << best << std::endl;
for (int i = 0; i < best; ++i) {
std::cout << solution[indeks][i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100001;
vector<int> v[maxn];
stack<int> s, anss;
int dfn[maxn], low[maxn], tot, ans = maxn, ins[maxn];
int n, m;
void tarjan(int x) {
low[x] = dfn[x] = ++tot;
s.push(x);
ins[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int p = v[x][i];
if (!dfn[p]) {
tarjan(p);
low[x] = min(low[x], low[p]);
} else if (ins[p])
low[x] = min(low[x], dfn[p]);
}
if (low[x] == dfn[x]) {
int cnt = 0;
stack<int> ss;
while (1) {
int now = s.top();
s.pop();
ins[x] = 0;
cnt++;
ss.push(now);
if (now == x) break;
}
if (cnt > 1) {
if (ans > cnt) {
ans = cnt;
anss = ss;
}
}
}
}
int U[maxn];
bool isok[maxn];
int main() {
int n, M, H;
scanf("%d%d%d", &n, &M, &H);
for (int i = 1; i <= n; i++) scanf("%d", &U[i]);
for (int i = 1, u, vv; i <= M; i++) {
scanf("%d%d", &u, &vv);
if ((U[u] + 1) % H == U[vv]) v[u].push_back(vv), isok[u] = 1;
if ((U[vv] + 1) % H == U[u]) v[vv].push_back(u), isok[vv] = 1;
}
for (int i = 1; i <= n; i++)
if (!isok[i]) {
printf("%d\n%d\n", 1, i);
return 0;
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) {
tarjan(i);
}
}
cout << ans << endl;
while (!anss.empty()) {
printf("%d ", anss.top());
anss.pop();
}
}
|
#include <bits/stdc++.h>
const int maxn = 100010;
const int maxm = 200010;
using namespace std;
struct Tarjan {
int head[maxn], node[maxm], nex[maxm], top, n;
void clr() {
top = 0;
memset(head, -1, sizeof(head));
memset(nex, 0, sizeof(nex));
}
void addedge(int u, int v) {
node[top] = v;
nex[top] = head[u];
head[u] = top++;
}
int low[maxn], dfn[maxn], sz[maxn], scc[maxn], stack[maxn], dout[maxn],
scccnt, times;
void dfs(int u) {
low[u] = dfn[u] = ++times;
stack[++stack[0]] = u;
for (int tmp = head[u]; tmp != -1; tmp = nex[tmp]) {
int v = node[tmp];
if (!dfn[v]) {
dfs(v);
if (low[v] < low[u]) low[u] = low[v];
} else if (!scc[v] && dfn[v] < low[u])
low[u] = dfn[v];
}
if (dfn[u] == low[u]) {
scccnt++;
while (1) {
int v = stack[stack[0]--];
scc[v] = scccnt;
sz[scccnt]++;
if (v == u) break;
}
}
}
void calc() {
for (int i = 1; i <= n; i++)
for (int j = head[i]; j != -1; j = nex[j]) {
int v = node[j];
if (scc[i] != scc[v]) dout[scc[i]]++;
}
int Ans = 1e9, t = 0;
for (int i = 1; i <= scccnt; i++)
if (!dout[i] && sz[i] < Ans) Ans = sz[i], t = i;
printf("%d\n", Ans);
for (int i = 1; i <= n; i++)
if (scc[i] == t) printf("%d ", i);
}
void getscc() {
memset(low, 0, sizeof(low));
memset(dfn, 0, sizeof(dfn));
memset(scc, 0, sizeof(scc));
stack[0] = 0;
scccnt = 0;
times = 0;
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i);
}
} G;
int w[maxn];
int n, m, h;
int main() {
scanf("%d%d%d", &n, &m, &h);
G.n = n;
G.clr();
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if ((w[u] + 1) % h == w[v]) G.addedge(u, v);
if ((w[v] + 1) % h == w[u]) G.addedge(v, u);
}
G.getscc();
G.calc();
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() {
ios::sync_with_stdio(false);
cin.tie();
cin >> N >> M >> H;
for (int i = 1; i <= N; ++i) cin >> hours[i];
int a, b;
for (int i = 1; i <= M; ++i) {
cin >> 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>
const int inf = (1ll << 30) - 1;
const int maxn = (int)1e5 + 10;
using namespace std;
int a[200200];
int n, m, h;
vector<int> g[400400];
int col[200200];
vector<int> gr[400400], ord;
int used[400400];
int F = 0;
void add_edge(int i, int j, int u, int v) {
if ((u + 1) % h == v) {
g[i].push_back(j);
}
if ((v + 1) % h == u) {
g[j].push_back(i);
}
}
void dfs(int v) {
used[v] = 1;
for (int i = 0; i < gr[v].size(); i++) {
int to = gr[v][i];
if (!used[to]) dfs(to);
}
ord.push_back(v);
}
vector<int> li;
int ok;
void dfs2(int v, int cc) {
used[v] = 1;
col[v] = cc;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!used[to])
dfs2(to, cc);
else if (col[to] != cc) {
ok = 0;
}
}
li.push_back(v);
}
void solve() {
scanf("%d%d%d", &n, &m, &h);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1, x, y; i <= m; i++) {
scanf("%d%d", &x, &y);
add_edge(x, y, a[x], a[y]);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j];
gr[to].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs(i);
}
}
memset(used, 0, sizeof used);
reverse(ord.begin(), ord.end());
int cc = 1;
vector<int> ans;
int cur_ans = inf;
for (int i = 0; i < ord.size(); i++) {
int v = ord[i];
if (!used[v]) {
ok = 1;
li.clear();
dfs2(v, cc);
cc++;
if (ok && cur_ans > li.size()) {
cur_ans = li.size();
ans = li;
}
}
}
printf("%d\n", (int)cur_ans);
for (__typeof(ans.begin()) it = ans.begin(); it != ans.end(); it++) {
printf("%d ", *it);
}
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> e;
vector<vector<int>> re;
vector<int> vis;
vector<int> seq;
vector<int> cand;
void dfs1(int i) {
if (vis[i]) return;
vis[i] = 1;
for (int j : re[i]) {
dfs1(j);
}
seq.push_back(i);
}
bool dfs2(int i) {
if (vis[i] == 2) return false;
if (vis[i] == 1) return true;
vis[i] = 1;
cand.push_back(i);
bool res = true;
for (int j : e[i]) {
res &= dfs2(j);
}
return res;
}
int main() {
int n, m, h;
scanf("%d %d %d", &n, &m, &h);
e.resize(n);
re.resize(n);
vector<int> u(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &u[i]);
}
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d %d", &x, &y);
--x;
--y;
if ((u[x] + 1) % h == u[y]) {
e[x].push_back(y);
re[y].push_back(x);
}
if ((u[y] + 1) % h == u[x]) {
e[y].push_back(x);
re[x].push_back(y);
}
}
vis = vector<int>(n, 0);
for (int i = 0; i < n; ++i) {
dfs1(i);
}
vis = vector<int>(n, 0);
vector<int> best;
while (!seq.empty()) {
if (dfs2(seq.back())) {
if (best.empty() || cand.size() < best.size()) {
best = cand;
}
}
for (int i : cand) {
vis[i] = 2;
}
seq.pop_back();
cand.clear();
}
printf("%d\n", best.size());
for (int v : best) {
printf("%d ", v + 1);
}
printf("\n");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.