text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, m, tot, ans[N];
set<int> e[N], st;
int bfs(int S) {
int cnt = 0;
queue<int> Q;
Q.push(S);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
cnt++;
for (set<int>::iterator it = st.begin(); it != st.end();) {
if (e[u].count(*it)) {
it++;
continue;
}
int v = *it;
it++;
Q.push(v);
st.erase(v);
}
}
return cnt;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
register int x, y;
scanf("%d%d", &x, &y);
e[x].insert(y);
e[y].insert(x);
}
for (int i = 1; i <= n; i++) st.insert(i);
for (int i = 1; i <= n; i++) {
if (st.count(i)) st.erase(i), ans[++tot] = bfs(i);
}
printf("%d\n", tot);
sort(ans + 1, ans + tot + 1);
for (int i = 1; i <= tot; i++) {
printf("%d ", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 7;
set<pair<int, int>> ms;
bool tree[MAXN * 4];
int n, m;
int find(int v, int tl, int tr, int l, int r) {
if (tr < l || r < tl) return -1;
if (tree[v]) return -1;
if (tl == tr) return tl;
int tm = (tl + tr) / 2;
int lres = find(v * 2 + 1, tl, tm, l, r);
if (lres != -1)
return lres;
else
return find(v * 2 + 2, tm + 1, tr, l, r);
}
void upd(int v, int tl, int tr, int p) {
if (tl == tr) {
tree[v] = true;
return;
}
int tm = (tl + tr) / 2;
if (p <= tm)
upd(v * 2 + 1, tl, tm, p);
else
upd(v * 2 + 2, tm + 1, tr, p);
tree[v] = (tree[v * 2 + 1] & tree[v * 2 + 2]);
}
bool get(int v, int tl, int tr, int p) {
if (tl == tr) return tree[v];
int tm = (tl + tr) / 2;
if (p <= tm)
return get(v * 2 + 1, tl, tm, p);
else
return get(v * 2 + 2, tm + 1, tr, p);
}
int dfs(int u) {
upd(0, 0, n - 1, u);
int res = 1;
int last = -1;
while (last < n - 1) {
int v = find(0, 0, n - 1, last + 1, n - 1);
if (v == -1) break;
last = v;
if (ms.find({u, v}) != ms.end()) continue;
res += dfs(v);
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
ms.insert({u - 1, v - 1});
ms.insert({v - 1, u - 1});
}
vector<int> ans;
for (int i = 0; i < n; ++i) {
if (!get(0, 0, n - 1, i)) {
ans.push_back(dfs(i));
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (int elem : ans) cout << elem << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 2e5 + 10;
int n, m;
queue<int> q;
vector<int> sol, u[MaxN], v[MaxN];
set<int> x;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) x.insert(i);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
u[--a].push_back(--b);
u[b].push_back(a);
}
int cnt;
while (x.size()) {
cnt = 0;
q.push(*x.begin());
x.erase(x.begin());
while (!q.empty()) {
int a = q.front();
q.pop();
cnt++;
for (int b : u[a]) {
if (x.find(b) != x.end()) {
x.erase(b);
v[a].push_back(b);
}
}
for (auto b : x) q.push(b);
x.clear();
for (int b : v[a]) x.insert(b);
}
sol.push_back(cnt);
}
sort(sol.begin(), sol.end());
cout << sol.size() << "\n";
for (int i : sol) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, bool> mp;
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[pair<int, int>(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[pair<int, int>(u, v)] = 1;
mp[pair<int, int>(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;
const int maxn = 200005;
map<int, int> mp[maxn];
int n, m;
set<int> s;
vector<int> ans;
queue<int> q;
queue<int> del;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; ++i) mp[i].clear();
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
mp[u][v] = 1;
mp[v][u] = 1;
}
for (int i = 1; i <= n; ++i) {
s.insert(i);
}
ans.clear();
while (!s.empty()) {
int u = *(s.begin());
s.erase(u);
int res = 1;
while (!q.empty()) q.pop();
q.push(u);
while (!q.empty()) {
int x = q.front();
q.pop();
while (!del.empty()) del.pop();
for (auto &y : s) {
if (mp[x][y] == 0) {
q.push(y);
del.push(y);
res++;
}
}
while (!del.empty()) {
int y = del.front();
del.pop();
s.erase(y);
}
}
ans.push_back(res);
}
sort(ans.begin(), ans.end());
int len = ans.size();
cout << len << '\n';
for (int i = 0; i < len; ++i) {
cout << ans[i];
if (i == len - 1)
cout << '\n';
else
cout << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int n1, n2;
bool marc[200010];
vector<int> ans;
set<int> unvisited;
set<int>::iterator it;
set<pair<int, int> > blocked;
queue<int> q;
void add(int i, int& sz) {
marc[i] = true;
sz++;
q.push(i);
}
int BFS(int i) {
int sz = 0;
add(i, sz);
unvisited.erase(i);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (it = unvisited.begin(); it != unvisited.end();) {
int prox = *it;
if (marc[prox])
it++;
else if (blocked.find({cur, prox}) != blocked.end())
it++;
else {
add(prox, sz);
it = unvisited.erase(it);
}
}
}
return sz;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &n1, &n2);
blocked.insert({n1, n2});
blocked.insert({n2, n1});
}
for (int i = 1; i <= n; i++) unvisited.insert(i);
for (int i = 1; i <= n; i++)
if (!marc[i]) ans.push_back(BFS(i));
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
vector<int> g[maxn];
int din[maxn], root[maxn], n, m;
bool vis[maxn], st[maxn];
int res[maxn], siz[maxn];
int Find(int x) {
if (x != root[x]) root[x] = Find(root[x]);
return root[x];
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) root[i] = i;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
din[u]++;
din[v]++;
}
int minn = 0x3f3f3f3f, pos = -1;
for (int i = 1; i <= n; i++)
if (din[i] < minn) {
minn = din[i];
pos = i;
}
for (int i = 0; i < g[pos].size(); i++) {
int x = g[pos][i];
vis[x] = 1;
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
root[i] = pos;
}
for (int i = 1; i <= n; i++) {
if (!vis[i] || i == pos) {
continue;
}
memset(st, 0, sizeof st);
for (int j = 0; j < g[i].size(); j++) {
int x = g[i][j];
st[x] = 1;
}
for (int j = 1; j <= n; j++)
if (!st[j]) {
root[Find(j)] = Find(i);
}
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (i == Find(i)) res[i] = ++cnt;
for (int i = 1; i <= n; i++) siz[res[Find(i)]]++;
sort(siz + 1, siz + 1 + cnt);
cout << cnt << endl;
for (int i = 1; i <= cnt; i++) cout << siz[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 10;
struct DSU {
long long n = MAXN;
long long parent[MAXN], rank[MAXN];
DSU() {
for (long long i = 0; i < n; i++) {
parent[i] = i;
rank[i] = 1;
}
}
long long gp(long long v) {
if (v == parent[v]) return v;
return parent[v] = gp(parent[v]);
}
bool merge(long long a, long long b) {
a = gp(a), b = gp(b);
if (a == b) return true;
if (rank[a] < rank[b]) swap(a, b);
parent[b] = parent[a];
rank[a] += rank[b];
return true;
}
} dsu;
vector<long long> g[MAXN];
int32_t main() {
ios ::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long f, s;
cin >> f >> s;
f--, s--;
g[f].push_back(s);
g[s].push_back(f);
}
for (long long i = 0; i < n; i++) sort(g[i].begin(), g[i].end());
set<long long> s;
for (long long i = 0; i < n; i++) {
map<long long, long long> mp;
for (auto j : g[i]) {
if (j >= i) break;
mp[dsu.gp(j)]++;
}
vector<long long> temp;
for (auto j : s) {
if (dsu.rank[dsu.gp(j)] > mp[dsu.gp(j)]) {
dsu.merge(j, i);
temp.push_back(j);
}
}
for (auto j : temp) s.erase(j);
s.insert(i);
}
cout << s.size() << '\n';
vector<long long> ans;
for (auto i : s) ans.push_back(dsu.rank[dsu.gp(i)]);
sort(ans.begin(), ans.end());
for (auto i : ans) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
char c;
bool nega = 0;
while ((!isdigit(c = getchar())) && (c != '-'))
;
if (c == '-') {
nega = 1;
c = getchar();
}
x = c - 48;
while (isdigit(c = getchar())) x = x * 10 + c - 48;
if (nega) x = -x;
}
template <typename T>
inline void writep(T x) {
if (x > 9) writep(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
writep(x);
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
vector<int> g[200001];
vector<int> h[200001];
bool done[200001];
int n, m;
int r[200001];
int root(int u) {
if (r[u] < 0) return u;
return r[u] = root(r[u]);
}
void uni(int u, int v) {
u = root(u);
v = root(v);
if (u == v) return;
h[u].push_back(v);
h[v].push_back(u);
r[u] += r[v];
r[v] = u;
}
vector<int> good;
vector<int> boss;
set<int> s;
int dfstime[200001];
vector<int> ans;
int ntime;
bool dfs(int u, int a) {
if (s.find(u) == s.end()) {
uni(u, a);
return 1;
}
dfstime[u] = ntime;
for (int v : h[u])
if (dfstime[v] != ntime)
if (dfs(v, a)) return 1;
return 0;
}
int main() {
read(n);
read(m);
for (int i = (1); i <= (n); i++) {
r[i] = -1;
good.push_back(i);
}
{
int u, v;
for (int i = (1); i <= (m); i++) {
read(u);
read(v);
g[u].push_back(v);
g[v].push_back(u);
}
}
sort(good.begin(), good.end(),
[](int a, int b) { return (g[a].size()) < (g[b].size()); });
boss.push_back(good[0]);
done[good[0]] = 1;
for (int v : g[boss.back()]) s.insert(v);
for (int i = (1); i <= (n); i++)
if (s.find(i) == s.end()) {
uni(boss.back(), i);
done[i] = 1;
}
for (int u : good) {
if (done[u]) continue;
s.clear();
for (int v : g[u]) s.insert(v);
for (int v : boss) {
int a = root(v);
if ((-r[a]) > ((int)g[u].size())) {
uni(u, v);
done[u] = 1;
} else {
ntime++;
if (dfs(v, u)) done[u] = 1;
}
}
if (!done[u]) {
boss.push_back(u);
for (int i = (1); i <= (n); i++)
if (s.find(i) == s.end()) {
uni(boss.back(), i);
}
}
}
s.clear();
for (int i : boss)
if (s.find(root(i)) == s.end()) {
s.insert(root(i));
ans.push_back(-r[root(i)]);
}
sort(ans.begin(), ans.end());
writeln(ans.size());
for (int x : ans) write(x), putchar(' ');
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int P = 1000000007;
const long long mod = P;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const long double eps = 1e-8;
long long qmod(long long a, long long n, long long mod) {
long long ans = 1;
while (n) {
assert(ans > 0);
if (n & 1ll) ans = ans * a % mod;
n >>= 1;
a = a * a % mod;
}
return ans % mod;
}
map<int, bool> e[200005];
int n, m;
vector<int> Map, ans;
int bfs(int v) {
queue<int> q;
while (!q.empty()) q.pop();
q.push(v);
int cnt = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
++cnt;
for (int i = 0; i < Map.size(); ++i) {
v = Map[i];
if (!e[u][v]) {
swap(Map[i], Map.back());
Map.pop_back();
--i;
q.push(v);
}
}
}
return cnt;
}
void solve() {
Map.clear();
ans.clear();
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i) Map.push_back(i), e[i].clear();
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
e[u][v] = e[v][u] = true;
}
while (!Map.empty()) {
int v = Map.back();
Map.pop_back();
int x = bfs(v);
if (x) ans.push_back(x);
}
sort(ans.begin(), ans.end());
printf("%d\n", ((int)(ans).size()));
for (int i = 0; i < ans.size(); ++i)
printf("%d%c", ans[i], " \n"[i == ((int)(ans).size()) - 1]);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 1e9 + 7;
const double EPS = 1e-9;
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const int N = 1e6 + 1000;
const int maxn = 2e5 + 100;
using namespace std;
inline void time() { cerr << (clock() * 1.0 / CLOCKS_PER_SEC * 1.0); }
set<int> st;
vector<int> res;
map<pair<int, int>, int> mp;
int n, m, c[maxn], t = 0;
void dfs(int u) {
t++;
st.erase(u);
vector<int> nw;
for (auto it : st) {
int v = it;
if (mp[make_pair(u, v)] == 1) continue;
nw.push_back(v);
}
for (auto it : nw) st.erase(it);
for (auto it : nw) dfs(it);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
mp[make_pair(u, v)] = 1;
mp[make_pair(v, u)] = 1;
}
for (int i = 1; i <= n; i++) {
st.insert(i);
}
for (int i = 1; i <= n; i++) {
if (st.find(i) != st.end()) {
t = 0;
dfs(i);
res.push_back(t);
}
}
sort(res.begin(), res.end());
cout << res.size() << "\n";
for (int i : res) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
set<int> g[N];
set<int> unused;
int size[N];
int cnt;
void dfs(int x) {
unused.erase(x);
++size[cnt];
int curr = -1;
while (1) {
auto it = unused.upper_bound(curr);
if (it == unused.end()) {
break;
}
curr = *it;
if (g[x].count(curr)) {
continue;
}
dfs(curr);
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
while (m--) {
int x, y;
scanf("%d %d", &x, &y);
g[x].insert(y);
g[y].insert(x);
}
for (int i = 1; i <= n; ++i) {
unused.insert(i);
}
for (int i = 1; i <= n; ++i) {
if (unused.count(i)) {
++cnt;
dfs(i);
}
}
printf("%d\n", cnt);
sort(size + 1, size + cnt + 1);
for (int i = 1; i <= cnt; ++i) {
printf("%d ", size[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
set<int> remaining;
set<pair<int, int>> edges;
int size = 0;
void dfs(int k) {
size++;
vector<int> temp;
for (auto it : remaining) {
if (it > k && edges.find(make_pair(k, it)) == edges.end()) {
temp.push_back(it);
} else if (it < k && edges.find(make_pair(it, k)) == edges.end()) {
temp.push_back(it);
}
}
for (auto it : temp) remaining.erase(it);
for (auto it : temp) dfs(it);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> sizes;
for (int i = 1; i <= n; i++) remaining.insert(i);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
if (x > y) swap(x, y);
edges.insert(make_pair(x, y));
}
for (int i = 1; i <= n; i++) {
if (remaining.find(i) != remaining.end()) {
remaining.erase(i);
size = 0;
dfs(i);
sizes.push_back(size);
}
}
sort(sizes.begin(), sizes.end());
cout << sizes.size() << "\n";
for (auto it : sizes) cout << it << " ";
cout << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 2e5 + 7;
int n, m;
vector<int> v;
set<int> ostali;
set<int> adj[NMAX];
int dfs(int v) {
int res = 1;
vector<int> zivi;
for (int idi : ostali)
if (!adj[v].count(idi)) zivi.push_back(idi);
for (int i : zivi) ostali.erase(i);
for (int i : zivi) res += dfs(i);
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
adj[x].insert(y);
adj[y].insert(x);
}
for (int i = 1; i <= n; i++) ostali.insert(i);
for (int i = 1; i <= n; i++) {
if (ostali.count(i)) {
ostali.erase(i);
v.push_back(dfs(i));
}
}
sort(v.begin(), v.end());
cout << v.size() << endl;
for (int i : v) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, bool> mp[200007];
set<int> st;
vector<int> ans2;
int main() {
int n, m, i, j, k, x, y;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
mp[x][y] = 1;
mp[y][x] = 1;
}
st.clear();
for (i = 1; i <= n; i++) {
st.insert(i);
}
set<int>::iterator it;
while (!st.empty()) {
vector<int> ans;
it = st.begin();
st.erase(it);
queue<int> q;
while (!q.empty()) q.pop();
q.push(*it);
ans.push_back(*it);
while (!q.empty()) {
x = q.front();
q.pop();
for (it = st.begin(); it != st.end();) {
if (!mp[x][*it]) {
ans.push_back(*it);
q.push(*it);
st.erase(it++);
} else
it++;
}
}
ans2.push_back(ans.size());
}
printf("%d\n", ans2.size());
sort(ans2.begin(), ans2.end());
for (i = 0; i < ans2.size(); i++) {
if (i > 0) printf(" ");
printf("%d", ans2[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void optimise() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int mod = 1e9 + 7;
void normalize(int &a) { a = (a + mod) % mod; }
int modmul(int a, int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a * b) % mod;
}
int modadd(int a, int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a + b) % mod;
}
int modsub(int a, int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a - b + mod) % mod;
}
int me(int x, int n) {
x %= mod;
if (n == 0) return 1;
int u = me(x, n / 2) % mod;
u = (u * u) % mod;
if (n % 2) u = (u * x) % mod;
return u;
}
int me1(int x, int n) {
if (n == 0) return 1;
int u = me1(x, n / 2);
u = u * u;
if (n % 2) u = u * x;
return u;
}
inline int modInv(int a) { return me(a, mod - 2); }
inline int modDiv(int a, int b) { return modmul(a, modInv(b)); }
int __gcd(int a, int b) {
if (b == 0)
return a;
else
return __gcd(b, a % b);
}
void solve() {
int n;
cin >> n;
int vis[n + 1];
memset(vis, 0, sizeof(vis));
set<int> G[n + 1];
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
G[x].insert(y);
G[y].insert(x);
}
set<int> v;
for (int i = 1; i <= n; i++) {
v.insert(i);
}
vector<int> ans1;
while (v.size() > 0) {
auto k1 = *v.begin();
queue<int> q;
q.push(k1);
v.erase(k1);
int ans = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
vector<int> v1;
for (auto y : v) {
if (G[u].find(y) == G[u].end()) {
v1.push_back(y);
q.push(y);
ans++;
}
}
for (auto y : v1) {
v.erase(y);
}
}
ans1.push_back(ans);
}
cout << ans1.size() << "\n";
sort(ans1.begin(), ans1.end());
for (auto y : ans1) cout << y << " ";
}
signed main() {
optimise();
int t;
t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
int n, m, x, y, c;
vector<int> ans;
set<int> s;
map<int, int> g[N];
void dfs(int x) {
queue<int> q;
c = 0;
q.push(x);
while (q.size()) {
int u = q.front();
c++;
q.pop();
vector<int> o;
for (auto v : s)
if (!g[u][v]) {
q.push(v);
o.push_back(v);
}
for (int i = 0; i < o.size(); i++) s.erase(o[i]);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
g[x][y] = 1;
g[y][x] = 1;
}
for (int i = 0; i < n; i++) s.insert(i + 1);
while (s.size()) {
x = *s.begin();
s.erase(x);
dfs(x);
ans.push_back(c);
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, m;
vector<int> adl[N];
unordered_map<int, bool> gak[N];
int par[N], sz[N];
vector<int> uni[N];
int find(int a) {
if (par[a] == a) return a;
return par[a] = find(par[a]);
}
void make(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
sz[a] += sz[b];
par[b] = a;
for (auto x : uni[b]) {
uni[a].push_back(x);
}
}
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 a, b;
cin >> a >> b;
gak[a][b] = 1;
gak[b][a] = 1;
}
for (int i = 1; i <= n; i++) {
par[i] = i;
sz[i] = 1;
uni[i].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (par[i] == i && sz[i] == 1) {
int cur = i;
for (int j = i + 1; j <= n; j++) {
bool bisa = 0;
for (auto x : uni[cur]) {
if (!gak[x][j]) {
bisa = 1;
break;
}
}
if (bisa) make(cur, j);
cur = find(cur);
}
}
}
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (par[i] == i) ans.push_back(sz[i]);
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (auto x : ans) {
cout << x << " ";
}
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 200010;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m;
cin >> n >> m;
vector<long long int> adj[n + 1];
for (long long int i = 0; i < m; ++i) {
long long int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (long long int i = 1; i <= n; ++i) {
sort(adj[i].begin(), adj[i].end());
}
vector<long long int> ans;
set<long long int> left;
for (long long int i = 1; i <= n; ++i) {
left.insert(i);
}
while (!left.empty()) {
long long int v = *left.begin();
left.erase(left.begin());
long long int count = 0;
queue<long long int> buffer;
buffer.push(v);
while (!buffer.empty()) {
++count;
v = buffer.front();
buffer.pop();
set<long long int> newcandidates;
for (auto u : adj[v]) {
if (left.find(u) != left.end()) {
newcandidates.insert(u);
left.erase(u);
}
}
for (auto u : left) {
buffer.push(u);
}
left = newcandidates;
}
ans.push_back(count);
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (long long int i = 0; i < ans.size(); ++i) {
cout << ans[i] << " ";
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 7;
int n, m;
set<int> s, a[MX];
vector<int> ans;
int dfs(int x) {
int sz = 1;
for (set<int>::iterator it = s.begin(); it != s.end();) {
if (a[x].count(*it) == 0) {
int nw = *it;
s.erase(nw);
sz += dfs(nw);
it = s.lower_bound(nw);
} else {
it++;
}
}
return sz;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x].insert(y);
a[y].insert(x);
}
for (int i = 1; i <= n; i++) s.insert(i);
while (s.size()) {
int nw = *s.begin();
s.erase(nw);
ans.push_back(dfs(nw));
}
printf("%d\n", ans.size());
sort(ans.begin(), ans.end());
for (auto x : ans) printf("%d ", x);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse4")
#pragma GCC optimize("unroll-loops")
using namespace std;
int bit[200005], n, sz;
set<int> adj[200005];
void update(int p) {
for (int i = p; i <= n; i += i & (-i)) bit[i]++;
}
int query(int p) {
int s = 0;
for (int i = p; i; i -= i & (-i)) s += bit[i];
return s;
}
int range_query(int i, int j) { return query(j) - query(i - 1); }
void dfs(int u) {
int low, mid, high, pre = 0;
update(u);
sz++;
for (auto x : adj[u]) {
while (1) {
low = pre + 1, high = x - 1;
while (low <= high) {
mid = (low + high) >> 1;
if (range_query(pre + 1, mid) == mid - pre)
low = mid + 1;
else
high = mid - 1;
}
if (low < x)
dfs(low);
else
break;
}
pre = x;
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int m, i, u, v;
vector<int> res;
cin >> n >> m;
while (m--) {
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
}
for (i = 1; i <= n; i++) adj[i].insert(n + 1);
for (i = 1; i <= n; i++)
if (!range_query(i, i)) {
sz = 0;
dfs(i);
res.push_back(sz);
}
cout << (int)res.size() << '\n';
sort((res).begin(), (res).end());
for (auto x : res) cout << x << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m, u, v;
bool vis[maxn];
set<int> path[maxn];
int prv[maxn], nxt[maxn];
int sz[maxn], tot;
void eras(int p) {
prv[nxt[p]] = prv[p];
nxt[prv[p]] = nxt[p];
return;
}
void bfs(int p) {
queue<int> q;
q.push(p);
sz[tot] = 1;
eras(p);
vis[p] = true;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i = nxt[0]; i <= n; i = nxt[i]) {
if (!path[cur].count(i)) {
q.push(i);
sz[tot]++;
vis[i] = true;
eras(i);
}
}
}
return;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
path[u].insert(v);
path[v].insert(u);
}
for (int i = 0; i <= n; i++) {
prv[i] = i - 1;
nxt[i] = i + 1;
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
tot++;
sz[tot] = 0;
bfs(i);
}
}
sort(sz + 1, sz + tot + 1);
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) printf("%d ", sz[i]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const long long INF = 1e9;
int n, m;
vector<int> ar[MAXN];
int marc[MAXN];
long long seg[4 * MAXN], id[4 * MAXN], lz[4 * MAXN];
vector<int> ans;
void refresh(int pos, int ini, int fim);
void build(int pos, int ini, int fim);
void update(int pos, int ini, int fim, int p, int q, long long val);
int bb(int pos, int ini, int fim);
void getComp(int cur);
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
ar[a].push_back(b);
ar[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
if (marc[i]) continue;
getComp(i);
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
printf("\n");
}
void refresh(int pos, int ini, int fim) {
if (lz[pos] == 0) return;
seg[pos] += lz[pos];
if (ini != fim) {
int e = pos << 1, d = e | 1;
lz[e] += lz[pos];
lz[d] += lz[pos];
}
lz[pos] = 0;
}
void build(int pos, int ini, int fim) {
if (ini == fim) {
if (marc[ini])
seg[pos] = 3 * INF;
else
seg[pos] = -INF;
id[pos] = ini;
lz[pos] = 0;
return;
}
int mid = (ini + fim) >> 1, e = pos << 1, d = e | 1;
build(e, ini, mid);
build(d, mid + 1, fim);
if (seg[e] <= seg[d])
seg[pos] = seg[e], id[pos] = id[e];
else
seg[pos] = seg[d], id[pos] = id[d];
lz[pos] = 0;
}
void update(int pos, int ini, int fim, int p, int q, long long val) {
refresh(pos, ini, fim);
if (ini > q || fim < p) return;
if (ini >= p && fim <= q) {
lz[pos] += val;
refresh(pos, ini, fim);
return;
}
int mid = (ini + fim) >> 1, e = pos << 1, d = e | 1;
update(e, ini, mid, p, q, val);
update(d, mid + 1, fim, p, q, val);
if (seg[e] <= seg[d])
seg[pos] = seg[e], id[pos] = id[e];
else
seg[pos] = seg[d], id[pos] = id[d];
lz[pos] = 0;
}
void getComp(int cur) {
marc[cur] = 1;
build(1, 1, n);
for (int i = 0; i < ar[cur].size(); i++)
update(1, 1, n, ar[cur][i], ar[cur][i], INF + 1);
int cnt = 1;
while (1) {
if (seg[1] > 0) break;
int viz = id[1];
cnt++;
marc[viz] = 1;
for (int i = 0; i < ar[viz].size(); i++)
update(1, 1, n, ar[viz][i], ar[viz][i], 1);
update(1, 1, n, 1, n, -1);
update(1, 1, n, viz, viz, 3 * INF);
}
ans.push_back(cnt);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = ~(1 << 31);
const int NINF = 1 << 31;
const int N = 2e5 + 5;
int res[N];
int n, m, cnt;
set<int> e[N];
set<int> s;
void dfs(int first) {
int second;
s.erase(first), res[cnt]++;
for (auto it = s.begin(); it != s.end(); it = s.upper_bound(second)) {
second = *it;
if (!e[first].count(*it)) dfs(second);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int T;
while (cin >> n >> m) {
s.clear();
for (int i = (1); i <= (n); ++i) s.insert(i);
for (int i = (1); i <= (m); ++i) {
int first, second;
cin >> first >> second;
e[first].insert(second), e[second].insert(first);
}
cnt = 0;
for (int i = (1); i <= (n); ++i) {
if (s.count(i)) {
dfs(i), ++cnt;
}
}
sort(res, res + cnt);
cout << cnt << '\n';
for (int i = (0); i <= (cnt - 1); ++i) {
cout << res[i];
if (i == cnt - 1)
cout << '\n';
else
cout << ' ';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 202000;
set<int> s;
set<int>::iterator it;
int edg[N];
vector<int> g[N];
int ans[N];
int cur = 1;
int vis[N];
void dfs(int node) {
vis[node] = 1;
ans[cur]++;
vector<int> send;
for (it = s.begin(); it != s.end();) {
if (!binary_search(g[node].begin(), g[node].end(), *it)) {
send.push_back(*it);
s.erase(it++);
} else
it++;
}
for (int el : send) dfs(el);
}
int main() {
int n, e;
scanf("%d%d", &n, &e);
for (int i = 1; i <= n; ++i) s.insert(i);
for (int i = 0; i < e; ++i) {
int temp, temp1;
scanf("%d%d", &temp, &temp1);
edg[temp]++;
edg[temp1]++;
g[temp].push_back(temp1);
g[temp1].push_back(temp);
}
vector<pair<int, int>> go;
for (int i = 1; i <= n; i++) {
go.push_back(make_pair(edg[i], i));
sort(g[i].begin(), g[i].end());
}
sort(go.begin(), go.end());
for (auto el : go) {
if (vis[el.second]) continue;
s.erase(el.second);
ans[0]++;
dfs(el.second);
cur++;
}
cout << ans[0] << "\n";
sort(ans + 1, ans + ans[0] + 1);
for (int i = 1; i <= ans[0]; i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 2;
int siz[N], par[N];
void make_set(int x) {
siz[x] = 1;
par[x] = x;
}
int find_set(int x) {
if (x == par[x]) return x;
return par[x] = find_set(par[x]);
}
void union_sets(int x, int y) {
x = find_set(x);
y = find_set(y);
if (x != y) {
if (siz[x] > siz[y]) swap(x, y);
siz[y] += siz[x];
par[x] = y;
}
}
int n, m;
bool vis[N];
vector<int> g[N];
void dfs(int x) {
vis[find_set(x)] = 1;
for (int i = 0, j = 1; j <= n; j = g[x][i++] + 1) {
while (j < g[x][i]) {
if (!vis[find_set(j)]) dfs(j);
union_sets(x, find_set(j++));
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
while (m--) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
vector<int> z, o;
for (int i = 1; i <= n; make_set(i++)) {
if (g[i].size() < (n + 1) >> 1)
z.push_back(i);
else
o.push_back(i);
sort(g[i].begin(), g[i].end());
g[i].push_back(n + 1);
}
for (int i = 1; i < z.size(); ++i) union_sets(z[i], z[i - 1]);
for (int &i : o)
if (!vis[find_set(i)]) dfs(i);
vector<int> ans;
map<int, bool> done;
for (int i = 1; i <= n; ++i) done[find_set(i)] = 1;
cout << done.size() << '\n';
for (auto &i : done) ans.push_back(siz[i.first]);
sort(ans.begin(), ans.end());
for (int &i : ans) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int cnt, n, m;
unordered_map<long long int, set<long long int>> forbidden;
set<long long int> not_vis;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
forbidden[min(u, v)].insert(max(u, v));
}
for (long long int i = 1; i <= n; i++) not_vis.insert(i);
vector<long long int> ans;
auto bfs = [&](long long int s) {
queue<long long int> q;
q.push(s);
not_vis.erase(s);
cnt++;
while (!q.empty()) {
long long int u = q.front();
q.pop();
vector<long long int> aux;
for (auto v : not_vis) {
if (forbidden[min(u, v)].count(max(u, v)) == 0) {
q.push(v);
aux.push_back(v);
}
}
for (auto x : aux) {
not_vis.erase(x);
cnt++;
}
}
};
for (long long int i = 1; i <= n; i++) {
if (not_vis.count(i)) {
cnt = 0;
bfs(i);
ans.push_back(cnt);
}
}
cout << ans.size() << '\n';
sort(ans.begin(), ans.end());
for (auto x : ans) cout << x << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 6;
set<int> unvisited;
set<int> g[MAX];
int sz;
void dfs(int u) {
unvisited.erase(u);
int cur = 0;
sz++;
while (1) {
auto it = unvisited.upper_bound(cur);
if (it == unvisited.end()) break;
cur = *it;
if (g[u].count(cur)) continue;
dfs(cur);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[u].insert(v), g[v].insert(u);
}
for (int i = 1; i <= n; i++) unvisited.insert(i);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (unvisited.count(i)) {
dfs(i);
ans.push_back(sz);
sz = 0;
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (int x : ans) cout << x << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
const int mod = 1e9 + 7;
const int MXM = 200090;
set<int> st;
set<pair<int, int>> non_edges;
bool vis[MXM];
int par[MXM];
int sz[MXM];
int find(int x) {
if (par[x] == x) return x;
par[x] = find(par[x]);
return par[x];
}
bool same(int x, int y) {
if (find(x) == find(y)) return true;
return false;
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (sz[x] < sz[y]) swap(x, y);
sz[x] += sz[y];
par[y] = x;
}
void dfs_complemented(int node) {
vector<int> v;
vis[node] = true;
for (auto it : st) {
if (non_edges.find({it, node}) != non_edges.end()) continue;
v.push_back(it);
}
for (auto it : v) {
st.erase(it);
unite(it, node);
}
for (auto it : v) dfs_complemented(it);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t, n, i, j, k, len, x, y, z, c, f, flag, p, q, mx, mn, l, r, sum, ans,
tmp, it, pos, avg, m, cnt;
string s;
char ch;
vector<int> v;
vector<pair<int, int>> vec;
unordered_map<int, int> mappu;
pair<int, int> pr;
t = 1;
{
f = 0;
sum = 0;
flag = 0;
ans = 0;
cnt = 0;
v.clear();
mappu.clear();
vec.clear();
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> l >> r;
non_edges.insert({l, r});
non_edges.insert({r, l});
}
for (i = 1; i <= n; i++) {
st.insert(i);
par[i] = i;
sz[i] = 1;
}
ans = 0;
vector<int> components;
for (i = 1; i <= n; i++) {
if (vis[i] == false) {
ans++;
dfs_complemented(i);
components.push_back(sz[find(i)]);
}
}
sort(components.begin(), components.end());
cout << ans << "\n";
{
for (auto dsp : components) cout << dsp << " ";
cout << "\n";
};
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 1 << 18;
int V, E;
set<int> S[MAXV], A;
bool m[MAXV];
multiset<int> ans;
queue<int> Q;
void push(int u) {
Q.push(u);
m[u] = 1;
A.erase(u);
}
int main() {
cin >> V >> E;
for (int i = 0; i < E; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
S[u].insert(v);
S[v].insert(u);
}
for (int i = 0; i < V; ++i) A.insert(i);
for (int u = 0; u < V; ++u)
if (!m[u]) {
int cnt = 0;
for (push(u); !Q.empty(); Q.pop()) {
cnt++;
int v = Q.front();
for (auto i = A.begin(); i != A.end();)
if (!S[v].count(*i))
push(*(i++));
else
++i;
}
ans.insert(cnt);
}
printf("%d\n", (int)ans.size());
for (int a : ans) printf("%d ", a);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
map<int, int> mp[maxn];
int n, m, pre;
int rec[maxn], ans[maxn];
set<int> st;
int main(int argc, char** argv) {
scanf("%d%d", &n, &m);
int u, v;
for (int i = 1; i <= n; i++) {
st.insert(i);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
mp[u][v] = 1;
mp[v][u] = 1;
}
int sum, cnt;
sum = cnt = 0;
while (n - sum) {
queue<int> que;
if (!st.empty()) {
sum++;
que.push(*st.begin());
st.erase(st.begin());
}
while (!que.empty()) {
v = que.front();
que.pop();
for (set<int>::iterator it = st.begin(); it != st.end();) {
if (!mp[v][*it]) {
que.push(*it);
st.erase(it++);
sum++;
} else {
it++;
}
}
}
int tmp = sum - pre;
pre = sum;
if (tmp) {
ans[++cnt] = tmp;
}
}
sort(ans + 1, ans + 1 + cnt);
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) {
printf("%d ", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 6;
int parent[MAX], sz[MAX], deg[MAX], rnk[MAX];
set<int> gt[MAX];
vector<int> g[MAX];
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int u, int v) {
u = find_set(u), v = find_set(v);
if (u != v) {
if (rnk[u] < rnk[v]) swap(u, v);
parent[v] = u;
sz[u] += sz[v];
if (rnk[u] == rnk[v]) rnk[u]++;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
parent[i] = i, sz[i] = 1, rnk[i] = 0, deg[i] = n - 1;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
deg[x]--, deg[y]--;
gt[x].insert(y), gt[y].insert(x);
}
int prev = -1;
for (int i = 1; i <= n; i++) {
if (deg[i] >= n / 2) {
if (prev == -1) {
prev = i;
} else {
union_sets(i, prev);
prev = i;
}
} else {
for (int j = 1; j <= n; j++) {
if (!gt[i].count(j)) g[i].push_back(j), g[j].push_back(i);
}
}
}
for (int i = 1; i <= n; i++) {
for (int x : g[i]) union_sets(i, x);
}
set<int> comp;
vector<int> ans;
for (int i = 1; i <= n; i++) comp.insert(find_set(i));
for (auto x : comp) ans.push_back(sz[x]);
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (int x : ans) cout << x << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n % 2 == 1) {
res = res * x;
}
x = x * x;
n = n / 2;
}
return res;
}
long long int powm(long long int a, long long int b) {
long long int res = 1;
a %= 1000000007;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
set<int> unvis;
set<int> g[200005];
int sz = 0;
void dfs(int s) {
if (unvis.find(s) != unvis.end()) {
unvis.erase(s);
sz++;
}
vector<int> v;
for (auto x : unvis) {
if (g[s].find(x) == g[s].end()) {
v.push_back(x);
}
}
for (int i = 0; i < v.size(); i++) {
unvis.erase(v[i]);
sz++;
}
for (int i = 0; i < v.size(); i++) dfs(v[i]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int T = 1;
while (T--) {
int n, m, i, j;
cin >> n >> m;
for (i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].insert(v);
g[v].insert(u);
}
for (i = 1; i <= n; i++) {
unvis.insert(i);
}
vector<int> v;
for (i = 1; i <= n; i++) {
if (unvis.find(i) != unvis.end()) {
sz = 0;
dfs(i);
v.push_back(sz);
}
}
sort(v.begin(), v.end());
cout << v.size() << "\n";
for (i = 0; i < v.size(); i++) cout << v[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 10;
vector<int> inpoints, size;
bool ina[N];
int n, m, fa[N], sz[N], deg[N], a, mina, cnt[N], tot;
set<pair<int, int> > edgesa;
pair<int, int> edges[N];
int find(int u) { return fa[u] == u ? u : fa[u] = find(fa[u]); }
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> edges[i].first >> edges[i].second;
deg[edges[i].first]++;
deg[edges[i].second]++;
}
mina = N;
for (int i = 1; i <= n; i++)
if (deg[i] < mina) {
mina = deg[i];
a = i;
}
for (int i = 0; i < m; i++)
if (a == edges[i].first) {
ina[edges[i].second] = true;
inpoints.push_back(edges[i].second);
tot++;
} else if (a == edges[i].second) {
ina[edges[i].first] = true;
inpoints.push_back(edges[i].first);
tot++;
}
for (int i = 1; i <= n; i++)
if (!ina[i]) {
fa[i] = a;
sz[a]++;
}
for (int i = 0; i < m; i++) {
if (ina[edges[i].first] && !ina[edges[i].second])
cnt[edges[i].first]++;
else if (!ina[edges[i].first] && ina[edges[i].second])
cnt[edges[i].second]++;
else if (ina[edges[i].first] && ina[edges[i].second])
edgesa.insert(edges[i]);
}
for (int u : inpoints) {
if (cnt[u] < n - tot) {
fa[u] = a;
sz[a]++;
} else {
fa[u] = u;
sz[u] = 1;
}
}
for (int i = 0; i < inpoints.size(); i++)
for (int j = i + 1; j < inpoints.size(); j++)
if (!edgesa.count(pair<int, int>(inpoints[i], inpoints[j])) &&
!edgesa.count(pair<int, int>(inpoints[j], inpoints[i]))) {
int u = find(inpoints[i]), v = find(inpoints[j]);
if (u != v) {
fa[u] = v;
sz[v] += sz[u];
}
}
for (int i = 1; i <= n; i++)
if (fa[i] == i) size.push_back(sz[i]);
cout << size.size() << '\n';
sort(size.begin(), size.end());
cout << size[0];
for (int i = 1; i < size.size(); i++) cout << ' ' << size[i];
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, x, y, ans[200005], cnt, nxt[200005], pre[200005], visits[200005];
vector<int> V[200005];
void erase(int p) {
nxt[pre[p]] = nxt[p];
pre[nxt[p]] = pre[p];
}
void solve(int x) {
queue<int> q;
q.push(x);
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = 0; i < V[now].size(); i++) {
visits[V[now][i]] = 1;
}
for (int i = nxt[0]; i <= N; i = nxt[i]) {
if (visits[i] == 0) {
erase(i);
ans[cnt]++;
q.push(i);
}
}
for (int i = 0; i < V[now].size(); i++) {
visits[V[now][i]] = 0;
}
}
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i <= N; i++) {
nxt[i] = i + 1;
}
for (int i = 1; i <= N; i++) {
pre[i] = i - 1;
}
for (int i = 0; i < M; i++) {
scanf("%d%d", &x, &y);
V[x].push_back(y);
V[y].push_back(x);
}
for (int i = nxt[0]; i <= N; i = nxt[0]) {
erase(i);
ans[++cnt] = 1;
solve(i);
}
printf("%d\n", cnt);
sort(ans + 1, ans + cnt + 1);
for (int i = 1; i <= cnt; i++) {
printf("%d ", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long OO = 1e8;
const long long OOL = 1e16;
const long long MOD = 1e9 + 7;
const double EPS = 1e-9;
unsigned long long gcd(unsigned long long a, unsigned long long b) {
return (b == 0 ? a : gcd(b, a % b));
}
unsigned long long lcm(unsigned long long a, unsigned long long b) {
return (a * (b / gcd(a, b)));
}
long long N, K;
set<int> s;
void printVec(vector<long long> v2) {
for (int i = 0; i < (int)v2.size(); ++i) cout << v2[i] << " ";
cout << endl;
}
long long M;
map<pair<int, int>, bool> m;
bool visited[200001] = {false};
long long nb = 0;
vector<int> suppme;
void f(int i) {
if (visited[i] == true) return;
visited[i] = true;
nb++;
bool ok = false;
set<int>::iterator it1 = s.begin();
while (it1 != s.end()) {
if (*it1 != i && m[make_pair(i, *it1)] != 1 && m[make_pair(*it1, i)] != 1) {
ok = true;
int tmp = *it1;
s.erase(it1);
f(tmp);
it1 = s.upper_bound(tmp);
} else
it1++;
}
if (!ok) s.erase(i);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M;
int x, y;
memset(visited, false, 200001);
while (M--) {
cin >> x >> y;
m[make_pair(x - 1, y - 1)] = 1;
}
vector<long long> res;
for (int i = N - 1; i >= 0; i--) s.insert(i);
set<int>::iterator it = s.begin();
while (it != s.end()) {
nb = 0;
f(*it);
if (nb != 0) res.push_back(nb);
it = s.begin();
}
cout << res.size() << endl;
sort(res.begin(), res.end());
printVec(res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<long long>;
using vpi = vector<pair<ll, ll>>;
using pi = pair<ll, ll>;
const int mod = 1000000007;
set<int> adj[200000];
set<int> unvis;
int group[200000];
int cur = 0;
void dfs(int x) {
group[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 tt = 1;
while (tt--) {
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(group, group + cur);
for (int i = 0; i < cur; i++) {
cout << group[i] << ' ';
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long i = 0, j = 0, k = 0, sum = 0, res = 0, start = 0, finall = 0, mx = 0,
mini = 1000000007, len = 0, cnt1 = 0, cnt2 = 0, ans = 0, cnt3 = 0,
eend = 0, pos = 0, cnt = 0;
int flag = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
set<long long> adj[n + 1];
for (i = 1; i <= m; i++) {
long long a, b;
cin >> a >> b;
adj[a].insert(b);
adj[b].insert(a);
}
set<long long> s;
for (i = 1; i <= n; i++) {
s.insert(i);
}
vector<long long> ans;
while (!s.empty()) {
queue<long long> q;
q.push(*s.begin());
s.erase(*s.begin());
cnt = 1;
while (!q.empty()) {
long long cur = q.front();
q.pop();
vector<long long> toerase;
for (auto i : s) {
if (adj[cur].count(i)) {
continue;
} else {
q.push(i);
cnt++;
toerase.push_back(i);
}
}
for (auto it : toerase) {
s.erase(it);
}
}
ans.push_back(cnt);
}
cout << ans.size() << "\n";
sort((ans).begin(), (ans).end());
for (i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > edges;
set<int> unvis_nodes;
int n, m;
bool vis[200005];
int cnt = 0;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
edges.insert({x, y});
edges.insert({y, x});
}
for (int i = 1; i <= n; i++) unvis_nodes.insert(i);
vector<int> v;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
queue<int> q;
q.push(i);
unvis_nodes.erase(i);
while (!q.empty()) {
int node = q.front();
q.pop();
cnt++;
vector<int> del;
for (auto it : unvis_nodes) {
int n_node = it;
if (vis[n_node]) continue;
if (edges.find({node, n_node}) != edges.end()) continue;
vis[n_node] = 1;
del.push_back(n_node);
q.push(n_node);
}
for (int i = 0; i < del.size(); i++) unvis_nodes.erase(del[i]);
}
v.push_back(cnt);
cnt = 0;
}
}
sort(v.begin(), v.end());
printf("%d\n", v.size());
for (int i = 0; i < v.size(); i++) printf("%d ", v[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long long int pINF = LLONG_MAX;
const long long int nINF = -LLONG_MAX;
void fast() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
}
long long int power(long long int a, long long int b) {
long long int ans = 1;
while (b != 0) {
if (b % 2 == 1) {
ans *= a;
ans %= mod;
}
b /= 2;
a *= a;
a %= mod;
}
return ans;
}
long long int invmod(long long int a) { return pow(a, mod - 2); }
const int INF = 0x3f3f3f3f;
void print(int a[], int n) {
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
set<int> s1[200005];
set<int> s2;
vector<int> ans;
queue<int> q;
int sz = 0;
void dfs(int node) {
q.push(node);
s2.erase(s2.find(node));
while (!q.empty()) {
int t = q.front();
q.pop();
sz++;
vector<int> aux;
for (auto it = s2.begin(); it != s2.end(); it++) {
if (s1[t].find(*it) == s1[t].end()) {
q.push(*it);
aux.push_back(*it);
}
}
for (int i : aux) s2.erase(s2.find(i));
}
}
int main() {
int n, m, x, y;
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &x);
scanf("%d", &y);
s1[x].insert(y);
s1[y].insert(x);
}
for (int i = 1; i <= n; i++) s2.insert(i);
for (int i = 1; i <= n; i++) {
if (s2.find(i) != s2.end()) {
sz = 0;
dfs(i);
ans.push_back(sz);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i : ans) cout << i << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> s[200001], unused;
multiset<int> result;
int m, n, a, b;
bool visited[200001];
int dfs(int i);
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
cin >> a >> b, s[a].insert(b), s[b].insert(a);
}
for (int i = 1; i <= n; ++i) unused.insert(i);
for (int i = 1; i <= n; ++i) {
if (!visited[i]) result.insert(dfs(i));
}
cout << result.size() << "\n";
for (auto it = result.begin(); it != result.end(); ++it) cout << *it << " ";
cout << "\n";
}
int dfs(int i) {
visited[i] = true, unused.erase(i);
vector<int> v;
int c = 1;
for (auto it = unused.begin(); it != unused.end(); ++it) {
if (!s[i].count(*it)) v.push_back(*it);
}
for (int i = 0; i < v.size(); ++i) unused.erase(v[i]);
for (auto x : v)
if (!visited[x]) c += dfs(x);
return c;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 7;
int n, m;
set<int> s[maxN], vis;
vector<int> ans, v;
queue<int> qu;
int BFS(int x) {
qu.push(x);
vis.erase(x);
int cnt = 0;
set<int>::iterator it;
while (!qu.empty()) {
v.clear();
int u = qu.front();
cnt++;
qu.pop();
for (it = vis.begin(); it != vis.end(); it++)
if (s[u].find(*it) == s[u].end()) v.push_back(*it);
for (int i = 0; i < v.size(); i++) {
int p = v[i];
qu.push(p);
vis.erase(p);
}
}
return cnt;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
s[u].insert(v);
s[v].insert(u);
}
for (int i = 1; i <= n; i++) vis.insert(i);
for (int i = 1; i <= n; i++) {
if (vis.find(i) != vis.end()) ans.push_back(BFS(i));
}
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 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;
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
set<int> adj[200005];
int group[200005];
vi currentcomponent;
int curgroup;
bool vis[200005];
int n, m;
int sz[200005];
void dfs(int x) {
currentcomponent.push_back(x);
vis[x] = true;
for (int i = 0; i < n; i++) {
if (x != i && adj[x].find(i) == adj[x].end()) {
if (group[i] == 1) {
curgroup = 1;
continue;
} else {
if (!vis[i]) {
dfs(i);
}
}
}
}
}
int main() {
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);
}
int cur = 1;
for (int i = 0; i < n; i++) {
if (n - adj[i].size() > n / 2) {
group[i] = 1;
sz[1]++;
cur = 2;
}
}
for (int i = 0; i < n; i++) {
if (!group[i]) {
curgroup = cur;
dfs(i);
for (int j : currentcomponent) {
group[j] = curgroup;
sz[curgroup]++;
}
currentcomponent.clear();
if (curgroup == cur) {
cur++;
}
}
}
cout << cur - 1 << endl;
sort(sz, sz + cur);
for (int i = 1; i < cur; i++) {
cout << sz[i] << ' ';
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> edge;
set<int> unvis;
vector<int> con;
int dfs(int x) {
int ans = 1;
unvis.erase(x);
int y = 1;
while (1) {
set<int>::iterator it = unvis.upper_bound(y);
if (it == unvis.end()) break;
y = *it;
if (edge[{x, y}] || edge[{y, x}]) continue;
ans += dfs(y);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
;
cin.tie(0);
cout.tie(0);
int i, j, x, y, n, m;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y;
edge[{x, y}] = edge[{y, x}] = 1;
}
for (i = 1; i < n + 1; i++) unvis.insert(i);
for (i = 1; i < n + 1; i++) {
if (unvis.find(i) != unvis.end()) con.push_back(dfs(i));
}
sort(con.begin(), con.end());
cout << con.size() << "\n";
for (i = 0; i < con.size(); i++) cout << con[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nn = 2e5 + 8;
set<int> vertex;
set<pair<int, int> > edge;
int n, m;
int com[nn], res[nn];
int num;
bool adj(int u, int v) {
if (u > v) swap(u, v);
return edge.find({u, v}) == edge.end();
}
void dfs(int u) {
com[u] = num;
vector<int> tmp;
for (int v : vertex)
if (adj(u, v)) tmp.push_back(v);
for (int v : tmp) vertex.erase(v);
for (int v : tmp) dfs(v);
}
int main() {
scanf("%d %d", &n, &m);
while (m--) {
int u, v;
scanf("%d %d", &u, &v);
if (u > v) swap(u, v);
edge.insert({u, v});
}
for (int i = 1; i <= n; i++) vertex.insert(i);
for (int i = 1; i <= n; i++) {
if (vertex.find(i) != vertex.end()) {
num++;
vertex.erase(i);
dfs(i);
}
}
for (int i = 1; i <= n; i++) res[com[i]]++;
sort(res + 1, res + 1 + num);
printf("%d\n", num);
for (int i = 1; i <= num; i++) printf("%d ", res[i]);
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:336777216")
using namespace std;
inline long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
inline long long power(long long a, long long n, long long m) {
if (n == 0) return 1;
long long p = power(a, n / 2, m);
p = (p * p) % m;
if (n % 2)
return (p * a) % m;
else
return p;
}
const long long MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
struct subset {
int rank, parent;
};
int find(subset subsets[], int i) {
if (subsets[i].parent == i) return i;
subsets[i].parent = find(subsets, subsets[i].parent);
return subsets[i].parent;
}
void Union(subset subsets[], int x, int y) {
if (subsets[x].rank > subsets[y].rank)
subsets[y].parent = x;
else if (subsets[y].rank > subsets[x].rank)
subsets[x].parent = y;
else {
subsets[y].parent = x;
subsets[x].rank++;
}
}
int cnt = 0;
set<int> unvisited;
void dfs(set<pair<int, int> >& s, int u) {
unvisited.erase(u);
set<int>::iterator it;
cnt++;
for (it = unvisited.begin(); it != unvisited.end();) {
if (s.find(make_pair(u, *it)) == s.end()) {
dfs(s, *it);
it = unvisited.begin();
} else
it++;
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, m;
cin >> n >> m;
set<pair<int, int> > s;
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
s.insert(make_pair(u, v));
s.insert(make_pair(v, u));
}
for (int i = 1; i <= n; i++) unvisited.insert(i);
vector<int> components;
while (!unvisited.empty()) {
cnt = 0;
dfs(s, (*(unvisited.begin())));
components.push_back(cnt);
}
cout << components.size() << endl;
sort(components.begin(), components.end());
for (int i = 0; i < components.size(); i++) cout << components[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unordered_set<int> nc[200005];
queue<int> vec;
bool vis[200005];
int ans[200005];
int n, m, cnt;
void bfs(int p, int cnt) {
queue<int> q;
while (!q.empty()) q.pop();
q.push(p);
while (!q.empty()) {
int x = q.front(), ns = vec.size();
q.pop();
for (int i = 1; i <= ns; i++) {
int now = vec.front();
vec.pop();
if (vis[now]) continue;
if (nc[x].find(now) != nc[x].end() || nc[now].find(x) != nc[now].end())
vec.push(now);
else
ans[cnt]++, q.push(now), vis[now] = 1;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
nc[a].insert(b);
}
for (int i = 1; i <= n; i++) vec.push(i);
for (int i = 1; i <= n; i++)
if (!vis[i]) {
vis[i] = true;
bfs(i, ++cnt);
}
sort(ans + 1, ans + cnt + 1);
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%d ", ans[i] + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const long long mod = 1e9 + 7;
const int inf = 1 << 30;
const int maxn = 1 << 22;
const double EPS = 1e-7;
vector<int> no[maxn], adj[maxn];
set<int> av;
int cn;
void dfs(int u, int p) {
int i = 0;
++cn;
for (int v : av)
if (v != p) {
while (i < no[u].size() && no[u][i] < v) ++i;
if (i == no[u].size() || no[u][i] != v) {
adj[u].push_back(v);
} else {
++i;
}
}
for (auto v : adj[u]) av.erase(v);
for (auto v : adj[u]) dfs(v, u);
}
void solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (int)(m); ++i) {
int u, v;
scanf("%d%d", &u, &v);
no[u].push_back(v);
no[v].push_back(u);
}
for (int i = (1); i < (int)(n + 1); ++i)
sort(no[i].begin(), no[i].end()), av.insert(i);
vector<int> cc;
while (!av.empty()) {
cn = 0;
int u = *av.begin();
av.erase(av.begin());
dfs(u, -1);
cc.push_back(cn);
}
sort(cc.begin(), cc.end());
printf("%d\n", cc.size());
for (int i : cc) printf("%d ", i);
}
int main() {
int tc = 1;
for (int tt = 0; tt < (int)(tc); ++tt) {
solve();
}
}
|
#include <bits/stdc++.h>
int take() {
int n;
scanf("%d", &n);
return n;
}
double ttake() {
double n;
scanf("%lf", &n);
return n;
}
long long takes() {
long long n;
scanf("%lld", &n);
return n;
}
int cas;
using namespace std;
bool approximatelyEqual(float a, float b, float epsilon) {
return fabs(a - b) <= ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
bool essentiallyEqual(float a, float b, float epsilon) {
return fabs(a - b) <= ((fabs(a) > fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
bool definitelyGreaterThan(float a, float b, float epsilon) {
return (a - b) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
bool definitelyLessThan(float a, float b, float epsilon) {
return (b - a) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
set<int> v1[200005];
set<int> unused;
bool nw[200005];
int cur, ans[200005], f;
void dfs(int x) {
nw[x] = 1;
int val = -1;
while (true) {
auto it = unused.upper_bound(val);
if (it == unused.end()) return;
val = *it;
if (!v1[x].count(val)) {
unused.erase(*it);
ans[f]++;
dfs(val);
}
}
}
int main() {
int n = take(), m = take(), u, v;
for (int i = 1; i <= m; i++) {
u = take(), v = take();
v1[u].insert(v);
v1[v].insert(u);
}
for (int i = 1; i <= n; i++) unused.insert(i);
for (int i = 1; i <= n; i++) {
if (!nw[i]) {
f++;
cur = 0;
ans[f] = cur;
dfs(i);
}
}
printf("%d\n", f);
sort(ans, ans + f + 1);
for (int i = 1; i <= f; i++) {
printf("%d ", ans[i]);
}
{ return 0; };
}
|
#include <bits/stdc++.h>
using namespace std;
std::set<int> ab[200000];
int i, j, n, m, a, b, rez[2000000], r, s, aa, k, jj, z[200000], zz;
int l;
set<int> mas;
int main() {
cin >> n >> m;
i = 0;
while (i < n) {
mas.insert(i);
i = i + 1;
}
i = 0;
while (i < m) {
cin >> a >> b;
a = a - 1;
b = b - 1;
ab[a].insert(b);
ab[b].insert(a);
i = i + 1;
}
i = 0;
while (i < n) {
s = i;
aa = 0;
k = 0;
if (mas.find(s) != mas.end()) {
zz = 1;
j = 0;
z[0] = s;
mas.erase(z[0]);
k = 1;
while (j < zz) {
l = -1;
while (mas.upper_bound(l) != mas.end()) {
if (ab[z[j]].count(*mas.upper_bound(l)) == 0) {
z[zz] = *mas.upper_bound(l);
mas.erase(z[zz]);
k = k + 1;
zz++;
} else {
l = *mas.upper_bound(l);
}
}
j++;
}
rez[r] = k;
r++;
}
i = i + 1;
}
cout << r << "\n";
i = 0;
sort(rez, rez + r);
while (i < r) {
cout << rez[i] << " ";
i++;
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> adj[200004], s;
vector<int> a;
int n, m, ans, res;
void readInput() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
}
for (int i = 1; i <= n; i++) s.insert(i);
}
void dfs(int u) {
res++;
if (s.count(u)) s.erase(u);
set<int> cnt;
for (auto v : s) {
if (adj[v].count(u))
continue;
else
cnt.insert(v);
}
for (auto v : cnt) s.erase(v);
for (auto v : cnt) dfs(v);
}
void solve() {
while (!s.empty()) {
res = 0;
dfs(*s.begin());
ans++;
a.push_back(res);
}
cout << ans << '\n';
sort(a.begin(), a.end());
for (auto v : a) cout << v << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
readInput();
solve();
}
|
#include <bits/stdc++.h>
const int maxn = 2e5 + 5;
using namespace std;
set<int> s, mp[maxn];
int n, m;
bool vis[maxn];
vector<int> a;
int cnt;
void dfs(int st) {
vis[st] = 1;
s.erase(st);
int now = 0;
while (1) {
set<int>::iterator i = s.upper_bound(now);
if (i == s.end()) break;
now = *i;
if (!mp[st].count(*i)) {
dfs(*i);
cnt++;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) s.insert(i);
int l, r;
for (int i = 0; i < m; i++) {
scanf("%d%d", &l, &r);
mp[l].insert(r);
mp[r].insert(l);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cnt = 1;
dfs(i);
a.push_back(cnt);
}
}
int si = a.size();
printf("%d\n", si);
sort(a.begin(), a.end());
for (int i = 0; i < si; i++) {
printf("%d%c", a[i], " \n"[i == si - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> dat;
UnionFind(int n) : dat(n, -1) {}
int find(int x) {
if (dat[x] < 0) return x;
return dat[x] = find(dat[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
dat[x] += dat[y];
dat[y] = x;
}
int size(int x) { return -dat[find(x)]; }
vector<int> iter_roots() {
vector<int> res;
for (int i = 0; i < dat.size(); i++) {
if (dat[i] < 0) {
res.push_back(i);
}
}
return res;
}
};
UnionFind complement_connected_components(vector<vector<int>> g) {
const int n = g.size();
queue<int> q;
vector<int> yet;
vector<bool> vis(n);
for (int i = 0; i < n; i++) {
yet.push_back(i);
sort(g[i].begin(), g[i].end());
}
UnionFind uf(n);
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = true;
vector<int> nxt;
for (int v : yet) {
if (binary_search(g[u].begin(), g[u].end(), v)) {
nxt.push_back(v);
} else {
uf.unite(u, v);
q.push(v);
}
}
yet = move(nxt);
}
}
return uf;
}
vector<vector<int>> read_graph(int n, int m) {
vector<vector<int>> g(n);
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);
}
return g;
}
template <class X, class Y>
vector<Y> fmap(function<Y(X)> f, vector<X> xs) {
for (auto &x : xs) {
x = f(x);
}
return xs;
}
void print(vector<int> a) {
for (size_t i = 0; i < a.size(); i++) {
if (i != 0) printf(" ");
printf("%d", a[i]);
}
printf("\n");
}
template <class T>
vector<T> sort(vector<T> xs) {
sort(xs.begin(), xs.end());
return xs;
}
int main() {
int n, m;
cin >> n >> m;
auto uf = complement_connected_components(read_graph(n, m));
auto ans = uf.iter_roots();
ans = fmap<int, int>([&](int x) { return uf.size(x); }, ans);
ans = sort(ans);
cout << ans.size() << endl;
print(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int n, m, u, v;
set<int> edge[maxn], pt;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
edge[u].insert(v);
edge[v].insert(u);
}
vector<int> ans;
for (int i = 1; i <= n; i++) pt.insert(i);
while (!pt.empty()) {
queue<int> que;
ans.push_back(0);
que.push(*pt.begin());
pt.erase(que.front());
while (!que.empty()) {
int u = que.front();
que.pop();
ans.back()++;
set<int> buf;
for (auto &ig : pt) {
if (edge[u].find(ig) == edge[u].end()) {
que.push(ig);
buf.insert(ig);
}
}
for (auto ig : buf) {
pt.erase(ig);
}
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (auto ig : ans) {
cout << ig << " ";
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[200010];
set<int> S;
bool vis[200010];
int cnt;
void dfs(int u) {
++cnt;
vis[u] = true;
S.erase(u);
set<int>::iterator it = S.begin();
while (it != S.end()) {
int v = *it;
if (vis[v] || binary_search(G[u].begin(), G[u].end(), v)) {
++it;
continue;
}
dfs(v);
it = S.lower_bound(v);
}
}
int main(int argc, const char* argv[]) {
int n, m;
memset(vis, 0, sizeof(vis));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
S.insert(i);
sort(G[i].begin(), G[i].end());
}
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (vis[i] == false) {
cnt = 0;
dfs(i);
ans.push_back(cnt);
}
}
printf("%d\n", ans.size());
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void optimise() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
long long int mod = 1e9 + 7;
void normalize(long long int &a) { a = (a + mod) % mod; }
long long int modmul(long long int a, long long int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a * b) % mod;
}
long long int modadd(long long int a, long long int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a + b) % mod;
}
long long int modsub(long long int a, long long int b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a - b + mod) % mod;
}
long long int me(long long int x, long long int n) {
x %= mod;
if (n == 0) return 1;
long long int u = me(x, n / 2) % mod;
u = (u * u) % mod;
if (n % 2) u = (u * x) % mod;
return u;
}
long long int me1(long long int x, long long int n) {
if (n == 0) return 1;
long long int u = me1(x, n / 2);
u = u * u;
if (n % 2) u = u * x;
return u;
}
inline long long int modInv(long long int a) { return me(a, mod - 2); }
inline long long int modDiv(long long int a, long long int b) {
return modmul(a, modInv(b));
}
long long int __gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return __gcd(b, a % b);
}
set<long long int> unvisted;
const long long int N = 2e5 + 1;
set<long long int> G[N];
long long int con = 0;
void dfs(long long int i) {
con++;
vector<long long int> next;
unvisted.erase(i);
for (auto &y : unvisted) {
if (G[i].find(y) == G[i].end()) {
next.push_back(y);
}
}
for (auto &y : next) unvisted.erase(y);
for (auto &y : next) dfs(y);
}
void solve() {
long long int n;
cin >> n;
long long int m;
cin >> m;
for (long long int i = 1; i <= m; i++) {
long long int x, y;
cin >> x >> y;
G[x].insert(y);
G[y].insert(x);
}
for (long long int i = 1; i <= n; i++) unvisted.insert(i);
vector<long long int> ans;
for (long long int i = 1; i <= n; i++) {
if (unvisted.find(i) != unvisted.end()) {
con = 0;
dfs(i);
ans.push_back(con);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (long long int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
signed main() {
optimise();
long long int t;
t = 1;
while (t--) {
solve();
}
}
|
#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;
int sear = -1;
while (1) {
auto ta = notused.upper_bound(sear);
if (ta == notused.end()) break;
sear = *ta;
if (adj[src].find(sear) == adj[src].end()) {
con[sear] = con[src];
dfs(sear);
} else {
continue;
}
}
}
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;
long long int powmod(long long int base, long long int pow) {
long long int res = 1;
while (pow) {
if (pow % 2 != 0) res = (res * base) % 1000000007;
base = (base * base) % 1000000007;
pow /= 2;
}
return res;
}
set<int> v;
set<int> g[200005];
int dfs(int ver) {
int sum = 1;
for (set<int>::iterator it = v.begin(); it != v.end();) {
int vv = *it;
if (g[ver].find(vv) != g[ver].end())
it++;
else {
v.erase(vv);
sum += dfs(vv);
it = v.lower_bound(vv);
}
}
return sum;
}
vector<long long int> sizess;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].insert(y);
g[y].insert(x);
}
for (long long int i = 0; i < n; i++) v.insert(i);
while (v.size()) {
int x = *(v.begin());
v.erase(x);
sizess.push_back(dfs(x));
}
cout << sizess.size() << "\n";
sort(sizess.begin(), sizess.end());
for (long long int i = 0; i < sizess.size(); i++) cout << sizess[i] << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > lista;
vector<int> r;
unordered_set<int> D, d;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, x, a, b, k;
cin >> n >> m;
lista.resize(n);
while (m--) {
cin >> a >> b;
a--;
b--;
lista[a].push_back(b);
lista[b].push_back(a);
}
for (x = 0; x < n; x++) D.insert(x);
while (!D.empty()) {
a = *D.begin();
unordered_set<int> A, B;
k = 1;
D.erase(a);
d.insert(a);
for (auto c : lista[a]) {
D.erase(c);
if (!d.count(c)) A.insert(c);
}
while (!D.empty()) {
a = *D.begin();
D.erase(a);
d.insert(a);
k++;
for (auto c : lista[a]) {
A.erase(c);
if (!d.count(c)) B.insert(c);
}
while (!A.empty()) {
a = *A.begin();
if (!d.count(a)) D.insert(a);
A.erase(a);
}
swap(A, B);
}
r.push_back(k);
swap(A, D);
}
sort(r.begin(), r.end());
cout << r.size() << endl;
for (x = 0; x < r.size(); x++) cout << r[x] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> nvis;
set<pair<int, int> > ase;
int con[200005];
int cn;
int coun;
int sz[200005];
void dfs(int n) {
nvis.erase(n);
con[n] = coun;
++sz[coun];
auto it = nvis.begin();
int val = -1;
while (it != nvis.end()) {
int u = (*it);
if (ase.find(make_pair(u, n)) != ase.end() ||
ase.find(make_pair(n, u)) != ase.end()) {
++it;
} else {
val = u;
dfs(u);
it = nvis.lower_bound(u);
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
ase.insert(make_pair(a, b));
ase.insert(make_pair(b, a));
}
for (int i = 1; i <= n; ++i) {
nvis.insert(i);
}
for (int i = 1; i <= n; ++i) {
if (nvis.find(i) != nvis.end()) {
++coun;
dfs(i);
}
}
cout << coun << endl;
vector<int> ajak;
for (int i = 1; i <= coun; ++i) {
ajak.push_back(sz[i]);
}
sort(ajak.begin(), ajak.end());
for (int i = 1; i <= coun; ++i) {
printf("%d ", ajak[i - 1]);
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
const int N = 5 * 100 * 1000 + 7;
int test;
int n, m;
map<pair<int, int>, int> e;
int par[N], rnk[N];
int t[N];
vector<int> G;
set<int> s;
vector<int> g[N];
vector<int> dow;
int fnd(int a) {
if (par[a] != a) {
par[a] = fnd(par[a]);
}
return par[a];
}
void uni(int a, int b) {
a = fnd(a);
b = fnd(b);
if (a != b) {
if (rnk[a] > rnk[b]) {
par[b] = a;
rnk[a] += rnk[b];
for (auto it : g[b]) {
g[a].push_back(it);
}
dow.push_back(b);
} else {
par[a] = b;
rnk[b] += rnk[a];
for (auto it : g[a]) {
g[b].push_back(it);
}
dow.push_back(a);
}
}
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= (m); ++i) {
int a, b;
cin >> a >> b;
e[make_pair(a, b)] = e[make_pair(b, a)] = 1;
}
for (int i = 1; i <= (n); ++i) {
par[i] = i;
rnk[i] = 1;
s.insert(i);
g[i].push_back(i);
}
for (int i = 1; i <= (n); ++i) {
dow.clear();
for (auto it : s) {
if (it != i)
for (auto it1 : g[it]) {
if (e[make_pair(i, it1)] == 0) {
uni(i, it1);
break;
}
}
}
for (auto it : dow) {
s.erase(it);
}
}
for (int i = 1; i <= (n); ++i) {
t[fnd(i)]++;
}
for (int i = 1; i <= (n); ++i) {
if (t[i]) {
G.push_back(t[i]);
}
}
sort(G.begin(), G.end());
cout << G.size() << '\n';
for (auto it : G) {
cout << it << " ";
}
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
test = 1;
while (test--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200050;
const int M = 4 * N;
vector<int> E[M], R[N];
int ls[M], rs[M], cnt, root;
void Build(int &c, int ss, int se) {
if (!c) c = ++cnt;
if (ss == se) {
c = ss;
return;
}
int mid = ss + se >> 1;
Build(ls[c], ss, mid);
Build(rs[c], mid + 1, se);
E[c].push_back(ls[c]);
E[c].push_back(rs[c]);
}
void Set(int c, int ss, int se, int qs, int qe, int nod) {
if (qs > qe) return;
if (ss > qe || qs > se) return;
if (qs <= ss && qe >= se) {
E[nod].push_back(c);
return;
}
int mid = ss + se >> 1;
Set(ls[c], ss, mid, qs, qe, nod);
Set(rs[c], mid + 1, se, qs, qe, nod);
}
bool vis[M];
int num;
void DFS(int u, int n) {
if (vis[u]) return;
if (u <= n) num++;
vis[u] = 1;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
DFS(v, n);
}
}
int main() {
int n, m, i, j, u, v;
scanf("%i %i", &n, &m);
cnt = n;
Build(root, 1, n);
while (m--) {
scanf("%i %i", &u, &v);
R[u].push_back(v);
R[v].push_back(u);
}
for (i = 1; i <= n; i++) {
R[i].push_back(0);
R[i].push_back(n + 1);
sort(R[i].begin(), R[i].end());
for (j = 1; j < R[i].size(); j++)
Set(root, 1, n, R[i][j - 1] + 1, R[i][j] - 1, i);
}
vector<int> sol;
for (i = 1; i <= n; i++)
if (!vis[i]) num = 0, DFS(i, n), sol.push_back(num);
sort(sol.begin(), sol.end());
printf("%i\n", sol.size());
for (i = 0; i < sol.size(); i++) printf("%i ", sol[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int f = 0, ch = 0;
x = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
if (f) x = -x;
}
int vis[(300005)], n, m;
vector<int> r[(300005)], s;
inline int dfs(int u) {
vector<int> a, b;
int ans = 1;
vis[u] = 1;
set_intersection(s.begin(), s.end(), r[u].begin(), r[u].end(),
back_inserter(a)),
set_difference(s.begin(), s.end(), a.begin(), a.end(), back_inserter(b)),
s.swap(a);
for (int i = 0; i < b.size(); i++) ans += dfs(b[i]);
return ans;
}
int main() {
read(n), read(m);
for (int i = 1, x, y; i <= m; i++) {
read(x), read(y);
r[x].push_back(y), r[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
s.push_back(i);
sort(r[i].begin(), r[i].end());
}
int tot = 0;
vector<int> ans;
while (s.size()) {
int now = s.back();
s.pop_back(), tot++, ans.push_back(dfs(now));
}
printf("%d\n", tot);
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int n, m, k, a, b;
vector<int> v[MAX], ss;
set<int> s[MAX];
bool M[MAX];
void dfs(int nod) {
queue<int> Q;
Q.push(nod);
k = 0;
M[nod] = true;
while (!Q.empty()) {
k++;
nod = Q.front();
Q.pop();
for (int i = 0; i < v[nod].size(); i++) {
int newn = v[nod][i];
if (!M[newn]) {
M[newn] = true;
Q.push(newn);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
s[a].insert(b);
s[b].insert(a);
}
for (int i = 1; i < n; i++) {
a = i;
int can = 0;
while (a < n && can < 20) {
a++;
if (s[i].find(a) == s[i].end())
v[i].push_back(a), v[a].push_back(i), can++;
}
}
for (int i = n; i > 1; i--) {
a = i;
int can = 0;
while (a >= 2 && can < 20) {
a--;
if (s[i].find(a) == s[i].end())
v[i].push_back(a), v[a].push_back(i), can++;
}
}
for (int i = 1; i <= n; i++) {
if (!M[i]) {
k = 0;
dfs(i);
ss.push_back(k);
}
}
sort(ss.begin(), ss.end());
printf("%d\n", (int)ss.size());
printf("%d", ss[0]);
for (int i = 1; i < (int)ss.size(); i++) {
printf(" %d", ss[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long bp(long long a, long long n) {
if (n == 0) return 1;
if (n & 1) return (a * bp(a, n - 1));
long long ans = bp(a, (n >> 1));
return (ans * ans);
}
const int N = 2e5 + 123, inf = 1e9 + 123;
int n, m;
set<int> st, g[N];
vector<int> comp;
const long long INF = 1e18 + 123;
void Dfs(int v) {
st.erase(v);
comp.push_back(v);
int to = -1;
while (st.upper_bound(to) != st.end()) {
to = *st.upper_bound(to);
if (g[v].find(to) == g[v].end()) {
Dfs(to);
}
}
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(NULL);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
g[x].insert(y);
g[y].insert(x);
}
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()) {
comp.clear();
Dfs(i);
ans.push_back(comp.size());
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << '\n';
for (auto it : ans) {
cout << it << ' ';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct DSU {
std::vector<int> dat;
DSU(int n) : dat(n, -1) {}
int find(int u) {
if (dat[u] < 0) return u;
return dat[u] = find(dat[u]);
}
void unite(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
if (-dat[u] < -dat[v]) std::swap(u, v);
dat[u] += dat[v];
dat[v] = u;
}
int size(int u) { return -dat[find(u)]; }
};
const int N = 2e5;
set<int> g[N];
bool vis[N];
set<int> yet;
DSU dsu(N);
void dfs(int u) {
if (vis[u]) return;
vis[u] = true;
set<int> nxt;
vector<int> rem;
for (int v : yet) {
if (g[u].count(v)) {
nxt.insert(u);
} else {
dsu.unite(u, v);
rem.push_back(v);
}
}
for (int v : rem) yet.erase(v);
for (int v : rem) {
dfs(v);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
g[u].insert(v);
g[v].insert(u);
}
for (int i = 0; i < n; i++) {
yet.insert(i);
}
for (int i = 0; i < n; i++) {
dfs(i);
}
vector<int> ans;
for (int i = 0; i < n; i++) {
if (dsu.find(i) == i) {
ans.push_back(dsu.size(i));
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int x : ans) {
printf("%d ", x);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, comp = 0, cnt[200100];
set<int> st;
set<int>::iterator it;
vector<int> v[200100];
vector<int> Answer;
map<pair<int, int>, int> mp;
bool vis[200100];
void DFS(int x) {
vector<int> temp;
vis[x] = true;
cnt[comp]++;
for (it = st.begin(); it != st.end(); it++) {
if (!mp.count({x, *it}) && !vis[*it]) temp.push_back(*it);
}
for (int i = 0; i < temp.size(); i++) st.erase(temp[i]);
for (int i = 0; i < temp.size(); i++) {
DFS(temp[i]);
}
}
int main() {
int x, y;
cin >> n >> m;
while (m--) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
mp[{x, y}]++;
mp[{y, x}]++;
}
for (int i = 1; i <= n; i++) st.insert(i);
for (int i = 1; i <= n; i++) {
if (!vis[i]) DFS(i), comp++;
}
for (int i = 0; i < n; i++) {
if (cnt[i]) Answer.push_back(cnt[i]);
}
sort(Answer.begin(), Answer.end());
cout << Answer.size() << endl;
for (int i = 0; i < Answer.size(); i++) cout << Answer[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
struct E {
int to, nxt;
} e[N << 1];
int n, m, head[N], cnt, l[N], r[N], ans[N], ans_cnt, fa[N];
bool b[N];
int Write[20], WRI;
void judge() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
int read() {
int d = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') d = d * 10 + c - 48, c = getchar();
return d * f;
}
void write(int x) {
if (!x) {
putchar('0');
return;
}
if (x < 0) putchar('-'), x = -x;
for (WRI = 1; x; x /= 10, WRI++) Write[WRI] = x % 10;
for (int i = WRI - 1; i; i--) putchar((char)(Write[i] + 48));
}
void add(int x, int y) {
e[++cnt] = (E){y, head[x]};
head[x] = cnt;
}
void addedge(int x, int y) {
add(x, y);
add(y, x);
}
void del(int x) {
b[x] = 1;
r[l[x]] = r[x];
l[r[x]] = l[x];
}
void bfs(int ljj) {
queue<int> q;
int sum = 1;
q.push(ljj);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
fa[v] = u;
}
for (int i = r[0]; i <= n; i = r[i])
if (fa[i] != u && !b[i]) {
q.push(i);
del(i);
sum++;
}
}
ans[++ans_cnt] = sum;
}
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) addedge(read(), read());
for (int i = 0; i <= n; i++) l[i] = i - 1, r[i] = i + 1;
for (int i = 1; i <= n; i = r[i])
if (!b[i]) {
del(i);
bfs(i);
}
sort(ans + 1, ans + 1 + ans_cnt);
write(ans_cnt);
puts("");
for (int i = 1; i <= ans_cnt; i++) write(ans[i]), putchar(' ');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, k = 0;
vector<int> odp;
vector<pair<int, int> > st2;
set<int> d[200001];
set<int> u;
void DFS(int v) {
u.erase(v);
odp[k]++;
int c = -1;
set<int>::iterator it = u.upper_bound(c);
while (it != u.end()) {
c = *it;
if (!d[v].count(c)) DFS(c);
it = u.upper_bound(c);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
d[x].insert(y);
d[y].insert(x);
}
for (int i = 1; i <= n; i++) u.insert(i);
for (int i = 1; i <= n; i++) {
if (u.count(i)) {
odp.push_back(0);
DFS(i);
k++;
}
}
sort(odp.begin(), odp.end());
cout << odp.size() << endl;
for (int i = 0; i < odp.size(); i++) cout << odp[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<long long>;
using vpi = vector<pair<ll, ll>>;
using pi = pair<ll, ll>;
const int mod = 1000000007;
set<int> adj[200000];
set<int> unvis;
int group[200000];
int cur = 0;
void dfs(int x) {
group[cur]++;
auto it = unvis.begin();
while (it != unvis.end()) {
assert(!unvis.empty());
if (adj[x].count(*it)) {
it++;
} else {
int last = *it;
unvis.erase(it);
dfs(*it);
it = unvis.upper_bound(last);
}
}
}
int main() {
int tt = 1;
while (tt--) {
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(group, group + cur);
for (int i = 0; i < cur; i++) {
cout << group[i] << ' ';
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> a;
vector<set<int> > b;
int kol = 0;
void dfs(int n) {
a.erase(n);
queue<int> q;
q.push(n);
while (!q.empty()) {
kol++;
n = q.front();
q.pop();
set<int>::iterator it = a.begin();
vector<int> q1;
while (it != a.end()) {
if (b[n].find(*it) == b[n].end()) q1.push_back(*it);
it++;
}
for (int i = 0; i < q1.size(); i++) {
q.push(q1[i]);
a.erase(q1[i]);
}
}
}
int main() {
int n, m;
cin >> n >> m;
b.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
b[x].insert(y);
b[y].insert(x);
}
for (int i = 0; i < n; i++) a.insert(i);
vector<int> c;
for (int i = 0; i < n; i++)
if (a.find(i) != a.end()) {
kol = 0;
dfs(i);
c.push_back(kol);
}
sort(c.begin(), c.end());
cout << c.size() << endl;
for (int i = 0; i < c.size(); i++) cout << c[i] << ' ';
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t>
using V = vector<t>;
int n, m;
V<int> odp;
V<int> tab;
V<bool> odw;
int t = 1;
V<int> arr;
V<int> ilo;
V<V<int> > gr;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
gr.resize(n + 1);
tab.resize(n + 1);
odw.resize(n + 1);
arr.resize(n + 1);
ilo.resize(n);
for (int i = 0; i < n; ++i) ilo[i] = i + 1;
for (int i = 0; i < m; ++i) {
int p, q;
cin >> p >> q;
gr[p].push_back(q);
gr[q].push_back(p);
}
for (int i = 1; i <= n; ++i) {
if (odw[i] == false) {
int tmp = i;
queue<int> Q;
Q.push(i);
int ctr = 0;
while (!Q.empty()) {
++ctr;
int v = Q.front();
Q.pop();
;
odw[v] = true;
for (int s : gr[v]) arr[s] = t;
for (int i = 0; i < ilo.size(); ++i) {
if (arr[ilo[i]] != t or ilo[i] == tmp) {
if (ilo[i] != tmp) Q.push(ilo[i]);
ilo[i] = ilo[ilo.size() - 1];
ilo.pop_back();
--i;
}
}
++t;
}
odp.push_back(ctr);
}
}
sort(begin(odp), end(odp));
cout << odp.size() << '\n';
for (int i : odp) cout << i << ' ';
cout << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const long long mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-9;
int n, m;
vector<int> vec, mp;
map<int, bool> vis[maxn];
int bfs(int x) {
queue<int> q;
int cnt = 0;
q.push(x);
while (q.size()) {
int u = q.front();
q.pop();
cnt++;
for (int i = 0; i < mp.size(); i++) {
int v = mp[i];
if (!vis[u][v]) {
swap(mp[i], mp.back());
mp.pop_back();
q.push(v);
i--;
}
}
}
return cnt;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
vis[x][y] = true;
vis[y][x] = true;
}
for (int i = 1; i <= n; i++) {
mp.push_back(i);
}
while (mp.size()) {
int u = mp.back();
mp.pop_back();
int num = bfs(u);
vec.push_back(num);
}
sort(vec.begin(), vec.end());
printf("%d\n", vec.size());
for (int i = 0; i < vec.size(); i++) {
printf("%d ", vec[i]);
}
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
bool vis[N];
set<int> st[N];
set<int> g;
vector<int> temp;
void bfs(int node, int &sz) {
queue<int> bfs;
bfs.push(node);
while (bfs.size()) {
sz++;
node = bfs.front();
bfs.pop();
vis[node] = 1;
for (auto it = g.begin(); it != g.end();) {
int u = *it;
int x = min(u, node), y = max(u, node);
if (st[x].find(y) == st[x].end() && !vis[u]) {
it++;
g.erase(u);
vis[u] = 1;
bfs.push(u);
} else {
it++;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) g.insert(i);
for (int i = 0, u, v; i < m; i++) {
cin >> u >> v;
if (u > v) swap(u, v);
st[u].insert(v);
}
vector<int> res;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
int sz = 0;
g.erase(i);
bfs(i, sz);
res.push_back(sz);
}
}
sort(res.begin(), res.end());
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++) cout << res[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, tot;
map<pair<int, int>, int> mp;
int vis[200010];
int ans[200010], len;
class Treap {
public:
struct treap_point {
int l, r, x, rep, son, rnd;
} t[200010];
int treesz, root;
inline void update(int k) {
t[k].son = t[t[k].l].son + t[t[k].r].son + t[k].rep;
}
inline void right_rotate(int &k) {
int tt = t[k].l;
t[k].l = t[tt].r;
t[tt].r = k;
update(k);
update(tt);
k = tt;
}
inline void left_rotate(int &k) {
int tt = t[k].r;
t[k].r = t[tt].l;
t[tt].l = k;
update(k);
update(tt);
k = tt;
}
inline void insert_to_tree(int &k, int x) {
if (!k) {
k = ++treesz;
t[k].x = x;
t[k].rnd = rand();
t[k].son = t[k].rep = 1;
t[k].l = t[k].r = 0;
return;
}
t[k].son++;
if (x == t[k].x) {
t[k].rep++;
return;
}
if (x < t[k].x) {
insert_to_tree(t[k].l, x);
if (t[t[k].l].rnd < t[k].rnd) right_rotate(k);
}
if (x > t[k].x) {
insert_to_tree(t[k].r, x);
if (t[t[k].r].rnd < t[k].rnd) left_rotate(k);
}
}
inline bool delete_from_tree(int &k, int x) {
if (!k) return 0;
if (x == t[k].x) {
if (t[k].rep > 1) {
t[k].rep--;
t[k].son--;
return 1;
}
if (!t[k].l || !t[k].r) {
k = t[k].l + t[k].r;
return 1;
}
if (t[t[k].l].rnd < t[t[k].r].rnd) {
right_rotate(k);
return delete_from_tree(k, x);
}
left_rotate(k);
return delete_from_tree(k, x);
}
int res;
if (x < t[k].x) {
res = delete_from_tree(t[k].l, x);
if (res) t[k].son--;
return res;
}
res = delete_from_tree(t[k].r, x);
if (res) t[k].son--;
return res;
}
inline int get_succ_in_tree(int k, int x) {
if (!k) return -1;
int sv;
if (x < t[k].x) {
sv = get_succ_in_tree(t[k].l, x);
return sv == -1 ? t[k].x : sv;
}
return get_succ_in_tree(t[k].r, x);
}
inline int get_pred_in_tree(int k, int x) {
if (!k) return -1;
int sv;
if (x > t[k].x) {
sv = get_pred_in_tree(t[k].r, x);
return sv == -1 ? t[k].x : sv;
}
return get_pred_in_tree(t[k].l, x);
}
inline int ask_kth_in_tree(int k, int x) {
if (!k) return -1;
if (x <= t[t[k].l].son) return ask_kth_in_tree(t[k].l, x);
if (x > t[t[k].l].son + t[k].rep)
return ask_kth_in_tree(t[k].r, x - t[t[k].l].son - t[k].rep);
return t[k].x;
}
inline int ask_rank_in_tree(int k, int x) {
if (!k) return -1;
if (x == t[k].x) return t[t[k].l].son + 1;
if (x < t[k].x) return ask_rank_in_tree(t[k].l, x);
return t[t[k].l].son + t[k].rep + ask_rank_in_tree(t[k].r, x);
}
inline void init() { treesz = root = 0; }
inline void insert(int x) { insert_to_tree(root, x); }
inline int del(int x) { return delete_from_tree(root, x); }
inline int succ(int x) { return get_succ_in_tree(root, x); }
inline int pred(int x) { return get_pred_in_tree(root, x); }
inline int ask_kth(int x) { return ask_kth_in_tree(root, x); }
inline int ask_rank(int x) { return ask_rank_in_tree(root, x); }
} T;
inline void dfs(int x) {
tot++;
vis[x] = 1;
T.del(x);
int now = T.ask_kth(1);
while (now != -1) {
if (!vis[now] && !mp[make_pair(x, now)]) dfs(now);
now = T.succ(now);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
mp[make_pair(x, y)] = mp[make_pair(y, x)] = 1;
}
for (int i = 1; i <= n; i++) T.insert(i);
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i), ans[++len] = tot, tot = 0;
sort(ans + 1, ans + len + 1);
printf("%d\n", len);
for (int i = 1; i <= len; i++) printf("%d ", ans[i]);
puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
vector<set<int> > newadj(212345);
int visit[212345];
vector<vector<int> > adj(212345);
vector<int> vec, vecans;
set<int> seti;
int cnt = 0;
int pos[212345];
int dfs(int cur) {
cnt++;
visit[cur] = 1;
set<int>::iterator it;
for (it = newadj[cur].begin(); it != newadj[cur].end(); it++) {
if (!visit[*it]) {
dfs(*it);
}
}
return 0;
}
int main() {
std::ios::sync_with_stdio(false);
int n, m;
int i, j, u, v;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
int mini = (1000 * 1000 * 1000 + 5), vert;
for (i = 0; i < n; i++) {
if (mini > adj[i].size()) {
mini = adj[i].size();
vert = i;
}
}
int sumi = 0;
for (i = 0; i < n; i++) {
sumi++;
pos[i] = vert;
}
vec.push_back(vert);
for (i = 0; i < adj[vert].size(); i++) {
sumi--;
pos[adj[vert][i]] = adj[vert][i];
vec.push_back(adj[vert][i]);
seti.insert(adj[vert][i]);
}
seti.insert(vert);
set<int>::iterator it;
for (i = 1; i < vec.size(); i++) {
for (it = seti.begin(); it != seti.end(); it++) {
newadj[vec[i]].insert(*it);
}
cnt = 0;
for (j = 0; j < adj[vec[i]].size(); j++) {
if (pos[adj[vec[i]][j]] == vert) {
cnt++;
continue;
}
newadj[vec[i]].erase(pos[adj[vec[i]][j]]);
}
if (cnt == sumi) {
newadj[vec[i]].erase(vert);
} else {
newadj[vert].insert(vec[i]);
}
}
for (i = 0; i < vec.size(); i++) {
if (!visit[vec[i]]) {
cnt = 0;
dfs(vec[i]);
if (i == 0) {
cnt += sumi - 1;
}
vecans.push_back(cnt);
}
}
sort(vecans.begin(), vecans.end());
cout << vecans.size() << endl;
for (i = 0; i < vecans.size(); i++) {
cout << vecans[i] << " ";
}
return 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int N = 200010;
int sz[N], vis[N], vs;
unordered_map<int, int> no[N];
int n;
set<int> st;
int toerase[N], top;
int bfs(int s) {
queue<int> Q;
Q.push(s);
vis[s] = 1;
st.erase(s);
int ret = 1;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (auto &v : st) {
if (vis[v]) continue;
if (!no[u].count(v)) {
vis[v] = 1;
++ret;
toerase[++top] = v;
if (vs + ret >= n) return ret;
Q.push(v);
}
}
while (top) st.erase(toerase[--top]);
}
return ret;
}
int main(void) {
register int m, i, a, b;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
no[a][b] = no[b][a] = 1;
}
for (i = 1; i <= n; ++i) st.insert(i);
int Sz = 0;
for (i = 1; i <= n; ++i)
if (!vis[i]) sz[Sz++] = bfs(i);
sort(sz, sz + Sz);
printf("%d\n", Sz);
for (i = 0; i < Sz; ++i) printf("%d%c", sz[i], " \n"[i == Sz - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> e[200010];
set<int> v;
int p[200010];
map<int, int> num;
vector<int> ans;
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
void dfs(int x) {
v.erase(x);
auto it = v.lower_bound(0);
while (it != v.end()) {
int y = *it;
if (e[x].find(y) == e[x].end()) {
p[y] = find(x);
dfs(y);
}
it = v.lower_bound(y + 1);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
e[x].insert(y);
e[y].insert(x);
}
for (int i = 1; i <= n; i++) {
v.insert(i);
p[i] = i;
}
for (int i = 1; i <= n; i++)
if (v.find(i) != v.end()) dfs(i);
for (int i = 1; i <= n; i++) num[p[i]]++;
printf("%d\n", num.size());
for (auto it = num.begin(); it != num.end(); it++) ans.push_back(it->second);
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, tot = 0, ans[200005];
set<int> nv;
map<int, int> e[200005];
inline int bfs(int x) {
queue<int> q;
q.push(x);
int sz = 0;
while (!q.empty()) {
int x = q.front();
q.pop(), sz++;
for (set<int>::iterator i = nv.begin(), r; i != nv.end();)
if (!e[x][*i])
q.push(*i), r = i, i++, nv.erase(r);
else
i++;
}
return sz;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= m; i++)
scanf("%d%d", &x, &y), e[x][y] = 1, e[y][x] = 1;
for (int i = 1; i <= n; i++) nv.insert(i);
for (int x; !nv.empty();) x = *nv.begin(), nv.erase(x), ans[++tot] = bfs(x);
printf("%d\n", tot), sort(ans + 1, ans + tot + 1);
for (int i = 1; i <= tot; i++) printf("%d%c", ans[i], i == tot ? '\n' : ' ');
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 2e5 + 5;
using namespace std;
set<int> s, mp[maxn];
int n, m;
bool vis[maxn];
vector<int> a;
int cnt;
void dfs(int st) {
vis[st] = 1;
s.erase(st);
int now = 0;
while (1) {
set<int>::iterator it = s.upper_bound(now);
if (it == s.end()) break;
now = *it;
if (!mp[st].count(now)) {
dfs(now);
cnt++;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) s.insert(i);
int l, r;
for (int i = 0; i < m; i++) {
scanf("%d%d", &l, &r);
mp[l].insert(r);
mp[r].insert(l);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cnt = 1;
dfs(i);
a.push_back(cnt);
}
}
int si = a.size();
printf("%d\n", si);
sort(a.begin(), a.end());
for (int i = 0; i < si; i++) {
printf("%d%c", a[i], " \n"[i == si - 1]);
}
return 0;
}
|
#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 = 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;
set<int> bag[200005 * 5];
int id[200005 * 5];
int P[200005 * 10];
int n, q;
vector<int> E[200005];
int MaxId = 0;
int Cnt[200005 * 10];
int f(int u) {
if (P[u] != u) return P[u] = f(P[u]);
return u;
}
void build(int p, int s, int e) {
id[p] = p;
MaxId = max(MaxId, p);
if (s == e) return;
int m = (s + e) / 2;
build(p * 2 + 1, s, m);
build(p * 2 + 2, m + 1, e);
}
void upd(int p, int s, int e, int l, int r, int i) {
if (s > r || e < l) return;
if (l <= s && e <= r) {
bag[p].insert(i);
return;
}
int m = (s + e) / 2;
upd(p * 2 + 1, s, m, l, r, i);
upd(p * 2 + 2, m + 1, e, l, r, i);
}
void addE(int u, int v) { P[f(u)] = f(v); }
void dnc(int p, int s, int e, int isi) {
if (s == e) {
for (auto it : bag[p]) {
addE(s + MaxId, it + MaxId);
}
return;
}
int m = (s + e) / 2;
dnc(p * 2 + 1, s, m, isi | (!bag[p].empty()));
dnc(p * 2 + 2, m + 1, e, isi | (!bag[p].empty()));
int isiisi = isi | (!bag[p].empty());
if (isiisi) {
for (int i = s; i < e; i++) addE(i + MaxId, i + MaxId + 1);
for (auto it : bag[p]) {
addE(it + MaxId, s + MaxId);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 0; i < q; i++) {
int u, v;
cin >> u >> v;
if (u > v) swap(u, v);
E[u].push_back(v);
}
build(0, 1, n);
for (int i = 0; i <= MaxId + n; i++) P[i] = i;
for (int i = 1; i <= n; i++) sort(E[i].begin(), E[i].end());
for (int i = 1; i <= n; i++) {
int last = i;
int pos = lower_bound(E[i].begin(), E[i].end(), last) - E[i].begin();
while (true) {
if (pos == E[i].size()) break;
int L = last + 1, R = E[i][pos];
if (L < R) upd(0, 1, n, L, R - 1, i);
last = R;
pos++;
}
int L = last + 1, R = n;
if (L <= R) {
upd(0, 1, n, L, R, i);
}
}
dnc(0, 1, n, 0);
for (int i = MaxId + 1; i <= MaxId + n; i++) {
Cnt[f(i)]++;
}
vector<int> son;
for (int i = MaxId + 1; i <= MaxId + n; i++) {
if (Cnt[f(i)] > 0) {
son.push_back(Cnt[f(i)]);
Cnt[f(i)] = 0;
}
}
sort(son.begin(), son.end());
cout << son.size() << endl;
for (int i = 0; i < son.size(); i++) {
if (i) cout << " ";
cout << son[i];
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, k, w, a, b;
long long t;
unordered_set<long long> edge;
long long f(int x, int y) { return 200001ll * min(x, y) + max(x, y); }
int p[200005], siz[200005], ans[200005];
int s, nxt[200005], pre[200005];
queue<int> Q;
void del(int x) {
int a, b;
a = pre[x];
b = nxt[x];
if (a == -1)
pre[b] = -1, s = b;
else {
pre[b] = a;
nxt[a] = b;
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = (0); i < (m); i++) {
scanf("%d %d", &x, &y);
t = f(x, y);
edge.insert(t);
}
for (int i = (1); i <= (n); i++) nxt[i] = i + 1, pre[i] = i - 1;
;
nxt[n] = -1;
pre[1] = -1;
s = 1;
for (int node = (1); node <= (n); node++) {
if (p[node] > 0) continue;
del(node);
Q.push(node);
while (!Q.empty()) {
x = Q.front();
p[x] = node;
Q.pop();
for (int i = s; i != -1; i = nxt[i]) {
if (edge.find(f(x, i)) == edge.end()) {
del(i);
Q.push(i);
}
}
}
}
w = 0;
for (int i = (1); i <= (n); i++) siz[p[i]]++;
for (int i = (1); i <= (n); i++)
if (siz[i] > 0) ans[w++] = siz[i];
sort(ans, ans + w);
printf("%d\n", w);
for (int i = (0); i < (w); i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, tot;
map<pair<int, int>, int> mp;
int vis[200010];
int ans[200010], len;
class Treap {
public:
struct treap_point {
int l, r, x, rep, son, rnd;
} t[200010];
int treesz, root;
inline void update(int k) {
t[k].son = t[t[k].l].son + t[t[k].r].son + t[k].rep;
}
inline void right_rotate(int &k) {
int tt = t[k].l;
t[k].l = t[tt].r;
t[tt].r = k;
update(k);
update(tt);
k = tt;
}
inline void left_rotate(int &k) {
int tt = t[k].r;
t[k].r = t[tt].l;
t[tt].l = k;
update(k);
update(tt);
k = tt;
}
inline void insert_to_tree(int &k, int x) {
if (!k) {
k = ++treesz;
t[k].x = x;
t[k].rnd = rand();
t[k].son = t[k].rep = 1;
t[k].l = t[k].r = 0;
return;
}
t[k].son++;
if (x == t[k].x) {
t[k].rep++;
return;
}
if (x < t[k].x) {
insert_to_tree(t[k].l, x);
if (t[t[k].l].rnd < t[k].rnd) right_rotate(k);
}
if (x > t[k].x) {
insert_to_tree(t[k].r, x);
if (t[t[k].r].rnd < t[k].rnd) left_rotate(k);
}
}
inline bool delete_from_tree(int &k, int x) {
if (!k) return 0;
if (x == t[k].x) {
if (t[k].rep > 1) {
t[k].rep--;
t[k].son--;
return 1;
}
if (!t[k].l || !t[k].r) {
k = t[k].l + t[k].r;
return 1;
}
if (t[t[k].l].rnd < t[t[k].r].rnd) {
right_rotate(k);
return delete_from_tree(k, x);
}
left_rotate(k);
return delete_from_tree(k, x);
}
int res;
if (x < t[k].x) {
res = delete_from_tree(t[k].l, x);
if (res) t[k].son--;
return res;
}
res = delete_from_tree(t[k].r, x);
if (res) t[k].son--;
return res;
}
inline int get_succ_in_tree(int k, int x) {
if (!k) return -1;
int sv;
if (x < t[k].x) {
sv = get_succ_in_tree(t[k].l, x);
return sv == -1 ? t[k].x : sv;
}
return get_succ_in_tree(t[k].r, x);
}
inline int get_pred_in_tree(int k, int x) {
if (!k) return -1;
int sv;
if (x > t[k].x) {
sv = get_pred_in_tree(t[k].r, x);
return sv == -1 ? t[k].x : sv;
}
return get_pred_in_tree(t[k].l, x);
}
inline int ask_kth_in_tree(int k, int x) {
if (!k) return -1;
if (x <= t[t[k].l].son) return ask_kth_in_tree(t[k].l, x);
if (x > t[t[k].l].son + t[k].rep)
return ask_kth_in_tree(t[k].r, x - t[t[k].l].son - t[k].rep);
return t[k].x;
}
inline int ask_rank_in_tree(int k, int x) {
if (!k) return -1;
if (x == t[k].x) return t[t[k].l].son + 1;
if (x < t[k].x) return ask_rank_in_tree(t[k].l, x);
return t[t[k].l].son + t[k].rep + ask_rank_in_tree(t[k].r, x);
}
inline void init() { treesz = root = 0; }
inline void insert(int x) { insert_to_tree(root, x); }
inline int del(int x) { return delete_from_tree(root, x); }
inline int succ(int x) { return get_succ_in_tree(root, x); }
inline int pred(int x) { return get_pred_in_tree(root, x); }
inline int ask_kth(int x) { return ask_kth_in_tree(root, x); }
inline int ask_rank(int x) { return ask_rank_in_tree(root, x); }
} T;
inline void dfs(int x) {
tot++;
vis[x] = 1;
T.del(x);
int now = T.ask_kth(1);
while (now != -1) {
if (!vis[now] && !mp[make_pair(x, now)]) dfs(now);
now = T.succ(now);
}
}
int main() {
T.init();
srand(time(0));
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
mp[make_pair(x, y)] = mp[make_pair(y, x)] = 1;
}
for (int i = 1; i <= n; i++) T.insert(i);
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i), ans[++len] = tot, tot = 0;
sort(ans + 1, ans + len + 1);
printf("%d\n", len);
for (int i = 1; i <= len; i++) printf("%d ", ans[i]);
puts("");
}
|
#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")
using namespace std;
int64_t mod = 1e9 + 7;
int64_t mod1 = 1e9 + 5;
int64_t power(int64_t a, int64_t b) {
if (b == 0)
return 1;
else if (b % 2 == 0)
return power((((a % mod) * (a % mod)) % mod), b / 2) % mod;
else
return ((a % mod) * (power((((a % mod) * (a % mod)) % mod), b / 2) % mod)) %
mod;
}
unordered_set<int64_t> v[200001];
bool vis[200001];
int64_t sz;
int64_t n, m;
unordered_set<int64_t> s;
unordered_set<int64_t> s1;
void dfs(int64_t u) {
vis[u] = true;
vector<int64_t> te;
for (auto it = s.begin(); it != s.end(); ++it) {
if (v[u].find(*it) == v[u].end() and vis[*it] == false) {
te.push_back(*it);
}
}
for (int64_t i = 0; i < te.size(); ++i) {
s.erase(te[i]);
}
for (int64_t i = 0; i < te.size(); ++i) dfs(te[i]), sz++;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int64_t i = 0; i < m; ++i) {
int64_t a, b;
cin >> a >> b;
v[a].insert(b);
v[b].insert(a);
}
memset(vis, false, sizeof(vis));
int64_t ans = 0;
for (int64_t i = 1; i <= n; ++i) s.insert(i);
vector<int64_t> fin;
for (int64_t i = 1; i <= n; ++i) {
if (vis[i] == false) {
sz = 0;
dfs(i), ans++;
fin.push_back(sz);
}
}
cout << ans << '\n';
sort(fin.begin(), fin.end());
for (int64_t i = 0; i < fin.size(); ++i) cout << fin[i] + 1 << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, nn = 0, nm = 0, dsu[200069], cc[200069], fq[200069], ls[200069],
vl[200069], rs[200069], sq[200069];
vector<long long> al[200069];
queue<long long> q;
long long fd(long long x) {
if (dsu[x] != x) {
dsu[x] = fd(dsu[x]);
}
return dsu[x];
}
int main() {
long long i, j, k, l, sz;
scanf("%lld%lld", &n, &m);
for (i = 0; i < m; i++) {
scanf("%lld%lld", &k, &l);
if (k > l) {
swap(k, l);
}
al[l].push_back(k);
}
for (i = 1; i <= n; i++) {
dsu[i] = i;
cc[i] = 1;
sz = al[i].size();
for (j = 0; j < sz; j++) {
l = al[i][j];
l = fd(l);
if (ls[l] < i) {
fq[l] = 0;
ls[l] = i;
}
fq[l]++;
}
nm = 0;
for (j = 1; j <= nn; j++) {
if (ls[vl[j]] < i || fq[vl[j]] < cc[vl[j]]) {
cc[i] += cc[vl[j]];
dsu[vl[j]] = i;
} else {
nm++;
rs[nm] = vl[j];
}
}
nm++;
rs[nm] = i;
nn = nm;
for (j = 1; j <= nm; j++) {
vl[j] = rs[j];
}
}
for (i = 1; i <= nn; i++) {
sq[i] = cc[vl[i]];
}
sort(sq + 1, sq + nn + 1);
printf("%lld\n", nn);
for (i = 1; i <= nn; i++) {
printf("%lld%c", sq[i], " \n"[i == nn]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
inline void chmax(int &x, int y) { x = max(x, y); }
inline void chmin(int &x, int y) { x = min(x, y); }
inline void pls(int &x, int y, int Mod) {
x = (x + y >= Mod) ? (x + y - Mod) : (x + y);
}
inline void red(int &x, int y, int Mod) {
x = (x - y < 0) ? (x - y + Mod) : (x - y);
}
const int MAXN = 200005;
int n, m;
vector<int> G[MAXN];
int fa[MAXN];
inline int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
pair<int, int> lk[MAXN];
inline void del(int x) {
lk[lk[x].first].second = lk[x].second;
lk[lk[x].second].first = lk[x].first;
}
bool vis1[MAXN], vis2[MAXN];
int cnt[MAXN];
signed main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
fa[i] = i;
lk[i - 1].second = i;
lk[i].first = i - 1;
}
queue<int> q;
while (lk[0].second) {
int now = lk[0].second;
del(now);
q.push(now);
while (!q.empty()) {
int p = q.front();
q.pop();
vis1[p] = true;
for (int i : G[p])
if (!vis1[i]) vis2[i] = true;
int cur = lk[0].second;
while (cur) {
if (!vis2[cur]) {
fa[find(cur)] = find(p);
del(cur);
q.push(cur);
}
cur = lk[cur].second;
}
for (int i : G[p]) vis2[i] = false;
}
}
vector<int> ans;
memset(vis1, false, sizeof(vis1));
for (int i = 1; i <= n; i++) cnt[find(i)]++;
for (int i = 1; i <= n; i++)
if (cnt[i]) ans.push_back(cnt[i]);
sort(ans.begin(), ans.end());
cout << (int)ans.size() << endl;
for (int i : ans) cout << i << ' ';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> st;
set<int> v[200005];
int cnt;
void dfs(int s) {
cnt++;
st.erase(s);
vector<int> next;
for (auto it = st.begin(); it != st.end(); it++) {
int val = *it;
if (!v[s].count(val)) {
next.push_back(val);
}
}
for (auto val : next) st.erase(val);
for (auto x : next) dfs(x);
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
v[x].insert(y);
v[y].insert(x);
}
for (int i = 1; i <= n; i++) st.insert(i);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (st.count(i)) {
cnt = 0;
dfs(i);
ans.push_back(cnt);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (auto val : ans) cout << val << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, m;
int l[maxn];
int r[maxn];
vector<int> G[maxn];
int res[maxn], tmp;
void bfs(int s) {
queue<int> Q;
Q.push(s);
r[l[s]] = r[s];
l[r[s]] = l[s];
tmp++;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
int sz = G[u].size();
for (int i = r[0], j = 0; i != n + 1; i = r[i]) {
while (j < sz && G[u][j] < i) j++;
if (j < sz && G[u][j] == i)
j++;
else {
Q.push(i);
tmp++;
r[l[i]] = r[i];
l[r[i]] = l[i];
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++) l[i] = i - 1, r[i] = i + 1;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) sort(G[i].begin(), G[i].end());
res[0] = 0;
while (r[0] != n + 1) {
tmp = 0;
bfs(r[0]);
res[++res[0]] = tmp;
}
sort(res + 1, res + res[0] + 1);
printf("%d\n", res[0]);
for (int i = 1; i <= res[0]; i++) {
if (i != 1) printf(" ");
printf("%d", res[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int degree[200001];
struct MNode {
int x;
int y;
MNode() {}
MNode(int a, int b) : x(a), y(b) {}
bool operator==(MNode &b) const { return x == b.x && y == b.y; }
bool operator<(MNode b) const { return x < b.x || (x == b.x && y < b.y); }
};
bool cmp1(MNode &a, MNode &b) {
return (a.x < b.x || (a.x == b.x && a.y < b.y));
}
bool cmp2(const MNode &a, const MNode &b) {
return (a.y < b.y || (a.y == b.y && a.x < b.x));
}
int n, m;
multiset<int> result;
set<MNode> M;
void star(int i, const set<int> &u, set<int> &ai, set<int> &mi) {
ai = u;
mi.clear();
for (set<MNode>::iterator it = M.lower_bound(MNode(i, 0));
it != M.upper_bound(MNode(i + 1, 0)); it++) {
if (it->x == i && u.find(it->y) != u.end()) {
mi.insert(it->y);
ai.erase(it->y);
}
}
}
int CountM(const set<int> &u) {
int c = 0;
for (set<MNode>::iterator it = M.begin(); it != M.end(); it++) {
if (u.find(it->x) != u.end() && u.find(it->y) != u.end()) c++;
}
c /= 2;
}
void UpdateDegree(const set<int> &u, int &dmin, int &dmax) {
for (int i = 1; i <= n; i++) degree[i] = (i - 1);
for (set<MNode>::iterator it = M.begin(); it != M.end(); it++) {
if (u.find(it->x) != u.end()) degree[it->x]--;
}
dmin = 0x7fffffff;
dmax = 0;
for (int i = 1; i <= n; i++) {
if (degree[i] < dmin) dmin = degree[i];
if (degree[i] > dmax) dmax = degree[i];
}
}
void UpdateMNode(const set<int> &u) {
for (set<MNode>::iterator it = M.begin(); it != M.end();) {
if (u.find(it->x) == u.end() || u.find(it->y) == u.end())
M.erase(it++);
else
it++;
}
}
int parent[200001], coun[200001];
void InitUF() {
for (int i = 1; i <= n; i++) {
parent[i] = i;
coun[i] = 1;
}
}
int Find(int x) { return (parent[x] == x) ? x : (parent[x] = Find(parent[x])); }
void Union(int x, int y) {
int i = Find(x);
int j = Find(y);
if (i != j) {
if (coun[i] < coun[j]) {
parent[i] = j;
coun[j] += coun[i];
} else {
parent[j] = i;
coun[i] += coun[j];
}
}
}
void DSU(set<int> &u) {
int a[700][700];
int i, j, ii[700];
map<int, int> mp;
i = 1;
for (set<int>::iterator it = u.begin(); it != u.end(); it++) {
mp.insert(pair<int, int>(*it, i));
ii[i++] = *it;
}
memset(a, 0, sizeof(a));
for (set<MNode>::iterator it = M.begin(); it != M.end(); it++) {
if (it->x < it->y && u.find(it->x) != u.end() && u.find(it->y) != u.end()) {
map<int, int>::iterator itm;
i = mp.find(it->x)->second;
j = mp.find(it->y)->second;
a[i][j] = a[j][i] = 1;
}
}
InitUF();
for (int i = 1; i <= u.size(); i++) {
int x = ii[i];
for (int j = i + 1; j <= u.size(); j++) {
int y = ii[j];
if (a[i][j] == 0) Union(x, y);
}
}
for (set<int>::iterator it = u.begin(); it != u.end(); it++)
if (parent[*it] == *it) result.insert(coun[*it]);
}
int main() {
int a, b;
set<int> u, s, t, r, tmp;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
if (a != b) {
M.insert(MNode(a, b));
M.insert(MNode(b, a));
}
}
m = M.size() / 2;
int dmin, dmax;
for (int i = 1; i <= n; i++) u.insert(i);
do {
UpdateMNode(u);
UpdateDegree(u, dmin, dmax);
if (u.size() < 700) {
DSU(u);
break;
}
set<int>::iterator it, it0 = u.begin();
for (it = u.begin(); it != u.end(); it++) {
if (degree[*it] > degree[*it0]) it0 = it;
}
star(*it0, u, s, r);
bool update;
do {
update = false;
for (set<int>::iterator it = r.begin(); it != r.end(); it++) {
set<int> r1;
star(*it, u, t, r1);
if (s.find(*it) != s.end())
set_union(s.begin(), s.end(), t.begin(), t.end(),
inserter(s, s.begin()));
else {
tmp.clear();
set_intersection(s.begin(), s.end(), t.begin(), t.end(),
inserter(tmp, tmp.begin()));
if (!tmp.empty()) {
update = true;
set_union(s.begin(), s.end(), t.begin(), t.end(),
inserter(s, s.begin()));
}
}
}
if (update) {
r.clear();
set_difference(u.begin(), u.end(), s.begin(), s.end(),
inserter(r, r.begin()));
}
} while (update);
result.insert(s.size());
if (r.empty()) break;
u = r;
} while (1);
printf("%d\n", result.size());
for (multiset<int>::iterator it = result.begin(); it != result.end(); it++)
printf("%d ", *it);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
const long long int mod = 9999999999999983;
long long int primes[6] = {1125899906842597, 1495921043, 1005985879,
1495921043, 1005985879, 1495921043};
using namespace std;
set<long long int> adj[2000009];
set<long long int> st;
multiset<long long int> vect;
multiset<long long int>::iterator it1;
set<long long int>::iterator it;
long long int cnt = 0;
void dfs(long long int val) {
st.erase(val);
cnt++;
long long int curr = -1;
while (1) {
it = st.upper_bound(curr);
curr = (*it);
if (it == st.end()) break;
if (adj[val].find(*it) == adj[val].end()) {
dfs(*it);
}
}
}
int main() {
int start_s = clock();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k, n, m, u, v;
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
}
for (i = 1; i <= n; i++) {
st.insert(i);
}
for (i = 1; i <= n; i++) {
if (st.find(i) != st.end()) {
cnt = 0;
dfs(i);
vect.insert(cnt);
}
}
cout << vect.size() << endl;
for (it1 = vect.begin(); it1 != vect.end(); it1++) cout << *it1 << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, bool> mp[2000000];
vector<int> u, ans;
int bfs(int x) {
int res = 0;
queue<int> q;
q.push(x);
while (q.size()) {
int c = q.front();
q.pop();
res++;
for (int i = 0; i < u.size(); i++) {
int v = u[i];
if (mp[c].count(v) == 0) {
swap(u[i], u.back());
u.pop_back();
i--;
q.push(v);
}
}
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) u.push_back(i);
for (int x, y, i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
mp[x][y] = 1;
mp[y][x] = 1;
}
while (!u.empty()) {
int v = u.back();
u.pop_back();
int cnt = bfs(v);
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;
int n, m;
vector<int> ans;
set<int> s, e[200005];
set<int>::iterator p;
queue<int> q;
int bfs(int x) {
s.erase(x);
q.push(x);
int cnt = 0, u, v;
while (!q.empty()) {
u = q.front();
q.pop();
cnt++;
for (p = s.begin(); p != s.end();) {
v = (*p);
if (e[u].count(v)) {
p++;
continue;
}
q.push(v);
s.erase(p++);
}
}
return cnt;
}
int main() {
cin >> n >> m;
int u, v;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
e[u].insert(v);
e[v].insert(u);
}
for (int i = 1; i <= n; i++) {
s.insert(i);
}
for (int i = 1; i <= n; i++) {
if (s.count(i)) {
ans.push_back(bfs(i));
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, m;
int mark[MAXN];
int mark2[MAXN];
vector<int> mapp[MAXN];
vector<int> ans;
queue<int> qqq;
list<int> lli;
void bfs(int be) {
int cnt = 1;
qqq.push(be);
mark[be] = 1;
list<int>::iterator it;
while (!qqq.empty()) {
int tt = qqq.front();
qqq.pop();
for (auto u : mapp[tt]) mark2[u] = 1;
for (it = lli.begin(); it != lli.end();) {
if (!mark[*it] && !mark2[*it]) {
qqq.push(*it);
mark[*it] = 1;
lli.erase(it++);
cnt++;
} else
it++;
}
for (auto u : mapp[tt]) mark2[u] = 0;
}
ans.push_back(cnt);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> m;
int u, v;
for (int i = 1; i <= m; ++i) {
cin >> u >> v;
mapp[u].push_back(v);
mapp[v].push_back(u);
}
for (int i = 1; i <= n; ++i) lli.push_back(i);
for (int i = 1; i <= n; ++i) {
if (mark[i]) continue;
bfs(i);
}
cout << ans.size() << endl;
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); ++i) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
const int inf = 0x3f3f3f3f;
inline int read() {
register int s = 0;
register bool neg = 0;
register char c = getchar();
for (; c < '0' || c > '9'; c = getchar()) neg |= (c == '-');
for (; c >= '0' && c <= '9'; s = s * 10 + (c ^ 48), c = getchar())
;
return (neg ? -s : s);
}
int a, b, in[N + 10], fa[N + 10], scc, bel[N + 10], siz[N + 10];
bool vis[N + 10], vis1[N + 10];
vector<int> st[N + 10];
inline int f(int n) { return fa[n] == n ? n : fa[n] = f(fa[n]); }
signed main() {
a = read();
b = read();
int x, y;
for (int i = 1; i <= b; i++) {
x = read();
y = read();
st[x].push_back(y);
st[y].push_back(x);
in[x]++;
in[y]++;
}
int mx = 1;
for (int i = 1; i <= a; i++) fa[i] = i;
for (int i = 2; i <= a; i++)
if (in[i] < in[mx]) mx = i;
for (int i = 0; i < st[mx].size(); i++) vis[st[mx][i]] = 1;
for (int i = 1; i <= a; i++)
if (!vis[i]) fa[i] = mx;
for (int i = 1; i <= a; i++) {
if (!vis[i] || i == mx) continue;
memset(vis1, 0, sizeof(vis1));
int f1 = f(i);
for (int j = 0; j < st[i].size(); j++) vis1[st[i][j]] = 1;
for (int j = 1; j <= a; j++)
if (!vis1[j]) fa[f(j)] = f1;
}
for (int i = 1; i <= a; i++)
if (fa[i] == i) bel[i] = ++scc;
for (int i = 1; i <= a; i++) siz[bel[f(i)]]++;
sort(siz + 1, siz + scc + 1);
printf("%d\n", scc);
for (int i = 1; i <= scc; i++) printf("%d ", siz[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename T1>
ostream &operator<<(ostream &out, pair<T, T1> obj) {
out << "(" << obj.first << "," << obj.second << ")";
return out;
}
template <typename T, typename T1>
ostream &operator<<(ostream &out, map<T, T1> cont) {
typename map<T, T1>::const_iterator itr = cont.begin();
typename map<T, T1>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T>
ostream &operator<<(ostream &out, set<T> cont) {
typename set<T>::const_iterator itr = cont.begin();
typename set<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T>
ostream &operator<<(ostream &out, multiset<T> cont) {
typename multiset<T>::const_iterator itr = cont.begin();
typename multiset<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T,
template <typename ELEM, typename ALLOC = allocator<ELEM>> class CONT>
ostream &operator<<(ostream &out, CONT<T> cont) {
typename CONT<T>::const_iterator itr = cont.begin();
typename CONT<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
return out;
}
template <typename T, unsigned int N, typename CTy, typename CTr>
typename enable_if<!is_same<T, char>::value, basic_ostream<CTy, CTr> &>::type
operator<<(basic_ostream<CTy, CTr> &out, const T (&arr)[N]) {
for (auto i = 0; i < N; ++i) out << arr[i] << " ";
out << endl;
return out;
}
template <typename T>
T gcd(T a, T b) {
T min_v = min(a, b);
T max_v = max(a, b);
while (min_v) {
T temp = max_v % min_v;
max_v = min_v;
min_v = temp;
}
return max_v;
}
template <typename T>
T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
template <typename T>
T fast_exp_pow(T base, T exp, T mod) {
T res = 1;
while (exp) {
if (exp & 1) {
res *= base;
res %= mod;
}
exp >>= 1;
base *= base;
base %= mod;
}
return res % mod;
}
int N, M, X, Y;
int Parent[200010], Rank[200010], counts[200010];
set<int> non_neigh[200010];
vector<int> leaders, leaders_count;
int Find(int node) {
return Parent[node] = (Parent[node] != node ? Find(Parent[node]) : node);
}
void Union(int nde_1, int nde_2) {
if (Rank[nde_1] >= Rank[nde_2]) {
Parent[nde_2] = nde_1;
Rank[nde_1] += Rank[nde_2];
} else {
Parent[nde_1] = nde_2;
Rank[nde_2] += Rank[nde_1];
}
}
int main() {
scanf("%d%d", &N, &M);
for (auto i = 0; i < M; ++i) {
scanf("%d%d", &X, &Y);
non_neigh[X].insert(Y);
non_neigh[Y].insert(X);
}
for (auto i = 1; i <= N; ++i) {
non_neigh[i].insert(i);
Parent[i] = i;
Rank[i] = 1;
}
for (auto i = 1; i <= N; ++i) {
int node = 1;
auto itr = non_neigh[i].begin();
for (auto t = 1; t <= 5; ++t) {
while (itr != non_neigh[i].end() && node == *itr) {
++node, ++itr;
}
if (node > N) {
continue;
}
non_neigh[node].insert(i);
int par_1 = Find(i);
int par_2 = Find(node);
if (par_1 != par_2) {
Union(par_1, par_2);
}
++node;
}
}
int comp = 0;
for (auto i = 1; i <= N; ++i) {
int par = Find(i);
if (par == i) {
leaders.push_back(i);
}
++counts[par];
}
printf("%d\n", (int)leaders.size());
for (auto elem : leaders) {
leaders_count.push_back(counts[elem]);
}
sort(leaders_count.begin(), leaders_count.end());
for (auto elem : leaders_count) {
printf("%d ", elem);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f * x;
}
list<int> vec;
list<int>::iterator ite;
bool vis[200005];
vector<int> v_[200005];
int ans[200005];
queue<int> que;
bool cn[200005];
int n, m;
void bfs(int t, int e) {
while (!que.empty()) que.pop();
que.push(t);
while (!que.empty()) {
int v = que.front();
que.pop();
if (vis[v]) continue;
vis[v] = 1;
ans[e]++;
for (int i = 0; i < v_[v].size(); i++) cn[v_[v][i]] = 1;
for (ite = vec.begin(); ite != vec.end();) {
int u = (*ite);
if (!cn[u]) {
que.push(u);
vec.erase(ite++);
} else
ite++;
}
for (int i = 0; i < v_[v].size(); i++) cn[v_[v][i]] = 0;
}
}
int main() {
ios::sync_with_stdio(false);
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) vec.push_back(i);
int t1, t2;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &t1, &t2);
v_[t1].push_back(t2);
v_[t2].push_back(t1);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cnt++;
bfs(i, cnt);
}
}
printf("%d\n", cnt);
sort(ans + 1, ans + cnt + 1);
for (int i = 1; i <= cnt; i++) {
if (i == 1)
printf("%d", ans[i]);
else
printf(" %d", ans[i]);
}
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 111;
set<int> g[N], fr;
int n, m, i1, i2, cnt;
vector<int> ans;
void dfs(int v) {
fr.erase(v);
cnt++;
int cur = -1;
while (!fr.empty()) {
auto it = fr.upper_bound(cur);
if (it == fr.end()) break;
int to = *it;
cur = to;
if (g[v].find(to) == g[v].end()) dfs(to);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &i1, &i2);
i1--;
i2--;
g[i1].insert(i2);
g[i2].insert(i1);
}
for (int i = 0; i < n; i++) fr.insert(i);
for (int i = 0; i < n; i++)
if (fr.find(i) != fr.end()) {
cnt = 0;
dfs(i);
ans.push_back(cnt);
}
sort(ans.begin(), ans.end());
printf("%d\n", (int)ans.size());
for (int i = 0; i < (int)ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<int> edge[200010];
queue<int> vertices;
vector<int> trace, ans;
void Gb() {
trace.push_back(1);
n--;
int bd = 0, kt = 0, x, y, lim, dem = 1;
while (n != false) {
if (bd > kt) {
ans.push_back(dem), dem = 1;
n--, kt++;
trace.push_back(vertices.front());
vertices.pop();
}
x = trace[bd];
lim = n;
while (lim--) {
y = vertices.front();
vertices.pop();
if (edge[x].find(y) == edge[x].end()) {
kt++, n--, dem++;
trace.push_back(y);
} else {
vertices.push(y);
}
}
bd++;
}
ans.push_back(dem);
}
int main() {
int x, y;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
edge[x].insert(y);
edge[y].insert(x);
}
for (int i = 2; i <= n; i++) vertices.push(i);
Gb();
sort(ans.begin(), ans.end());
cout << ans.end() - ans.begin() << endl;
for (auto i : ans) {
cout << i << " ";
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.