solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
inline void upd1(T1& a, const T2& b) {
a = a < b ? a : b;
}
template <class T1, class T2>
inline void upd2(T1& a, const T2& b) {
a = a > b ? a : b;
}
template <class T>
inline bool equ(const T& a, const T& b) {
return !memcmp(&a, &b, sizeof a);
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct ano {
operator long long() {
long long x = 0, y = 0, c = getchar();
while (c < 48) y = c == 45, c = getchar();
while (c > 47) x = x * 10 + c - 48, c = getchar();
return y ? -x : x;
}
} buf;
const int N = 2e5 + 5;
set<int> t[N];
int d[N], f[N];
int main() {
int n = buf, m = buf, k = buf;
vector<array<int, 2>> e;
set<array<int, 2>> c;
for (int i = 0; i < m; ++i) {
int u = buf, v = buf;
if (u > v) swap(u, v);
c.insert({u, v});
e.push_back({u, v});
t[u].insert(v);
t[v].insert(u);
++d[u];
++d[v];
}
queue<int> q;
for (int i = 1; i <= n; ++i)
if (d[i] < k) q.push(i);
int s = n;
for (int i = m - 1; ~i; --i) {
while (q.size()) {
int u = q.front();
q.pop();
for (int v : t[u]) {
c.erase({min(u, v), max(u, v)});
t[v].erase(u);
if (d[v]-- == k) q.push(v);
}
--s;
}
f[i] = s;
if (c.count(e[i])) {
int u = e[i][0], v = e[i][1];
t[u].erase(v);
t[v].erase(u);
if (d[u]-- == k) q.push(u);
if (d[v]-- == k) q.push(v);
}
}
for (int i = 0; i < m; ++i) printf("%d\n", f[i]);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
vector<pair<int, int> > e;
set<pair<int, int> > f;
vector<int> adj[MAXN];
int n, m, k, deg[MAXN], num;
bool kicked[MAXN];
vector<int> ans;
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
e.push_back(pair<int, int>(u, v));
f.insert(pair<int, int>(u, v));
adj[u].push_back(v);
adj[v].push_back(u);
deg[u]++;
deg[v]++;
}
num = n;
queue<int> q;
for (int i = 1; i <= n; ++i) {
if (deg[i] < k) {
q.push(i);
}
}
while (!q.empty()) {
int top = q.front();
q.pop();
if (kicked[top]) continue;
kicked[top] = true;
num--;
for (int j : adj[top])
if (f.count(pair<int, int>(top, j)) + f.count(pair<int, int>(j, top)) ==
1) {
deg[j]--;
f.erase(pair<int, int>(j, top));
f.erase(pair<int, int>(top, j));
if (deg[j] < k) {
q.push(j);
}
}
}
reverse(e.begin(), e.end());
for (pair<int, int> i : e) {
ans.push_back(num);
if (f.count(i) == 0) continue;
deg[i.first]--;
deg[i.second]--;
f.erase(i);
queue<int> q;
if (deg[i.first] < k && !kicked[i.first]) q.push(i.first);
if (deg[i.second] < k && !kicked[i.second]) q.push(i.second);
while (!q.empty()) {
int top = q.front();
q.pop();
if (kicked[top]) continue;
kicked[top] = true;
num--;
for (int j : adj[top])
if (f.count(pair<int, int>(top, j)) + f.count(pair<int, int>(j, top)) ==
1) {
deg[j]--;
f.erase(pair<int, int>(j, top));
f.erase(pair<int, int>(top, j));
if (deg[j] < k) {
q.push(j);
}
}
}
}
reverse(ans.begin(), ans.end());
for (int i : ans) printf("%d\n", i);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
set<int> e[N];
int deg[N], x[N], y[N], ans[N], q[N], del[N];
int n, m, k, tail = 0, head = 1;
void delv(int u) {
if (deg[u] >= k || del[u]) return;
del[u] = 1;
q[++tail] = u;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", x + i, y + i);
e[x[i]].insert(y[i]);
e[y[i]].insert(x[i]);
++deg[x[i]], ++deg[y[i]];
}
for (int i = 1; i <= n; ++i) delv(i);
for (int i = m; i >= 1; --i) {
while (head <= tail) {
int u = q[head++];
for (auto &v : e[u]) {
--deg[v];
delv(v);
e[v].erase(u);
}
}
ans[i] = n - tail;
if (!del[x[i]] && !del[y[i]]) {
--deg[x[i]], --deg[y[i]];
delv(x[i]), delv(y[i]);
e[x[i]].erase(y[i]);
e[y[i]].erase(x[i]);
}
}
for (int i = 1; i <= m; ++i) printf("%d%c", ans[i], " \n"[i == m]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct DATA {
int first, second;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
vector<vector<int>> adj(n + 1);
vector<int> degree(n + 1, 0);
set<pair<int, int>> good_set;
vector<bool> check(n + 1, true);
vector<int> ans(m + 1, true);
vector<DATA> edge(m + 1);
check[0] = false;
for (int i = 1; i <= m; ++i) {
cin >> edge[i].first >> edge[i].second;
adj[edge[i].first].push_back(edge[i].second);
adj[edge[i].second].push_back(edge[i].first);
degree[edge[i].first]++;
degree[edge[i].second]++;
}
for (int i = 1; i <= n; ++i) {
good_set.insert(pair<int, int>(degree[i], i));
}
while (!good_set.empty() && good_set.begin()->first < k) {
int node = good_set.begin()->second;
for (int i = 0; i < adj[node].size(); ++i) {
int v = adj[node][i];
if (check[v]) {
good_set.erase(pair<int, int>(degree[v], v));
--degree[v];
good_set.insert(pair<int, int>(degree[v], v));
}
}
good_set.erase(pair<int, int>(degree[node], node));
check[node] = false;
}
ans[m] = good_set.size();
for (int i = m; i > 1; --i) {
int x = edge[i].first;
int y = edge[i].second;
if (check[x] && check[y]) {
good_set.erase(pair<int, int>(degree[x], x));
degree[x]--;
good_set.insert(pair<int, int>(degree[x], x));
good_set.erase(pair<int, int>(degree[y], y));
degree[y]--;
good_set.insert(pair<int, int>(degree[y], y));
adj[x].erase(std::remove(adj[x].begin(), adj[x].end(), y), adj[x].end());
adj[y].erase(std::remove(adj[y].begin(), adj[y].end(), x), adj[y].end());
while (!good_set.empty() && good_set.begin()->first < k) {
int node = good_set.begin()->second;
for (int j = 0; j < adj[node].size(); ++j) {
int v = adj[node][j];
if (check[v]) {
good_set.erase(pair<int, int>(degree[v], v));
--degree[v];
good_set.insert(pair<int, int>(degree[v], v));
}
}
good_set.erase(pair<int, int>(degree[node], node));
check[node] = false;
}
}
ans[i - 1] = good_set.size();
}
for (int i = 1; i <= m; ++i) cout << ans[i] << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, k, l, i, ans, a[N], b[N], in[N], x[N], y[N], z[N], head[N], go[N + N],
Next[N + N];
bool f[N], use[N + N];
inline void Add(int u, int v) {
Next[++l] = head[u], head[u] = l, go[l] = v, use[l] = 1;
}
inline void bfs(int x) {
int l, r, j, u, v;
if (in[x] >= k || !f[x]) return;
for (b[l = r = 1] = x, f[x] = 0, ans--; l <= r; l++) {
for (j = head[u = b[l]]; j; j = Next[j]) {
if (!use[j]) continue;
in[v = go[j]]--, in[u]--;
use[j] = use[j ^ 1] = 0;
if (f[v] && in[v] < k) b[++r] = v, f[v] = 0, ans--;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (l = 1, i = 1; i <= m; i++)
scanf("%d%d", &x[i], &y[i]), Add(x[i], y[i]), Add(y[i], x[i]),
z[i] = l, in[x[i]]++, in[y[i]]++;
memset(f, 1, sizeof(f));
for (ans = n, i = 1; i <= n; i++) bfs(i);
for (i = m; i; i--) {
a[i] = ans;
if (!use[z[i]]) continue;
in[x[i]]--, in[y[i]]--, use[z[i]] = use[z[i] ^ 1] = 0;
bfs(x[i]), bfs(y[i]);
}
for (i = 1; i <= m; i++) printf("%d\n", a[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, cnt;
struct Edge {
int u, v;
};
vector<Edge> vE;
vector<int> ans;
const int maxN = 2 * 100000 + 1;
set<int> edge[maxN];
set<int> nodes;
queue<int> Q;
int do_remove() {
while (!Q.empty()) {
int s = Q.front();
Q.pop();
if (edge[s].size() < k) {
for (auto iter1 = edge[s].begin(); iter1 != edge[s].end(); iter1++) {
int t = *iter1;
edge[t].erase(s);
if (edge[t].size() < k) Q.push(t);
}
edge[s].clear();
auto iter = nodes.find(s);
if (iter != nodes.end()) nodes.erase(iter);
};
}
return nodes.size();
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) nodes.insert(i);
cnt = n;
for (int i = 0; i < m; i++) {
int s, t;
cin >> s >> t;
vE.push_back(Edge{s, t});
edge[s].insert(t);
edge[t].insert(s);
}
for (int i = 1; i <= n; i++)
if (edge[i].size() < k) Q.push(i);
int ret = do_remove();
ans.push_back(ret);
for (int i = vE.size() - 1; i >= 1; i--) {
int s = vE[i].u;
int t = vE[i].v;
edge[s].erase(t);
edge[t].erase(s);
Q.push(s);
Q.push(t);
int ret = do_remove();
ans.push_back(ret);
}
for (int i = ans.size() - 1; i >= 0; i--) {
cout << ans[i] << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MN = 2e5 + 5;
int n, m, k, x, y;
set<int> al[MN], t;
vector<pair<int, int> > el;
void del(int u) {
if (!t.count(u) || al[u].size() >= k) return;
t.erase(u);
for (int v : al[u]) al[v].erase(u);
for (int v : al[u])
if (al[v].size() < k) del(v);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> x >> y;
el.push_back(pair<int, int>(x, y));
al[x].insert(y);
al[y].insert(x);
}
for (int i = 1; i <= n; i++) t.insert(i);
for (int i = 1; i <= n; i++) del(i);
int res[m + 1];
for (int i = el.size() - 1; i >= 0; i--) {
res[i] = t.size();
pair<int, int> e = el[i];
int x = e.first, y = e.second;
al[x].erase(y);
al[y].erase(x);
del(x);
del(y);
}
for (int i = 0; i < m; i++) {
cout << res[i] << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const int MAX = 200005;
int ans[MAX];
vector<int> P[MAX];
pair<int, int> edges[MAX];
bool O[MAX];
int SZ[MAX];
set<pair<int, int> > wziete;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m, k;
cin >> n >> m >> k;
int akt = 0;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
SZ[a]++;
SZ[b]++;
edges[i] = make_pair(a, b);
P[a].push_back(b);
P[b].push_back(a);
}
queue<int> Q;
for (int i = 1; i <= n; i++) {
if (O[i]) continue;
if (P[i].size() < k) {
O[i] = true;
Q.push(i);
}
}
while (!Q.empty()) {
int aktuell = Q.front();
Q.pop();
for (auto it : P[aktuell]) {
int l1 = it;
int l2 = aktuell;
if (l1 > l2) swap(l1, l2);
if (wziete.find(make_pair(l1, l2)) != wziete.end()) continue;
if (!O[it] && SZ[it] - 1 < k) {
O[it] = true;
Q.push(it);
}
SZ[it]--;
wziete.insert(make_pair(l1, l2));
}
}
for (int i = 1; i <= n; i++)
if (!O[i]) akt++;
ans[m] = akt;
for (int i = m; i >= 2; i--) {
int a = edges[i].first;
int b = edges[i].second;
if (a > b) swap(a, b);
if (wziete.find(make_pair(a, b)) != wziete.end()) {
ans[i - 1] = akt;
continue;
}
wziete.insert(make_pair(a, b));
SZ[a]--;
SZ[b]--;
if (!O[a] && SZ[a] < k) {
O[a] = true;
Q.push(a);
akt--;
}
if (!O[b] && SZ[b] < k) {
O[b] = true;
Q.push(b);
akt--;
}
while (!Q.empty()) {
int aktuell = Q.front();
Q.pop();
for (auto it : P[aktuell]) {
int l1 = it;
int l2 = aktuell;
if (l1 > l2) swap(l1, l2);
if (wziete.find(make_pair(l1, l2)) != wziete.end()) continue;
if (!O[it] && SZ[it] - 1 < k) {
O[it] = true;
Q.push(it);
akt--;
}
SZ[it]--;
wziete.insert(make_pair(l1, l2));
}
}
ans[i - 1] = akt;
}
for (int i = 1; i <= m; i++) cout << ans[i] << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, cnt[222222], x[222222], y[222222], all, idx[222222], idy[222222],
ans[222222];
bool used[222222];
vector<pair<int, int> > g[222222];
void upd(int i) {
used[i] = 1;
all--;
for (int j = 0; j < g[i].size(); j++) {
if (!g[i][j].second) continue;
cnt[g[i][j].first]--;
if (used[g[i][j].first]) continue;
if (cnt[g[i][j].first] < k) upd(g[i][j].first);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x[i], &y[i]);
idx[i] = g[x[i]].size();
idy[i] = g[y[i]].size();
g[x[i]].push_back(make_pair(y[i], 1));
g[y[i]].push_back(make_pair(x[i], 1));
}
all = n;
for (int i = 1; i <= n; i++) cnt[i] = g[i].size();
for (int i = 1; i <= n; i++) {
if (!used[i] && cnt[i] < k) upd(i);
}
ans[m] = all;
for (int i = m; i >= 2; i--) {
g[x[i]][idx[i]].second = 0;
g[y[i]][idy[i]].second = 0;
if (used[x[i]] | used[y[i]]) {
ans[i - 1] = all;
continue;
}
cnt[x[i]]--;
cnt[y[i]]--;
if (cnt[x[i]] < k) upd(x[i]);
if (!used[y[i]] && cnt[y[i]] < k) upd(y[i]);
ans[i - 1] = all;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mx = 2e5 + 10, cut = 700;
int n, m, k, cnt[mx], lv, x[mx], y[mx], dead[mx];
vector<pair<int, int> > adj[mx];
vector<int> res;
void er(int a, int b) {
auto it = lower_bound(adj[a].begin(), adj[a].end(), make_pair(b, 0));
if (it->second) return;
it->second = 1;
cnt[a]--;
}
void f(int h) {
if (cnt[h] >= k || dead[h]) return;
dead[h] = 1;
lv--;
for (auto &it : adj[h])
if (!it.second) er(it.first, h);
for (auto &it : adj[h])
if (!it.second) f(it.first);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
if (k > cut) {
for (int i = 0; i < m; i++) puts("0");
return 0;
}
for (int i = 0; i < m; i++) {
scanf("%d%d", x + i, y + i);
cnt[x[i]]++;
cnt[y[i]]++;
adj[x[i]].push_back({y[i], 0});
adj[y[i]].push_back({x[i], 0});
}
for (int i = 1; i <= n; i++) sort(adj[i].begin(), adj[i].end());
lv = n;
for (int i = 1; i <= n; i++) f(i);
for (int i = m; i--;) {
res.push_back(lv);
er(x[i], y[i]);
er(y[i], x[i]);
f(x[i]);
f(y[i]);
}
reverse(res.begin(), res.end());
for (auto &it : res) printf("%d\n", it);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
template <class T>
using MinHeap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
const int MAX_N = 2e5 + 7;
struct bg_edge {
int a, b;
} edges[MAX_N];
struct bg_state {
int node;
long unsigned int deg;
bool operator>(const bg_state& o) const { return deg > o.deg; }
};
static inline void setio(void);
int n, m;
long unsigned int k;
std::set<int> gr[MAX_N];
int ans[MAX_N], in[MAX_N];
int main(void) {
setio();
memset(in, 1, sizeof(in));
std::cin >> n >> m >> k;
for (int i = 0, a, b; i < m; ++i) {
std::cin >> a >> b;
--a;
--b;
gr[a].insert(b);
gr[b].insert(a);
edges[i] = {a, b};
}
MinHeap<bg_state> pq;
for (int i = 0; i < n; ++i) pq.push(bg_state{i, gr[i].size()});
std::function<int(void)> doit = [&](void) {
int rem = 0;
while (pq.size() && pq.top().deg < k) {
bg_state now = pq.top();
pq.pop();
if (now.deg != gr[now.node].size() || !in[now.node]) continue;
++rem;
in[now.node] = false;
for (const auto& nei : gr[now.node]) {
gr[nei].erase(now.node);
pq.push(bg_state{nei, gr[nei].size()});
}
}
return rem;
};
ans[m] = n;
for (int i = m; i > 0; --i) {
if (i < m) {
gr[edges[i].a].erase(edges[i].b);
gr[edges[i].b].erase(edges[i].a);
pq.push(bg_state{edges[i].a, gr[edges[i].a].size()});
pq.push(bg_state{edges[i].b, gr[edges[i].b].size()});
}
ans[i - 1] = ans[i] - doit();
}
for (int i = 0; i < m; ++i) std::cout << ans[i] << "\n";
return 0;
}
static inline void setio(void) {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.precision(10);
std::cout << std::fixed;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, m, k, deg[N], ans[N], s[N], t[N];
map<int, bool> adj[N];
vector<int> g[N];
bool alive[N];
void solve() {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
memset(alive, 1, sizeof(alive));
for (int u = 1; u <= n; u++) q.push(make_pair(deg[u], u));
while (q.size()) {
pair<int, int> now = q.top();
if (now.first >= k) break;
q.pop();
if (!alive[now.second]) continue;
alive[now.second] = 0;
for (int &v : g[now.second]) {
deg[v]--;
if (alive[v]) q.push(make_pair(deg[v], v));
}
}
int res = 0;
for (int u = 1; u <= n; u++) res += alive[u];
ans[m] = res;
for (int i = m; i >= 1; i--) {
if (alive[s[i]] && alive[t[i]]) {
deg[s[i]]--;
deg[t[i]]--;
adj[s[i]][t[i]] = 0;
adj[t[i]][s[i]] = 0;
q.push(make_pair(deg[s[i]], s[i]));
q.push(make_pair(deg[t[i]], t[i]));
pair<int, int> now = q.top();
while (q.size()) {
pair<int, int> now = q.top();
if (now.first >= k) break;
q.pop();
if (!alive[now.second]) continue;
--res;
alive[now.second] = 0;
for (int &v : g[now.second]) {
if (!adj[now.second][v]) continue;
--deg[v];
if (alive[v]) q.push(make_pair(deg[v], v));
}
}
}
ans[i - 1] = res;
}
for (int i = 1; i <= m; i++) printf("%d\n ", ans[i]);
}
int main() {
scanf("%d %d %d ", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d %d ", &s[i], &t[i]);
deg[s[i]]++;
deg[t[i]]++;
adj[s[i]][t[i]] = adj[t[i]][s[i]] = 1;
g[s[i]].push_back(t[i]);
g[t[i]].push_back(s[i]);
}
solve();
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> edge[200009];
set<int> g[200009];
int vis[200009];
int ar[200009];
int ans;
int n, m, k;
void dfs(int v) {
if (g[v].size() >= k || vis[v] == 1) return;
--ans;
vis[v] = 1;
for (auto u : g[v]) {
g[u].erase(v);
dfs(u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> m >> k;
int x, y;
ans = n;
for (int i = 0; i < m; ++i) {
cin >> x >> y;
edge[i] = {x, y};
g[x].insert(y);
g[y].insert(x);
}
for (int i = 1; i <= n; ++i) dfs(i);
for (int i = m - 1; i >= 0; --i) {
ar[i] = ans;
g[edge[i].first].erase(edge[i].second);
g[edge[i].second].erase(edge[i].first);
dfs(edge[i].first);
dfs(edge[i].second);
}
for (int i = 0; i < m; ++i) cout << ar[i] << "\n";
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, fs;
std::vector<int> yol[200005];
pair<int, int> o[200005];
int ans, yaz[200005], say[200005], del[200005];
map<pair<int, int>, int> mp;
void sil(int k) {
if (del[k] == 1) return;
del[k] = 1;
ans--;
for (int i = 0; i < yol[k].size(); ++i) {
if (mp[make_pair(k, yol[k][i])] || mp[make_pair(yol[k][i], k)]) continue;
say[yol[k][i]]--;
if (say[yol[k][i]] < fs && del[yol[k][i]] == 0) sil(yol[k][i]);
}
}
int main() {
scanf("%d %d %d", &n, &m, &fs);
ans = n;
for (int i = 0; i < m; ++i) {
scanf("%d %d", &o[i].first, &o[i].second);
yol[o[i].first].push_back(o[i].second);
yol[o[i].second].push_back(o[i].first);
say[o[i].first]++;
say[o[i].second]++;
}
for (int i = 1; i <= n; ++i) {
if (say[i] < fs) {
sil(i);
}
}
for (int i = m - 1; i >= 0; --i) {
yaz[i] = ans;
if (del[o[i].first] == 0 && del[o[i].second] == 0) {
say[o[i].first]--;
say[o[i].second]--;
mp[o[i]] = 1;
}
if (say[o[i].first] < fs) sil(o[i].first);
if (say[o[i].second] < fs) sil(o[i].second);
}
for (int i = 0; i < m; ++i) printf("%d\n", yaz[i]);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
void del(int edge, vector<set<int>>& g, map<int, int>& degr, int k) {
degr.erase(degr.find(edge));
for (auto neigh : g[edge]) {
g[neigh].erase(edge);
auto it = degr.find(neigh);
if (it != degr.end()) {
if (--degr[neigh] < k) {
del(neigh, g, degr, k);
}
}
}
g[edge].clear();
}
int main() {
int n, m, k;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
vector<set<int>> g(n);
vector<pair<int, int>> edges;
map<int, int> degr;
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].insert(b);
g[b].insert(a);
edges.push_back({a, b});
degr[a]++;
degr[b]++;
}
for (int i = 0; i < n; i++) {
if (degr.find(i) != degr.end() && degr[i] < k) {
del(i, g, degr, k);
}
}
std::list<int> answ;
for (int i = m - 1; i >= 0; i--) {
answ.push_front(degr.size());
auto edge = edges[i];
if (g[edge.second].find(edge.first) != g[edge.second].end()) {
g[edge.second].erase(edge.first);
if (--degr[edge.first] < k) del(edge.first, g, degr, k);
}
if (g[edge.first].find(edge.second) != g[edge.first].end()) {
g[edge.first].erase(edge.second);
if (--degr[edge.second] < k) del(edge.second, g, degr, k);
}
}
for (auto a : answ) {
cout << a << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
while (cin >> n >> m >> k) {
set<pair<int, int> > st;
vector<vector<int> > G(n + 1);
vector<int> deg(n + 1), vis(n + 1), x(m), y(m), ans(m);
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
deg[x[i]]++;
deg[y[i]]++;
G[x[i]].push_back(y[i]);
G[y[i]].push_back(x[i]);
}
queue<int> q;
for (int i = 1; i <= n; i++) {
if (deg[i] < k) {
vis[i] = true;
q.push(i);
}
}
for (int cnt = n, day = m - 1; day >= 0; day--) {
if (day != m - 1) {
int u = x[day + 1], v = y[day + 1];
if (!st.count(make_pair(u, v))) {
st.insert(make_pair(u, v));
st.insert(make_pair(v, u));
if (--deg[u] < k && !vis[u]) {
vis[u] = true;
q.push(u);
}
if (--deg[v] < k && !vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
cnt--;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (!st.count(make_pair(u, v))) {
st.insert(make_pair(u, v));
st.insert(make_pair(v, u));
if (--deg[v] < k && !vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
}
ans[day] = cnt;
}
for (int i = 0; i < m; i++) {
cout << ans[i] << endl;
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1123456;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
void vout(T s) {
cout << s << endl;
exit(0);
}
long long bp(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res *= a;
a *= a;
n >>= 1;
}
return res;
}
set<long long> s[MAXN];
long long n, m, k;
long long kol[MAXN];
long long ans;
bool fl[MAXN];
pair<long long, long long> a[MAXN];
queue<long long> q;
void add(long long x) {
if (fl[x]) return;
ans--;
fl[x] = 1;
q.push(x);
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
ans = n;
vector<long long> res(m);
for (int i = 0; i < m; i++) {
cin >> a[i].first >> a[i].second;
kol[a[i].first]++;
kol[a[i].second]++;
s[a[i].first].insert(a[i].second);
s[a[i].second].insert(a[i].first);
}
for (int i = 1; i <= n; i++)
if (!fl[i] && kol[i] < k) {
add(i);
while (!q.empty()) {
long long x = q.front();
q.pop();
for (auto i : s[x]) {
kol[i]--;
if (kol[i] < k) add(i);
}
}
}
for (int i = m - 1; i >= 0; i--) {
res[i] = ans;
if (!fl[a[i].first] && !fl[a[i].second]) {
kol[a[i].first]--;
kol[a[i].second]--;
s[a[i].first].erase(a[i].second);
s[a[i].second].erase(a[i].first);
if (kol[a[i].first] < k) add(a[i].first);
if (kol[a[i].second] < k) add(a[i].second);
while (!q.empty()) {
long long x = q.front();
q.pop();
for (auto i : s[x]) {
kol[i]--;
if (kol[i] < k) add(i);
}
}
}
}
for (auto i : res) cout << i << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a, b, x;
vector<int> edge[200005];
pair<int, int> amie[200005];
int deg[200005], ans[200005];
set<pair<int, int> > s, r;
void go(int y, int z) {
while (!s.empty() && s.begin()->first < k) {
a = s.begin()->second;
b = (int)edge[a].size();
s.erase(s.begin());
for (int i = 0; i < b; ++i) {
if ((a == y && edge[a][i] == z) || (a == z && edge[a][i] == y)) continue;
if (s.find(pair<int, int>(deg[edge[a][i]], edge[a][i])) != s.end() &&
r.find(pair<int, int>(a, edge[a][i])) == r.end() &&
r.find(pair<int, int>(edge[a][i], a)) == r.end()) {
s.erase(s.find(pair<int, int>(deg[edge[a][i]], edge[a][i])));
deg[edge[a][i]]--;
s.insert(pair<int, int>(deg[edge[a][i]], edge[a][i]));
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &amie[i].first, &amie[i].second);
edge[amie[i].first].push_back(amie[i].second);
edge[amie[i].second].push_back(amie[i].first);
deg[amie[i].first]++;
deg[amie[i].second]++;
}
for (int i = 1; i <= n; ++i) s.insert(pair<int, int>(deg[i], i));
go(-1, -1);
for (int i = m - 1; i >= 0; --i) {
ans[i] = (int)s.size();
if (s.find(pair<int, int>(deg[amie[i].first], amie[i].first)) != s.end() &&
s.find(pair<int, int>(deg[amie[i].second], amie[i].second)) !=
s.end()) {
s.erase(s.find(pair<int, int>(deg[amie[i].first], amie[i].first)));
s.erase(s.find(pair<int, int>(deg[amie[i].second], amie[i].second)));
deg[amie[i].first]--;
deg[amie[i].second]--;
s.insert(pair<int, int>(deg[amie[i].first], amie[i].first));
s.insert(pair<int, int>(deg[amie[i].second], amie[i].second));
r.insert(amie[i]);
go(amie[i].first, amie[i].second);
}
}
for (int i = 0; i < m; ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct Node {
int x, y;
} a[200010];
int deg[200010];
bool fl[200010];
set<int> v[200010];
int ans;
int ans1[200010];
int pos[200010];
void solve(int x) {
if (deg[x] >= k || !fl[x]) {
return;
}
queue<int> q;
q.push(x);
fl[x] = 0;
ans--;
while (!q.empty()) {
int y = q.front();
q.pop();
for (auto to : v[y]) {
deg[to]--;
if (deg[to] < k && fl[to]) {
fl[to] = 0;
q.push(to);
ans--;
}
}
}
}
int main(int argc, char const *argv[]) {
scanf("%d%d%d", &n, &m, &k);
memset(fl, 1, sizeof(fl));
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
deg[a[i].x]++;
deg[a[i].y]++;
v[a[i].x].insert(a[i].y);
v[a[i].y].insert(a[i].x);
}
ans = n;
for (int i = 1; i <= n; i++) {
solve(i);
}
for (int i = m; i; i--) {
ans1[i] = ans;
if (fl[a[i].y]) {
deg[a[i].x]--;
}
if (fl[a[i].x]) {
deg[a[i].y]--;
}
v[a[i].x].erase(a[i].y);
v[a[i].y].erase(a[i].x);
solve(a[i].x);
solve(a[i].y);
}
for (int i = 1; i <= m; i++) {
printf("%d\n", ans1[i]);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int max_N = 2e5 + 10;
int x[max_N], y[max_N];
set<int> E[max_N];
void remove(int u);
int N, M, K;
int ans = 0;
int active[max_N];
int main() {
cin >> N >> M >> K;
for (int i = 1; i <= M; ++i) {
cin >> x[i] >> y[i];
E[x[i]].insert(y[i]);
E[y[i]].insert(x[i]);
}
for (int i = 1; i <= N; ++i) {
active[i] = 1;
}
ans = N;
for (int i = 1; i <= N; ++i) {
remove(i);
}
vector<int> ans;
for (int i = M; i >= 1; --i) {
ans.push_back(::ans);
int u = x[i], v = y[i];
E[u].erase(v);
E[v].erase(u);
remove(u);
remove(v);
}
reverse(ans.begin(), ans.end());
for (auto &x : ans) {
cout << x << '\n';
}
}
void remove(int u) {
if (E[u].size() >= K || !active[u]) {
return;
}
active[u] = 0;
ans--;
for (auto &v : E[u]) {
E[v].erase(u);
remove(v);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
vector<vector<pair<int, int> > > g;
set<pair<int, int> > good;
vector<char> very_good;
vector<int> d;
int k;
void check(long long int i) {
while (!good.empty() && good.begin()->first < k) {
int v = good.begin()->second;
for (auto &y : g[v]) {
int x = y.first;
if (y.second >= i) continue;
if (very_good[x]) {
good.erase(make_pair(d[x], x));
d[x]--;
good.insert(make_pair(d[x], x));
}
}
good.erase(make_pair(d[v], v));
very_good[v] = false;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m >> k;
g.resize(n);
d.resize(n);
vector<pair<int, int> > f(m);
for (int i = 0; i < m; ++i) {
cin >> f[i].first >> f[i].second;
f[i].first--, f[i].second--;
g[f[i].first].push_back(make_pair(f[i].second, i));
g[f[i].second].push_back(make_pair(f[i].first, i));
d[f[i].first]++;
d[f[i].second]++;
}
for (int i = 0; i < n; ++i) {
good.insert(make_pair(d[i], i));
}
very_good.assign(n, true);
check(1e18);
vector<int> ans(m);
for (int i = m - 1; i >= 0; --i) {
ans[i] = good.size();
int v = f[i].first, u = f[i].second;
if (very_good[v] && very_good[u]) {
good.erase(make_pair(d[v], v));
d[v]--;
good.insert(make_pair(d[v], v));
good.erase(make_pair(d[u], u));
d[u]--;
good.insert(make_pair(d[u], u));
check(i);
}
}
for (int i = 0; i < m; ++i) cout << ans[i] << '\n';
}
| 11 | CPP |
from collections import deque
def solve(adj, m, k, uv):
n = len(adj)
nn = [len(a) for a in adj]
q = deque()
for i in range(n):
if nn[i] < k:
q.append(i)
while q:
v = q.popleft()
for u in adj[v]:
nn[u] -= 1
if nn[u] == k-1:
q.append(u)
res = [0]*m
nk = len([1 for i in nn if i >= k])
res[-1] = nk
for i in range(m-1, 0, -1):
u1, v1 = uv[i]
if nn[u1] < k or nn[v1] < k:
res[i - 1] = nk
continue
if nn[u1] == k:
q.append(u1)
nn[u1] -= 1
if not q and nn[v1] == k:
q.append(v1)
nn[v1] -= 1
if not q:
nn[u1] -= 1
nn[v1] -= 1
adj[u1].remove(v1)
adj[v1].remove(u1)
while q:
v = q.popleft()
nk -= 1
for u in adj[v]:
nn[u] -= 1
if nn[u] == k - 1:
q.append(u)
res[i - 1] = nk
return res
n, m, k = map(int, input().split())
a = [set() for i in range(n)]
uv = []
for i in range(m):
u, v = map(int, input().split())
a[u - 1].add(v - 1)
a[v - 1].add(u - 1)
uv.append((u-1, v-1))
res = solve(a, m, k, uv)
print(str(res)[1:-1].replace(' ', '').replace(',', '\n')) | 11 | PYTHON3 |
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {1, -1, 1, 0, -1, 0, 1, -1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
long long a[200005], b[200005], deg[200005];
vector<long long> adj[200005];
long long ans[200005], mark[200005];
int main() {
long long n, m, k, i, j;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
while (cin >> n >> m >> k) {
set<pair<long long, long long> > s;
set<pair<long long, long long> >::iterator it;
for (i = 1; i <= m; i++) {
cin >> a[i] >> b[i];
deg[a[i]]++;
deg[b[i]]++;
adj[a[i]].push_back(b[i]);
adj[b[i]].push_back(a[i]);
}
for (i = 1; i <= n; i++) {
mark[i] = 1;
s.insert(make_pair(deg[i], i));
}
map<pair<long long, long long>, long long> mp;
for (i = m; i >= 1; i--) {
for (j = 1;; j++) {
if (s.size() == 0) break;
it = s.begin();
long long x = it->first;
long long y = it->second;
if (x >= k) break;
mark[y] = 0;
s.erase(s.find({deg[y], y}));
for (j = 0; j < adj[y].size(); j++) {
long long p = adj[y][j];
if (mp[{y, p}] == 1) continue;
s.erase(s.find({deg[p], p}));
deg[p]--;
s.insert({deg[p], p});
mp[{y, p}] = mp[{p, y}] = 1;
}
}
ans[i] = s.size();
long long x = a[i];
long long y = b[i];
if (mp[{x, y}] == 1) continue;
mp[{x, y}] = mp[{y, x}] = 1;
s.erase(s.find({deg[x], x}));
deg[x]--;
s.insert({deg[x], x});
s.erase(s.find({deg[y], y}));
deg[y]--;
s.insert({deg[y], y});
}
for (i = 1; i <= m; i++) cout << ans[i] << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n, m, k;
cin >> n >> m >> k;
vector<vector<int> > edges(m, vector<int>(2));
vector<vector<int> > graph(n + 1);
vector<int> degrees(n + 1, 0);
for (int i = 0; i < m; ++i) {
scanf("%d %d", &edges[i][0], &edges[i][1]);
degrees[edges[i][0]]++;
degrees[edges[i][1]]++;
graph[edges[i][0]].push_back(edges[i][1]);
graph[edges[i][1]].push_back(edges[i][0]);
}
map<pair<int, int>, bool> sorted;
for (int i = 0; i < n; ++i)
sorted.insert(make_pair(make_pair(degrees[i + 1], i + 1), 1));
vector<int> ans(m);
for (int i = m - 1; i >= 0; --i) {
while ((!sorted.empty()) and sorted.begin()->first.first < k) {
int temp = sorted.begin()->first.second;
sorted.erase(sorted.begin());
degrees[temp] = 0;
for (int i = 0; i < graph[temp].size(); ++i) {
auto it =
sorted.find(make_pair(degrees[graph[temp][i]], graph[temp][i]));
degrees[graph[temp][i]]--;
if (it != sorted.end()) {
sorted.erase(it);
if (degrees[graph[temp][i]] >= 0)
sorted.insert(make_pair(
make_pair(degrees[graph[temp][i]], graph[temp][i]), 1));
}
}
}
ans[i] = sorted.size();
graph[edges[i][0]].pop_back();
graph[edges[i][1]].pop_back();
if (degrees[edges[i][0]] >= k and degrees[edges[i][1]] >= k) {
auto it1 = sorted.find(make_pair(degrees[edges[i][0]], edges[i][0]));
auto it2 = sorted.find(make_pair(degrees[edges[i][1]], edges[i][1]));
degrees[edges[i][0]]--;
degrees[edges[i][1]]--;
if (it1 != sorted.end()) {
sorted.erase(it1);
sorted.insert(
make_pair(make_pair(degrees[edges[i][0]], edges[i][0]), 1));
}
if (it2 != sorted.end()) {
sorted.erase(it2);
sorted.insert(
make_pair(make_pair(degrees[edges[i][1]], edges[i][1]), 1));
}
}
}
for (int i = 0; i < m; ++i) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using std::queue;
const int N = 2e5 + 6;
template <class T>
inline void read(T &x) {
T f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
struct Edge {
int u, v, id;
} e[N << 1];
int head[N], ecnt;
inline void addedge(int u, int v, int id) {
e[++ecnt].v = v;
e[ecnt].u = head[u];
head[u] = ecnt;
e[ecnt].id = id;
}
inline void add(int u, int v, int id) {
addedge(u, v, id);
addedge(v, u, id);
}
int n, m, k, du[N], a[N], b[N], del[N], u, ans, inq[N], Ans[N], len;
queue<int> q;
signed main() {
read(n);
read(m);
read(k);
for (int i = 1; i <= m; i++) {
read(a[i]);
read(b[i]);
du[a[i]]++;
du[b[i]]++;
add(a[i], b[i], i);
}
for (int i = 1; i <= n; i++)
if (du[i] < k) q.push(i), inq[i] = 1;
ans = n;
while (!q.empty()) {
u = q.front();
q.pop();
ans--;
du[u] = 0;
for (int i = head[u], v; i && (v = e[i].v); i = e[i].u) {
if (inq[v]) continue;
if (del[e[i].id]) continue;
du[v]--;
del[e[i].id] = 1;
if (du[v] < k) q.push(v), inq[v] = 1;
}
}
for (int i = m; i >= 1; i--) {
Ans[++len] = ans;
if (del[i]) continue;
du[a[i]]--;
du[b[i]]--;
del[i] = 1;
if (!inq[a[i]] && du[a[i]] < k) q.push(a[i]), inq[a[i]] = 1;
if (!inq[b[i]] && du[b[i]] < k) q.push(b[i]), inq[b[i]] = 1;
while (!q.empty()) {
u = q.front();
q.pop();
ans--;
du[u] = 0;
for (int i = head[u], v; i && (v = e[i].v); i = e[i].u) {
if (inq[v]) continue;
if (del[e[i].id]) continue;
du[v]--;
del[e[i].id] = 1;
if (du[v] < k) q.push(v), inq[v] = 1;
}
}
}
for (int i = m; i >= 1; i--) printf("%d\n", Ans[i]);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, r[200005], redd[200005], t, xx[200005], yy[200005],
ans[200005];
vector<pair<long long, long long> > v[200005];
void red(long long x, long long time) {
if (time == 5) {
}
redd[x] = 1;
t++;
for (int i = 0; i < v[x].size(); i++) {
if (v[x][i].first > time) break;
r[v[x][i].second]--;
if (r[v[x][i].second] < k && redd[v[x][i].second] == 0) {
red(v[x][i].second, time);
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> xx[i] >> yy[i];
v[xx[i]].push_back(make_pair(i, yy[i]));
r[xx[i]]++;
v[yy[i]].push_back(make_pair(i, xx[i]));
r[yy[i]]++;
}
for (int i = 1; i <= n; i++) sort(v[i].begin(), v[i].end());
ans[m] = n;
for (int i = 1; i <= n; i++) {
if (r[i] < k && redd[i] == 0) {
t = 0;
red(i, m);
ans[m] -= t;
}
}
for (int i = m; i >= 2; i--) {
for (int j = 1; j <= n; j++) {
}
if (redd[yy[i]] == 0) r[xx[i]]--;
t = 0;
if (r[xx[i]] < k && redd[xx[i]] == 0) {
red(xx[i], i);
ans[i - 1] = ans[i] - t;
continue;
}
if (redd[xx[i]] == 0) r[yy[i]]--;
if (r[yy[i]] < k && redd[yy[i]] == 0) {
if (xx[i] == 5) {
}
r[xx[i]]++;
red(yy[i], i);
}
ans[i - 1] = ans[i] - t;
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int m, n, k, d[N];
set<int> ad[N];
int ans[N], dd[N];
pair<int, int> ed[N];
int main() {
;
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
ad[u].insert(v);
ad[v].insert(u);
d[u]++;
d[v]++;
ed[i] = {u, v};
}
queue<int> q;
for (int i = 1; i <= n; ++i)
if (d[i] < k) q.push(i), dd[i] = 1;
ans[m] = n;
while (!q.empty()) {
int uu = q.front();
q.pop();
for (auto &vv : ad[uu]) {
d[vv]--;
ad[vv].erase(uu);
if (d[vv] < k && !dd[vv]) {
dd[vv] = 1;
q.push(vv);
}
}
ans[m]--;
d[uu] = 0;
ad[uu].clear();
}
for (int i = m - 1; i >= 1; --i) {
ans[i] = ans[i + 1];
if (dd[ed[i + 1].first] || dd[ed[i + 1].second]) continue;
int u = ed[i + 1].first, v = ed[i + 1].second;
ad[u].erase(v);
ad[v].erase(u);
d[u]--;
d[v]--;
if (d[u] < k && !dd[u]) q.push(u), dd[u] = 1;
if (d[v] < k && !dd[v]) q.push(v), dd[v] = 1;
while (!q.empty()) {
int uu = q.front();
q.pop();
for (auto &vv : ad[uu]) {
d[vv]--;
ad[vv].erase(uu);
if (d[vv] < k && !dd[vv]) {
dd[vv] = 1;
q.push(vv);
}
}
ans[i]--;
d[uu] = 0;
ad[uu].clear();
}
}
for (int i = 1; i <= m; ++i) cout << ans[i] << '\n';
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
vector<vector<pair<long long, long long> > > friends(n);
vector<long long> pointers(n);
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
friends[a - 1].push_back(make_pair(b - 1, i));
friends[b - 1].push_back(make_pair(a - 1, i));
}
queue<long long> q;
set<pair<long long, long long> > good;
for (long long i = 0; i < n; i++) {
if (friends[i].size() >= k) {
good.insert(make_pair(friends[i][k - 1].second, i));
pointers[i] = k - 1;
} else {
pointers[i] = -1;
q.push(i);
}
}
long long u = m;
vector<long long> ans(m);
fill(ans.begin(), ans.end(), 0);
vector<bool> used(n);
fill(used.begin(), used.end(), false);
while (good.size()) {
while (q.size()) {
long long V = q.front();
q.pop();
used[V] = true;
for (long long i = 0; i < friends[V].size(); i++) {
long long to = friends[V][i].first, tm = friends[V][i].second;
if (pointers[to] == -1) continue;
long long T = friends[to][pointers[to]].second;
if (tm > T) continue;
pointers[to]++;
while (pointers[to] < friends[to].size()) {
long long K = friends[to][pointers[to]].first;
if (used[K] || friends[to][pointers[to]].second >= u)
pointers[to]++;
else
break;
}
if (pointers[to] >= friends[to].size()) {
good.erase(good.find(make_pair(T, to)));
pointers[to] = -1;
q.push(to);
} else {
good.erase(good.find(make_pair(T, to)));
T = friends[to][pointers[to]].second;
good.insert(make_pair(T, to));
}
}
}
long long S = good.size();
if (S == 0) break;
set<pair<long long, long long> >::iterator it = good.end();
it--;
pair<long long, long long> P = *it;
long long tt = P.first;
for (long long i = tt; i < u; i++) ans[i] = S;
u = tt;
while (good.size()) {
set<pair<long long, long long> >::iterator it = good.end();
it--;
pair<long long, long long> P = *it;
long long ttt = P.first;
if (tt != ttt) {
break;
}
good.erase(it);
pointers[P.second] = -1;
q.push(P.second);
}
}
for (long long i = 0; i < m; i++) cout << ans[i] << "\n";
}
| 11 | CPP |
#include <bits/stdc++.h>
const int N = 200005;
using namespace std;
int n, m, k, deg[N], ans[N];
set<pair<int, int> > st;
vector<pair<int, int> > g[N], h;
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
h.push_back({u, v});
g[u].push_back({v, i});
g[v].push_back({u, i});
deg[u]++;
deg[v]++;
}
for (int i = 1; i <= n; i++) st.insert({deg[i], i});
while (st.size() && (*(st.begin())).first < k) {
pair<int, int> e = *st.begin();
st.erase(e);
int u = e.second;
for (auto E : g[u]) {
int el = E.first;
if (st.count({deg[el], el})) {
st.erase({deg[el], el});
deg[el]--;
st.insert({deg[el], el});
}
}
}
for (int i = m - 1; i >= 0; i--) {
ans[i] = st.size();
int u = h[i].first, v = h[i].second;
if (st.count({deg[u], u}) && st.count({deg[v], v})) {
st.erase({deg[u], u});
deg[u]--;
st.insert({deg[u], u});
st.erase({deg[v], v});
deg[v]--;
st.insert({deg[v], v});
while (st.size() && (*(st.begin())).first < k) {
pair<int, int> e = *st.begin();
st.erase(e);
int u = e.second;
for (auto E : g[u]) {
int el = E.first;
if (E.second >= i) continue;
if (st.count({deg[el], el})) {
st.erase({deg[el], el});
deg[el]--;
st.insert({deg[el], el});
}
}
}
}
}
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int deg[200005];
vector<pair<int, int> > g[200005];
bool notInSet[200005];
int main() {
int n, m, k, x, y, i;
cin >> n >> m >> k;
vector<pair<int, int> > v;
for (i = 0; i < m; i++) {
cin >> x >> y;
v.push_back({x, y});
deg[x]++, deg[y]++;
g[x].push_back({y, i});
g[y].push_back({x, i});
}
set<pair<int, int> > s;
for (i = 1; i <= n; i++) {
s.insert({deg[i], i});
}
while (!s.empty() && deg[s.begin()->second] < k) {
int u = s.begin()->second;
for (auto it : g[u]) {
int x = it.first;
if (!notInSet[x]) {
s.erase(s.find({deg[x], x}));
deg[x]--;
s.insert({deg[x], x});
}
}
s.erase({deg[u], u});
notInSet[u] = 1;
}
vector<int> res(m);
for (i = m - 1; i >= 0; i--) {
res[i] = s.size();
x = v[i].first, y = v[i].second;
if (!notInSet[x] && !notInSet[y]) {
s.erase(s.find({deg[x], x}));
s.erase(s.find({deg[y], y}));
deg[x]--, deg[y]--;
s.insert({deg[y], y});
s.insert({deg[x], x});
while (!s.empty() && deg[s.begin()->second] < k) {
int u = s.begin()->second;
for (auto it : g[u]) {
int x = it.first;
int y = it.second;
if (y >= i) continue;
if (!notInSet[x]) {
s.erase(s.find({deg[x], x}));
deg[x]--;
s.insert({deg[x], x});
}
}
s.erase({deg[u], u});
notInSet[u] = 1;
}
}
}
for (i = 0; i < m; i++) cout << res[i] << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int d[MAXN];
int a[MAXN], b[MAXN], f[MAXN], ans[MAXN];
int n, m, k;
int q[MAXN], fr, re;
vector<int> E[MAXN];
set<long long> S;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; ++i) {
scanf("%d%d", a + i, b + i);
d[a[i]]++, d[b[i]]++;
E[a[i]].push_back(b[i]);
E[b[i]].push_back(a[i]);
}
for (int i = 1; i <= n; ++i) {
if (d[i] < k) {
f[i] = 1;
q[re++] = i;
}
}
ans[m] = n;
while (fr < re) {
int u = q[fr++];
ans[m]--;
for (int i = 0; i < E[u].size(); ++i) {
int v = E[u][i];
if (f[v]) continue;
if (--d[v] < k) {
q[re++] = v;
f[v] = 1;
}
}
}
for (int i = m - 1; i >= 0; --i) {
ans[i] = ans[i + 1];
int u1 = a[i], u2 = b[i];
if (f[u1] || f[u2]) continue;
S.insert((long long)u1 * n + u2);
S.insert((long long)u2 * n + u1);
d[u1]--, d[u2]--;
if (d[u1] < k) {
fr = re = 0;
q[re++] = u1;
f[u1] = 1;
while (fr < re) {
int u = q[fr++];
ans[i]--;
for (int i = 0; i < E[u].size(); ++i) {
int v = E[u][i];
if (f[v] || S.find((long long)u * n + v) != S.end()) continue;
if (--d[v] < k) {
f[v] = 1;
q[re++] = v;
}
}
}
}
if (!f[u2] && d[u2] < k) {
fr = re = 0;
q[re++] = u2;
f[u2] = 1;
while (fr < re) {
int u = q[fr++];
ans[i]--;
for (int i = 0; i < E[u].size(); ++i) {
int v = E[u][i];
if (f[v] || S.find((long long)u * n + v) != S.end()) continue;
if (--d[v] < k) {
f[v] = 1;
q[re++] = v;
}
}
}
}
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 200005;
struct edge {
int u, v, next;
} G[max_n * 2];
int head[max_n];
int total;
bool visit[max_n * 2];
int in[max_n];
set<pair<int, int> > s;
int n, m, k;
int u, v;
int ans[max_n];
void add_edge(int u, int v) {
G[total].u = u;
G[total].v = v;
G[total].next = head[u];
head[u] = total++;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
total = 0;
memset(head, -1, sizeof(head));
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
in[u]++;
in[v]++;
}
for (int i = 1; i <= n; i++) s.insert(pair<int, int>(in[i], i));
pair<int, int> p;
for (int i = 2 * m - 1; i >= 0; i -= 2) {
while (!s.empty()) {
p = *s.begin();
if (p.first < k) {
s.erase(p);
for (int j = head[p.second]; ~j; j = G[j].next) {
if (!visit[j]) {
v = G[j].v;
s.erase(pair<int, int>(in[v], v));
in[v]--;
s.insert(pair<int, int>(in[v], v));
visit[j] = visit[j ^ 1] = true;
}
}
} else
break;
}
ans[i / 2] = s.size();
if (!visit[i]) {
u = G[i].u;
v = G[i].v;
s.erase(pair<int, int>(in[u], u));
in[u]--;
s.insert(pair<int, int>(in[u], u));
s.erase(pair<int, int>(in[v], v));
in[v]--;
s.insert(pair<int, int>(in[v], v));
visit[i] = visit[i ^ 1] = true;
}
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v;
};
int n, m, k, f[1000000 + 1], ans[1000000 + 1], q[1000000 + 1], lq = 0, rq = -1,
cur;
edge b[1000000 + 1];
vector<int> a[1000000 + 1], e[1000000 + 1];
bool remoed[1000000 + 1], removeti[1000000 + 1];
void removequeue() {
int x, y;
while (lq <= rq) {
x = q[lq];
lq++;
cur--;
for (int i = 0; i < a[x].size(); i++) {
y = a[x][i];
if (remoed[e[x][i]] == false) {
remoed[e[x][i]] = true;
f[y]--;
if (f[y] < k && removeti[y] == false) {
rq++;
q[rq] = y;
removeti[y] = true;
}
}
}
}
}
void removemany() {
for (int i = 1; i <= n; i++) {
if (f[i] < k) {
rq++;
q[rq] = i;
removeti[i] = true;
}
}
removequeue();
}
void solve() {
removemany();
for (int i = m - 1; i >= 0; i--) {
ans[i] = cur;
if (remoed[i] == false) {
remoed[i] = true;
f[b[i].u]--;
f[b[i].v]--;
if (f[b[i].u] < k && removeti[b[i].u] == false) {
rq++;
q[rq] = b[i].u;
removeti[b[i].u] = true;
}
if (f[b[i].v] < k && removeti[b[i].v] == false) {
rq++;
q[rq] = b[i].v;
removeti[b[i].v] = true;
}
}
removequeue();
}
for (int i = 0; i < m; i++) cout << ans[i] << "\n";
}
void readit() {
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> b[i].u >> b[i].v;
a[b[i].u].push_back(b[i].v);
a[b[i].v].push_back(b[i].u);
e[b[i].u].push_back(i);
e[b[i].v].push_back(i);
f[b[i].u]++;
f[b[i].v]++;
}
cur = n;
}
int main() {
readit();
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
pair<int, int> vv[m];
set<int> adj[n];
int deg[n];
for (int i = 0; i < n; i++) deg[i] = 0;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
vv[i] = make_pair(x, y);
deg[x]++;
deg[y]++;
adj[x].insert(y);
adj[y].insert(x);
}
int ans[m], good = n;
bool done[n];
for (int i = 0; i < n; i++) done[i] = 0;
set<pair<int, int> > st;
priority_queue<pair<int, int> > pq;
for (int i = 0; i < n; i++) pq.push(make_pair(-deg[i], i));
for (int i = m - 1; i >= 0; i--) {
while (!pq.empty()) {
pair<int, int> p = pq.top();
pq.pop();
if (-p.first >= k) {
pq.push(p);
break;
}
if (done[p.second]) continue;
done[p.second] = true;
good--;
int ix = p.second;
for (set<int>::iterator it = adj[ix].begin(); it != adj[ix].end(); it++) {
deg[*it]--;
adj[*it].erase(ix);
pq.push(make_pair(-deg[*it], *it));
}
deg[ix] = 0;
adj[ix].clear();
}
ans[i] = good;
if (adj[vv[i].first].find(vv[i].second) != adj[vv[i].first].end()) {
deg[vv[i].first]--;
pq.push(make_pair(-deg[vv[i].first], vv[i].first));
deg[vv[i].second]--;
pq.push(make_pair(-deg[vv[i].second], vv[i].second));
adj[vv[i].first].erase(vv[i].second);
adj[vv[i].second].erase(vv[i].first);
}
}
for (int i = 0; i < m; i++) cout << ans[i] << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int n, m, k, X[MAXN], Y[MAXN], deg[MAXN], cnt;
vector<pair<int, int> > E[MAXN];
bool removed[MAXN];
void ukloni(int x, int tijme) {
if (!removed[x] && deg[x] < k) {
removed[x] = true;
cnt--;
for (auto e : E[x])
if (e.second < tijme) {
deg[e.first]--;
ukloni(e.first, tijme);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < m; ++i) {
cin >> X[i] >> Y[i];
E[X[i]].push_back(pair<int, int>(Y[i], i));
E[Y[i]].push_back(pair<int, int>(X[i], i));
deg[X[i]]++;
deg[Y[i]]++;
}
cnt = n;
for (int i = 1; i < n + 1; ++i) ukloni(i, MAXN);
vector<int> sol;
for (int i = m - 1; i >= 0; --i) {
sol.push_back(cnt);
if (!removed[X[i]] && !removed[Y[i]]) {
deg[X[i]]--;
deg[Y[i]]--;
ukloni(X[i], i);
ukloni(Y[i], i);
}
}
for (int i = ((int)sol.size()) - 1; i >= 0; --i) cout << sol[i] << "\n";
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long M = 2e5 + 10;
vector<long long> v[200009], deg(M), vis(M);
map<pair<long long, long long>, long long> ed;
void dfs(long long s, long long k, long long p, long long &ans) {
vis[s] = 1;
ans--;
for (auto u : v[s]) {
pair<long long, long long> p1;
p1.first = u;
p1.second = s;
if (u != p && ed.find(p1) == ed.end()) {
deg[u]--;
deg[s]--;
ed[make_pair(u, s)] = 1;
ed[make_pair(s, u)] = 1;
}
if (vis[u] == 0 && deg[u] < k) {
dfs(u, k, s, ans);
}
}
return;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
vector<pair<long long, long long> > edge;
for (long long i = 0; i < m; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
edge.push_back(make_pair(a, b));
deg[a]++;
deg[b]++;
}
long long ans = n;
vector<long long> ans1(m);
vis[0] = 1;
for (long long i = 1; i <= n; i++) {
if (deg[i] < k && vis[i] == 0) {
dfs(i, k, 0, ans);
}
}
for (long long i = m - 1; i >= 0; i--) {
ans1[i] = ans;
long long a = edge[i].first;
long long b = edge[i].second;
if (vis[a] == 0 && vis[b] == 0 && ed.find(make_pair(a, b)) == ed.end()) {
deg[a]--;
deg[b]--;
ed[make_pair(a, b)] = 1;
ed[make_pair(b, a)] = 1;
}
if (deg[a] < k && vis[a] == 0) {
dfs(a, k, b, ans);
}
if (deg[b] < k && vis[b] == 0) {
dfs(b, k, a, ans);
}
}
for (long long i = 0; i < m; i++) {
printf("%lld\n", ans1[i]);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1e6 + 5;
struct edge {
int u, v, ne, num;
} e[maxn];
int n, m, k, sum;
int d[maxn], no[maxn], vis[maxn];
int head[maxn], len;
int ans[maxn];
void add(int u, int v, int num) {
e[len].u = u;
e[len].v = v;
e[len].num = num;
e[len].ne = head[u];
head[u] = len++;
}
void del(int x) {
sum--;
no[x] = 1;
for (int i = head[x]; i != -1; i = e[i].ne) {
int v = e[i].v;
if (no[v] || vis[e[i].num]) continue;
vis[e[i].num] = 1;
d[v]--;
if (d[v] < k) del(v);
}
return;
}
int main() {
memset(head, -1, sizeof(head));
cin >> n >> m >> k;
for (int i = 1, x, y; i <= m; i++) {
scanf("%d %d", &x, &y);
add(x, y, i);
add(y, x, i);
d[x]++;
d[y]++;
}
sum = n;
for (int i = 1; i <= n; i++) {
if (d[i] >= k || no[i]) continue;
del(i);
}
ans[m] = sum;
for (int i = len - 1; i > 0; i -= 2) {
int u = e[i].u, v = e[i].v;
if (!vis[e[i].num]) {
vis[e[i].num] = 1;
if (!no[u]) {
d[u]--;
if (d[u] < k) del(u);
}
if (!no[v]) {
d[v]--;
if (d[v] < k) del(v);
}
}
ans[(i + 1) / 2 - 1] = sum;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int n, m, k, used[N], w[N], all, deg[N];
bool c[N];
vector<set<int> > g(N);
vector<int> res;
vector<pair<int, int> > reb;
queue<int> q;
void bfs() {
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto& u : g[v]) {
if (deg[u] == k) {
deg[u]--;
q.push(u);
} else
deg[u]--;
}
}
}
void ddfs(int v) {
for (auto& u : g[v]) {
if (w[u] == 1) {
w[u] = 0;
c[u] = 0;
all--;
ddfs(u);
} else
w[u]--;
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].insert(b);
g[b].insert(a);
deg[a]++;
deg[b]++;
reb.push_back({a, b});
}
for (int i = 0; i < n; i++) {
if (deg[i] < k) {
q.push(i);
}
}
bfs();
for (int i = 0; i < n; i++)
if (deg[i] >= k) c[i] = 1;
for (int i = 0; i < n; i++) {
int x = 0;
for (auto& v : g[i]) x += c[v];
w[i] = max(0, x - k + 1);
all += c[i];
}
res.push_back(all);
for (int i = m - 1; i >= 0; i--) {
int a = reb[i].first, b = reb[i].second;
if (c[a] && c[b]) {
if (w[a] == 1) {
w[a] = 0;
all--;
c[a] = 0;
ddfs(a);
} else if (w[b] == 1) {
w[b] = 0;
all--;
c[b] = 0;
ddfs(b);
} else {
w[a]--;
w[b]--;
}
}
g[a].erase(b);
g[b].erase(a);
res.push_back(all);
}
for (int i = m - 1; i >= 0; i--) cout << res[i] << '\n';
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int t, id, next;
Edge() {}
Edge(int a, int b, int c) : t(a), id(b), next(c) {}
};
Edge e[400005];
int head[200005], ans[200005], k;
int cur;
int d[200005], sum;
bool col[200005];
void dfs(int x) {
col[x] = 0;
sum--;
for (int i = head[x]; i; i = e[i].next)
if (col[e[i].t] && e[i].id < cur) {
int u = e[i].t;
d[u]--;
if (d[u] < k) dfs(u);
}
}
pair<int, int> a[200005];
int main() {
int n, m;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
e[2 * i - 1] = Edge(y, i, head[x]);
head[x] = 2 * i - 1;
e[2 * i] = Edge(x, i, head[y]);
head[y] = 2 * i;
d[x]++;
d[y]++;
a[i] = pair<int, int>(x, y);
}
for (int i = 1; i <= n; i++) col[i] = 1;
sum = n;
cur = m + 1;
for (int i = 1; i <= n; i++)
if (col[i] && d[i] < k) dfs(i);
for (int i = m; i > 0; i--) {
ans[i] = sum;
int x = a[i].first, y = a[i].second;
cur--;
if (col[x] && col[y]) {
d[x]--;
d[y]--;
if (col[x] && d[x] < k) dfs(x);
if (col[y] && d[y] < k) dfs(y);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, m, k, indi[(int)5e5 + 110];
set<int> gra[(int)5e5 + 110];
int arr[(int)5e5 + 110], bra[(int)5e5 + 110], result[(int)5e5 + 110],
donno[(int)5e5 + 110];
int track;
void funck(int u) {
queue<int> pq;
pq.push(u);
while (!pq.empty()) {
u = pq.front();
pq.pop();
if (donno[u]) continue;
donno[u] = 1;
track--;
for (int go : gra[u]) {
gra[go].erase(u);
if (--indi[go] < k) pq.push(go);
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
gra[u].insert(v);
gra[v].insert(u);
indi[u]++;
indi[v]++;
arr[i] = u;
bra[i] = v;
}
track = n;
for (int i = 0; i < n; ++i) {
if (donno[i] == 0 and indi[i] < k) {
funck(i);
}
}
for (int i = m - 1; i >= 0; i--) {
result[i] = track;
if (donno[arr[i]] == 0 and donno[bra[i]] == 0) {
indi[arr[i]]--;
indi[bra[i]]--;
gra[arr[i]].erase(bra[i]);
gra[bra[i]].erase(arr[i]);
if (indi[arr[i]] < k) funck(arr[i]);
if (indi[bra[i]] < k) funck(bra[i]);
}
}
for (int i = 0; i < m; ++i) {
cout << result[i] << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
void func(void) {
freopen("input.c", "r", stdin);
freopen("output.c", "w", stdout);
}
void print(vector<long long> &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld ", v[i]);
}
printf("\n");
}
void print(vector<pair<long long, long long> > &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld %lld\n", v[i].first, v[i].second);
}
}
void print(double d) { cout << fixed << setprecision(10) << d << endl; }
void print(string s, double d) {
cout << s << " ";
cout << fixed << setprecision(10) << d << endl;
}
const int N = 2e5 + 100;
set<int> s[N];
set<pair<int, int> > keep;
int in[N];
vector<pair<int, int> > v;
int answer[N];
void setAnswer(int x, int i, int n) { answer[i] = x; }
void finIt(int n) {
for (int i = 0; i < n; i++) {
if (answer[i] == -1) answer[i] = 0;
}
}
int getAnswer(int k) {
while (keep.size()) {
auto it = keep.begin();
pair<int, int> x = *it;
if (x.first >= k) break;
int y = x.second;
keep.erase(it);
for (auto it1 = s[y].begin(); it1 != s[y].end(); it1++) {
int z = *it1;
keep.erase(keep.find({in[z], z}));
in[z]--;
keep.insert({in[z], z});
s[z].erase(y);
}
s[y].clear();
}
return keep.size();
}
int main() {
int n, q, i, j = 0, temp, t, k, ans = 0, sum = 0, x, y, z, cnt = 0, m, fg = 0,
mx = 0, mx1 = 0;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
s[x].insert(y);
s[y].insert(x);
v.push_back({x, y});
in[x]++;
in[y]++;
}
for (int i = 1; i <= n; i++) {
keep.insert({in[i], i});
}
int nowAnswer = getAnswer(k);
answer[m - 1] = nowAnswer;
for (int i = v.size() - 1; i >= 1; i--) {
int x = v[i].first;
int y = v[i].second;
if (s[x].find(y) == s[x].end()) {
answer[i - 1] = nowAnswer;
continue;
}
keep.erase(keep.find({in[x], x}));
keep.erase(keep.find({in[y], y}));
in[x]--;
in[y]--;
keep.insert({in[x], x});
keep.insert({in[y], y});
s[x].erase(y);
s[y].erase(x);
nowAnswer = getAnswer(k);
answer[i - 1] = nowAnswer;
}
for (int i = 0; i < m; i++) {
printf("%d\n", answer[i]);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> adj[N];
int deg[N], ans[N];
pair<int, int> ed[N];
queue<int> lazy;
bool rem_e[N], rem_v[N];
int k, tot;
void erase(int i) {
if (rem_e[i]) return;
rem_e[i] = true;
for (int u : {ed[i].first, ed[i].second}) {
if (deg[u] == k) {
lazy.push(u);
}
deg[u]--;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m >> k;
tot = n;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
ed[i] = {u, v};
adj[u].push_back(i);
deg[u]++;
adj[v].push_back(i);
deg[v]++;
}
for (int i = 1; i <= n; i++)
if (deg[i] < k) lazy.push(i);
for (int i = m - 1; i >= 0; i--) {
while (!lazy.empty()) {
int u = lazy.front();
lazy.pop();
if (rem_v[u]) continue;
rem_v[u] = true;
tot--;
for (int i : adj[u]) erase(i);
}
ans[i] = tot;
erase(i);
}
for (int i = 0; i < m; i++) {
cout << ans[i] << ' ';
}
cout << '\n';
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INFTY = 20000000;
const int MAX = 500100;
const int MOD = 10000000;
void coutTab(int* tab, int n) {
for (int i = 0; i < n; i++) {
cout << tab[i] << " ";
}
cout << "\n";
}
int n, m, k;
vector<set<int> > G(MAX);
int s[MAX];
bool was[MAX];
pair<int, int> E[MAX];
int res[MAX];
void addToQueue(queue<int>& Q, int i) {
if (s[i] < k && !was[i]) {
was[i] = 1;
Q.push(i);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> E[i].first >> E[i].second;
E[i].first--;
E[i].second--;
G[E[i].first].insert(E[i].second);
G[E[i].second].insert(E[i].first);
}
for (int i = 0; i < n; i++) s[i] = (G[i]).size();
queue<int> Q;
int cur = n;
for (int i = 0; i < n; i++) addToQueue(Q, i);
for (int i = 0; i < m; i++) {
while (!Q.empty()) {
int j = Q.front();
Q.pop();
for (auto l : G[j]) {
s[l]--;
addToQueue(Q, l);
}
cur--;
}
res[i] = cur;
pair<int, int> lst = E[m - i - 1];
G[lst.first].erase(lst.second);
G[lst.second].erase(lst.first);
if (!was[lst.second]) s[lst.first]--;
if (!was[lst.first]) s[lst.second]--;
addToQueue(Q, lst.first);
addToQueue(Q, lst.second);
}
reverse(res, res + m);
for (int i = 0; i < m; i++) cout << res[i] << "\n";
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const double EPS = 1e-8;
const int MOD = 998244353;
template <typename T>
void cmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void cmax(T &x, T y) {
if (y > x) x = y;
}
long long qpow(long long x, long long n, long long mod = MOD) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
namespace Solver {
void InitOnce() {}
int n, m, k;
int u[200005];
int v[200005];
int deg[200005];
vector<pair<int, int> > G[200005];
void Read() {
int res = scanf("%d%d%d", &n, &m, &k);
if (res == -1) exit(0);
for (int i = 1; i <= n; ++i) G[i].clear();
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u[i], &v[i]);
G[u[i]].emplace_back(v[i], i);
G[v[i]].emplace_back(u[i], i);
}
for (int i = 1; i <= n; ++i) deg[i] = G[i].size();
}
bool vis[200005];
int ans[200005];
bool inQ[200005];
queue<int> Q;
void delEdge(int u, int v, int id) {
if (vis[id]) return;
vis[id] = 1;
--deg[u];
--deg[v];
if (inQ[v] == 0 && deg[v] < k) {
Q.push(v);
inQ[v] = 1;
}
}
void delEdge2(int u, int v, int id) {
if (vis[id]) return;
vis[id] = 1;
--deg[u];
--deg[v];
if (inQ[u] == 0 && deg[u] < k) {
Q.push(u);
inQ[u] = 1;
}
if (inQ[v] == 0 && deg[v] < k) {
Q.push(v);
inQ[v] = 1;
}
}
void Solve() {
memset(vis, 0, sizeof(vis));
memset(ans, 0, sizeof(ans));
memset(inQ, 0, sizeof(inQ));
for (int i = 1; i <= n; ++i) {
if (deg[i] < k) {
Q.push(i);
inQ[i] = 1;
}
}
int cur = n;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
--cur;
for (pair<int, int> &p : G[u]) {
int v = p.first, id = p.second;
delEdge(u, v, id);
}
}
for (int i = 1; i <= n; ++i) {
if (deg[i]) assert(deg[i] >= k);
}
ans[m] = cur;
for (int i = m - 1; i >= 0; --i) {
int de = i + 1;
delEdge2(u[de], v[de], de);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
--cur;
for (pair<int, int> &p : G[u]) {
int v = p.first, id = p.second;
delEdge(u, v, id);
}
}
ans[i] = cur;
}
for (int i = 1; i <= n; ++i) {
assert(deg[i] == 0);
assert(inQ[i] == 1);
}
for (int i = 1; i <= m; ++i) assert(vis[i] == 1);
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return;
}
} // namespace Solver
int main() {
Solver::InitOnce();
while (true) {
Solver::Read();
Solver::Solve();
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int> > arr(m);
vector<vector<int> > G(n);
vector<int> in(n), vis(n);
for (auto& it : arr) {
int u, v;
cin >> u >> v;
in[--u]++;
in[--v]++;
it = {u, v};
G[u].push_back(v);
G[v].push_back(u);
}
queue<int> q;
for (int i = 0; i < n; i++) {
if (in[i] < k) {
q.push(i);
vis[i] = 1;
}
}
int cur = n - q.size();
set<pair<int, int> > cnt;
while (!q.empty()) {
auto x = q.front();
q.pop();
for (auto& it : G[x]) {
auto node = minmax(x, it);
if (cnt.find(node) == cnt.end()) {
cnt.insert(node);
if (!vis[it] && --in[it] < k) {
vis[it] = 1;
q.push(it);
cur--;
}
}
}
}
reverse(arr.begin(), arr.end());
vector<int> ans;
for (auto& it : arr) {
ans.push_back(cur);
auto node = minmax(it.first, it.second);
if (cnt.find(node) == cnt.end()) {
cnt.insert(node);
if (!vis[it.first] && --in[it.first] < k) {
vis[it.first] = 1;
q.push(it.first);
cur--;
}
if (!vis[it.second] && --in[it.second] < k) {
vis[it.second] = 1;
q.push(it.second);
cur--;
}
while (!q.empty()) {
auto x = q.front();
q.pop();
for (auto& jt : G[x]) {
auto node = minmax(x, jt);
if (cnt.find(node) == cnt.end()) {
cnt.insert(node);
if (!vis[jt] && --in[jt] < k) {
vis[jt] = 1;
q.push(jt);
cur--;
}
}
}
}
}
}
reverse(ans.begin(), ans.end());
for (auto& it : ans) cout << it << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
long long n, tot = 1, ans, m, k;
long long head[400005], d[400005], pr[400005], v[400005], vi[400005],
vdel[400005], num[400005];
struct node {
long long u, v;
} g[400005];
struct ed {
long long next, to;
} e[400005 * 2];
void ad(long long x, long long y) {
e[++tot].to = y;
e[tot].next = head[x];
head[x] = tot;
}
void del(long long x) {
if (vdel[x]) return;
ans--;
vdel[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int tt = e[i].to;
bool flag = 0;
if (d[tt] >= k) flag = 1;
if (vi[i]) continue;
d[tt]--;
if (flag && d[tt] < k) del(tt);
}
}
void dfs(long long x) {
v[x] = 1;
ans++;
for (int i = head[x]; i; i = e[i].next) {
int tt = e[i].to;
if (v[tt] || vi[i]) continue;
dfs(tt);
}
if (d[x] < k) del(x);
}
int main() {
n = read(), m = read(), k = read();
for (int i = 1; i <= m; i++) {
g[i].u = read(), g[i].v = read();
num[i] = tot + 1;
ad(g[i].u, g[i].v);
ad(g[i].v, g[i].u);
d[g[i].u]++;
d[g[i].v]++;
}
for (int i = 1; i <= n; i++) {
if (!v[i]) dfs(i);
}
for (int i = m; i >= 1; i--) {
pr[i] = ans;
long long u = g[i].u, v = g[i].v;
vi[num[i]] = vi[num[i] ^ 1] = 1;
if (d[u] >= k && d[v] >= k) {
d[u]--;
d[v]--;
if (d[u] < k) del(u);
if (d[v] < k) del(v);
} else if (d[u] >= k)
d[v]--;
else if (d[v] >= k)
d[u]--;
}
for (int i = 1; i <= m; i++) cout << pr[i] << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int u, v, nxt;
} e[400010];
int tot;
int first[200010];
int d[200010];
void build(int u, int v) {
e[++tot] = (Edge){u, v, first[u]};
first[u] = tot;
d[u]++;
return;
}
int ans[200010];
bool book[200010];
bool is[200010];
int n, m, k;
queue<int> q;
void getans(int w) {
if (w < m) {
ans[w] = ans[w + 1];
int u = e[(w + 1) * 2].u, v = e[(w + 1) * 2].v;
if (book[w + 1]) return;
d[u]--;
d[v]--;
book[w + 1] = true;
if (!is[u] && d[u] < k) q.push(u), ans[w]--, is[u] = true;
if (!is[v] && d[v] < k) q.push(v), ans[w]--, is[v] = true;
} else {
ans[w] = n;
for (int i = 1; i <= n; i++)
if (d[i] < k) q.push(i), ans[w]--, is[i] = true;
}
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = first[now]; i; i = e[i].nxt) {
if (book[(i + 1) / 2]) continue;
if (is[e[i].v]) continue;
book[(i + 1) / 2] = true;
d[e[i].v]--;
if (d[e[i].v] < k) {
q.push(e[i].v);
ans[w]--;
is[e[i].v] = true;
}
}
}
return;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
build(u, v);
build(v, u);
}
for (int i = m; i >= 1; i--) getans(i);
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <typename T>
void DBG(const char* name, T&& H) {
cerr << name << " = " << H << ')' << '\n';
}
template <typename T, typename... Args>
void DBG(const char* names, T&& H, Args&&... args) {
const char* NEXT = strchr(names + 1, ',');
cerr.write(names, NEXT - names) << " = " << H << " |";
DBG(NEXT + 1, args...);
}
using ll = long long;
using ld = long double;
const ll mod1 = 1e9 + 7;
const ld PI = acos(-1.0);
const ll maxN = 1e6 + 1;
const ll INF = 1e18;
void Solve() {
int n, m, k;
cin >> n >> m >> k;
vector<int> deg(n + 1, 0);
vector<pair<int, int>> friendship(m);
vector<set<int>> graph(n + 1);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
deg[a]++, deg[b]++;
graph[a].insert(b);
graph[b].insert(a);
friendship[i] = {a, b};
}
set<pair<int, int>> q;
for (int i = 1; i <= n; i++) {
q.insert({deg[i], i});
}
vector<int> ans(m, 0);
for (int i = m - 1; i >= 0; i--) {
while (q.size() && ((*q.begin()).first < k)) {
int ver = (*q.begin()).second;
for (auto j : graph[ver]) {
graph[j].erase(ver);
q.erase({deg[j], j});
q.insert({deg[j] - 1, j});
deg[j]--;
}
q.erase({deg[ver], ver});
}
ans[i] = q.size();
int a = friendship[i].first;
int b = friendship[i].second;
if (q.count({deg[a], a}) && q.count({deg[b], b})) {
q.erase({deg[a], a});
q.erase({deg[b], b});
graph[a].erase(b);
graph[b].erase(a);
deg[a]--;
deg[b]--;
q.insert({deg[a], a});
q.insert({deg[b], b});
}
}
for (auto i : ans) cout << i << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt = 1;
while (tt--) {
Solve();
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double Pi = 3.14159265359;
const long long MOD = (long long)1e9 + 7;
const long long MAXN = (long long)2e5 + 10;
const long long INF = (long long)9223372036854775;
const long double EPS = (long double)1e-8;
set<long long> ans;
set<long long> g[MAXN];
vector<pair<long long, long long> > q;
vector<long long> anss;
queue<long long> bfsq;
long long vis[MAXN];
int main() {
long long n, m, k, u, v;
scanf("%lld", &n);
scanf("%lld", &m);
scanf("%lld", &k);
long long an = n;
for (int i = 0; i < m; i++) {
scanf("%lld", &u);
scanf("%lld", &v);
u--;
v--;
g[u].insert(v);
g[v].insert(u);
q.push_back(make_pair(u, v));
}
for (int i = 0; i < n; i++) ans.insert(i);
for (int i = 0; i < n; i++) {
if (g[i].size() < k) {
bfsq.push(i);
vis[i] = 1;
}
}
while (bfsq.size() != 0) {
for (auto adj : g[bfsq.front()]) {
g[adj].erase(bfsq.front());
if (g[adj].size() < k) {
if (vis[adj] == 0) bfsq.push(adj);
vis[adj] = 1;
}
}
ans.erase(bfsq.front());
bfsq.pop();
an--;
}
anss.push_back(an);
for (int i = 0; i < m; i++) {
u = q.back().first;
v = q.back().second;
if ((vis[u] == 1) or (vis[v] == 1)) {
anss.push_back(an);
q.pop_back();
continue;
}
g[u].erase(v);
g[v].erase(u);
if (g[u].size() < k) {
bfsq.push(u);
vis[u] = 1;
}
if (g[v].size() < k) {
bfsq.push(v);
vis[v] = 1;
}
while (bfsq.size() != 0) {
for (auto adj : g[bfsq.front()]) {
g[adj].erase(bfsq.front());
if (g[adj].size() < k) {
if (vis[adj] == 0) bfsq.push(adj);
vis[adj] = 1;
}
}
ans.erase(bfsq.front());
bfsq.pop();
an--;
}
anss.push_back(an);
q.pop_back();
}
anss.pop_back();
for (int i = 0; i < m; i++) {
printf("%lld\n", anss.back());
anss.pop_back();
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int Int() {
int x;
scanf("%d", &x);
return x;
}
long long Long() {
long long x;
scanf("%lld", &x);
return x;
}
double Double() {
double x;
scanf("%lf", &x);
return x;
}
const int N = 2 * (int)1e5 + 5;
const long long MOD = (int)1e9 + 7;
int us[N], vs[N], ans[N], degree[N];
bool can[N];
set<pair<int, int> > trip;
vector<pair<int, int> > g[N];
int main() {
int n = Int(), m = Int(), k = Int();
memset(can, true, sizeof can);
for (int i = 1; i <= m; i++) {
us[i] = Int(), vs[i] = Int();
g[us[i]].push_back({vs[i], i});
g[vs[i]].push_back({us[i], i});
degree[us[i]]++;
degree[vs[i]]++;
}
for (int i = 1; i <= n; i++) {
trip.insert({degree[i], i});
}
while (!trip.empty() and trip.begin()->first < k) {
int u = trip.begin()->second;
for (auto j : g[u]) {
if (can[j.first]) {
trip.erase({degree[j.first], j.first});
degree[j.first]--;
trip.insert({degree[j.first], j.first});
}
}
trip.erase({degree[u], u});
can[u] = false;
}
for (int i = m; i > 0; i--) {
ans[i] = trip.size();
if (can[us[i]] and can[vs[i]]) {
trip.erase({degree[us[i]], us[i]});
degree[us[i]]--;
trip.insert({degree[us[i]], us[i]});
trip.erase({degree[vs[i]], vs[i]});
degree[vs[i]]--;
trip.insert({degree[vs[i]], vs[i]});
while (!trip.empty() and trip.begin()->first < k) {
int u = trip.begin()->second;
for (auto j : g[u]) {
if (j.second >= i) continue;
if (can[j.first]) {
trip.erase({degree[j.first], j.first});
degree[j.first]--;
trip.insert({degree[j.first], j.first});
}
}
trip.erase({degree[u], u});
can[u] = false;
}
}
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << '\n';
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = double;
using pii = pair<int, int>;
using vi = vector<int>;
const int maxn = 5e5;
const int inf = 1e9;
const int mod = 1e9 + 7;
const ll inf64 = 1e18;
const ld pi = acos(-1.0);
const ld eps = 1e-6;
int n, m, k, deg[maxn];
set<int> g[maxn];
int uu[maxn], vv[maxn];
int ans[maxn];
int del[maxn];
int cur;
void go(int v) {
queue<int> q;
q.push(v);
while (!q.empty()) {
v = q.front();
q.pop();
if (del[v]) continue;
del[v] = 1;
cur--;
for (int to : g[v]) {
g[to].erase(v);
if (--deg[to] < k) q.push(to);
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].insert(v);
g[v].insert(u);
deg[u]++;
deg[v]++;
uu[i] = u;
vv[i] = v;
}
cur = n;
for (int i = 0; i < n; i++)
if (del[i] == 0 && deg[i] < k) {
go(i);
}
for (int i = m - 1; i >= 0; i--) {
ans[i] = cur;
if (del[uu[i]] == 0 && del[vv[i]] == 0) {
deg[uu[i]]--;
deg[vv[i]]--;
g[uu[i]].erase(vv[i]);
g[vv[i]].erase(uu[i]);
if (deg[uu[i]] < k) go(uu[i]);
if (deg[vv[i]] < k) go(vv[i]);
}
}
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxi = 1e6 + 2;
int a[maxi], b[maxi];
int res[maxi];
vector<int> v[maxi];
string s;
int n, m, k;
int ok;
int rem[maxi];
int deg[maxi];
map<pair<int, int>, int> mp;
queue<int> q;
void skloni(int poz) {
while (!q.empty()) {
int x = q.front();
deg[x] = 0;
q.pop();
for (int i : v[x]) {
if (!rem[i] && deg[i] == k && !mp[{x, i}]) {
deg[i]--;
res[poz]--;
q.push(i);
rem[i] = 1;
mp[{x, i}] = 1;
mp[{i, x}] = 1;
} else {
if (!mp[{x, i}]) deg[i]--;
mp[{x, i}] = 1;
mp[{i, x}] = 1;
}
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[i] = x;
b[i] = y;
v[x].push_back(y);
v[y].push_back(x);
deg[x]++;
deg[y]++;
}
res[m] = n;
for (int i = 1; i <= n; i++)
if (deg[i] < k) {
q.push(i);
rem[i] = 1;
res[m]--;
}
skloni(m);
for (int i = m; i >= 1; i--) {
res[i - 1] = res[i];
if (!mp[{a[i], b[i]}]) {
deg[a[i]]--;
deg[b[i]]--;
mp[{a[i], b[i]}] = 1;
mp[{b[i], a[i]}] = 1;
if (deg[a[i]] == k - 1 && !rem[a[i]]) {
rem[a[i]] = 1;
res[i - 1]--;
q.push(a[i]);
};
if (deg[b[i]] == k - 1 && !rem[b[i]]) {
rem[b[i]] = 1;
res[i - 1]--;
q.push(b[i]);
};
skloni(i - 1);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", res[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
set<int> V[200200];
pair<int, int> edges[200200];
set<int> active;
int answer[200200];
void fix(int i) {
if (active.find(i) == active.end()) return;
if (V[i].size() < k) {
for (int x : V[i]) V[x].erase(i);
for (int x : V[i]) fix(x);
active.erase(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
edges[i].first = x;
edges[i].second = y;
V[x].insert(y);
V[y].insert(x);
}
for (int i = 1; i <= n; i++) active.insert(i);
for (int i = 1; i <= n; i++) fix(i);
for (int i = m - 1; i >= 0; i--) {
answer[i] = active.size();
int x = edges[i].first, y = edges[i].second;
V[x].erase(y);
V[y].erase(x);
fix(x);
fix(y);
}
for (int i = 0; i < m; i++) cout << answer[i] << "\n";
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
struct edge {
int v, nxt;
} e[200005 * 2];
int cnt = 1, head[200005];
void adde(int u, int v) {
e[++cnt].v = v;
e[cnt].nxt = head[u];
head[u] = cnt;
}
int vis[200005 * 2], d[200005], ans[200005], res;
struct ege2 {
int u, v;
} edge[200005];
queue<int> q;
void solve() {
while (!q.empty()) {
int u = q.front();
q.pop();
d[u] = 0;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (vis[i]) continue;
vis[i] = vis[i ^ 1] = 1;
d[v]--;
if (d[v] == k - 1) {
--res;
q.push(v);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1, u, v; i <= m; ++i) {
scanf("%d%d", &u, &v);
edge[i].u = u;
edge[i].v = v;
adde(u, v);
adde(v, u);
++d[u];
++d[v];
}
res = n;
for (int i = 1; i <= n; ++i)
if (d[i] < k) {
--res;
q.push(i);
}
solve();
ans[m] = res;
for (int i = m; i >= 2; --i) {
if (vis[i << 1]) {
ans[i - 1] = ans[i];
continue;
}
vis[i << 1] = vis[i << 1 | 1] = 1;
int u = edge[i].u, v = edge[i].v;
d[u]--;
d[v]--;
if (d[u] == k - 1) {
--res;
q.push(u);
}
if (d[v] == k - 1) {
--res;
q.push(v);
}
solve();
ans[i - 1] = res;
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
set<int> adj[maxn];
int K;
queue<int> Q;
bool deleted[maxn];
int delc;
void del_edge(int u, int v) {
if (adj[u].count(v) != 0) {
adj[u].erase(v);
if (!deleted[u] && (int)adj[u].size() < K) {
deleted[u] = 1;
delc++;
Q.push(u);
}
}
if (adj[v].count(u) != 0) {
adj[v].erase(u);
if (!deleted[v] && (int)adj[v].size() < K) {
deleted[v] = 1;
delc++;
Q.push(v);
}
}
}
void del_vert(int u) {
vector<int> todel;
for (int v : adj[u]) {
todel.push_back(v);
}
for (int v : todel) {
del_edge(u, v);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int vertexc, queryc;
cin >> vertexc >> queryc >> K;
vector<pair<int, int>> edges;
for (int i = 0; i < queryc; i++) {
int u, v;
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
edges.push_back(make_pair(u, v));
}
for (int i = 1; i <= vertexc; i++) {
if ((int)adj[i].size() < K) {
deleted[i] = 1;
delc++;
Q.push(i);
}
}
deque<int> ans;
for (int i = 0; i < queryc; i++) {
while (!Q.empty()) {
int qtop = Q.front();
Q.pop();
del_vert(qtop);
}
ans.push_front(vertexc - delc);
pair<int, int> uv = edges.back();
edges.pop_back();
if (!deleted[uv.first] && !deleted[uv.second]) {
del_edge(uv.first, uv.second);
}
}
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i] << '\n';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int u[200050];
int v[200050];
int ans[200050];
int n, m, k;
set<int> s, num[200050];
void dfs(int u) {
if (num[u].size() < k && s.erase(u)) {
for (auto i : num[u]) {
num[i].erase(u);
dfs(i);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u[i], &v[i]);
num[u[i]].insert(v[i]);
num[v[i]].insert(u[i]);
}
for (int i = 1; i <= n; i++) s.insert(i);
for (int i = 1; i <= n; i++) dfs(i);
for (int i = m; i; i--) {
ans[i] = s.size();
if (s.empty()) break;
num[u[i]].erase(v[i]);
num[v[i]].erase(u[i]);
dfs(u[i]);
dfs(v[i]);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> v[200100];
int lv[200100];
vector<int> gr[200100];
int in[200100];
vector<int> go;
map<pair<int, int>, int> taiat;
int n, m, k, cont;
void dfs(int nod) {
in[nod] = 0;
cont--;
for (auto &x : gr[nod]) {
if (taiat[{nod, x}]) {
continue;
}
taiat[{nod, x}] = 1;
taiat[{x, nod}] = 1;
lv[x]--;
if (in[x] && lv[x] < k) {
dfs(x);
}
}
}
vector<int> ans;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
cont = n;
for (int i = 1; i <= m; i++) {
cin >> v[i].first >> v[i].second;
gr[v[i].first].push_back(v[i].second);
gr[v[i].second].push_back(v[i].first);
lv[v[i].first]++;
lv[v[i].second]++;
}
for (int i = 1; i <= n; i++) {
in[i] = 1;
}
for (int i = 1; i <= n; i++) {
if (lv[i] < k) {
go.push_back(i);
}
}
for (auto &x : go) {
if (in[x]) {
dfs(x);
}
}
for (int i = m; i >= 1; i--) {
ans.push_back(cont);
if (taiat[{v[i].first, v[i].second}]) {
continue;
}
taiat[{v[i].first, v[i].second}] = 1;
taiat[{v[i].second, v[i].first}] = 1;
lv[v[i].first]--;
lv[v[i].second]--;
if (lv[v[i].first] < k && in[v[i].first]) {
dfs(v[i].first);
}
if (lv[v[i].second] < k && in[v[i].second]) {
dfs(v[i].second);
}
}
reverse(ans.begin(), ans.end());
for (auto &x : ans) {
cout << x << '\n';
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, a, b, c, d, op, mini, mij, ls, ld, ul, timp, k, maxl, rasp;
int dp[1000005], flower[1000005], viz[1000005];
int good[1000005];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
int sol[1000005];
vector<pair<int, int> > muchii;
vector<pair<int, int> > v[1000005];
int gm[1000005];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
muchii.push_back({a, b});
v[a].push_back({b, i});
v[b].push_back({a, i});
gm[i] = 1;
}
for (int i = 1; i <= n; i++) {
dp[i] = v[i].size();
q.push({dp[i], i});
good[i] = 1;
}
rasp = n;
while (q.size() && (q.top().first < k || good[q.top().second] == 0)) {
pair<int, int> now = q.top();
q.pop();
if (good[now.second] == 0) continue;
good[now.second] = 0;
rasp--;
for (int i = 0; i < v[now.second].size(); i++) {
int nxt = v[now.second][i].first;
dp[nxt]--;
if (good[nxt]) q.push({dp[nxt], nxt});
}
}
vector<int> sol;
for (j = m; j; j--) {
sol.push_back(rasp);
a = muchii[j - 1].first;
b = muchii[j - 1].second;
gm[j] = 0;
if (good[a] && good[b]) {
dp[a]--;
dp[b]--;
q.push({dp[a], a});
q.push({dp[b], b});
}
while (q.size() && (q.top().first < k || good[q.top().second] == 0)) {
pair<int, int> now = q.top();
q.pop();
if (good[now.second] == 0) continue;
good[now.second] = 0;
rasp--;
for (int i = 0; i < v[now.second].size(); i++) {
if (gm[v[now.second][i].second]) {
int nxt = v[now.second][i].first;
dp[nxt]--;
if (good[nxt]) q.push({dp[nxt], nxt});
}
}
}
}
for (int i = sol.size() - 1; i >= 0; i--) cout << sol[i] << '\n';
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
int n, m, ans[N], cur, done[N], deg[N], k;
vector<pair<int, int> > ve[N];
pair<int, int> e[N];
void bfs(int u, int time) {
queue<int> qu;
done[u] = 1;
cur--;
qu.push(u);
int v;
while (!qu.empty()) {
u = qu.front();
qu.pop();
for (int i = 0; i < ve[u].size(); i++) {
v = ve[u][i].first;
if (done[v]) continue;
if (ve[u][i].second > time) continue;
deg[u]--;
deg[v]--;
if (deg[v] < k) {
cur--;
done[v] = 1;
qu.push(v);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
cur = n;
int u, v;
for (int i = 1; i <= m; i++) {
cin >> e[i].first >> e[i].second;
u = e[i].first;
v = e[i].second;
ve[u].push_back({v, i});
ve[v].push_back({u, i});
}
for (int i = 1; i <= n; i++) deg[i] = ve[i].size();
for (int i = 1; i <= n; i++) {
if (deg[i] < k && !done[i]) {
bfs(i, m);
}
}
ans[m] = cur;
for (int i = m - 1; i >= 1; i--) {
u = e[i + 1].first;
v = e[i + 1].second;
if (!done[u] && !done[v]) {
deg[u]--;
deg[v]--;
if (deg[u] < k && !done[u]) bfs(u, i);
if (deg[v] < k && !done[v]) bfs(v, i);
}
ans[i] = cur;
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << '\n';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
int n, m, k, u[N], v[N];
int deg[N], ans[N];
vector<int> G[N], id[N];
bool ok[N];
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u[i], &v[i]);
G[u[i]].push_back(v[i]);
G[v[i]].push_back(u[i]);
deg[u[i]]++;
deg[v[i]]++;
id[u[i]].push_back(i);
id[v[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
ok[i] = 1;
}
int c = 0;
queue<int> que;
for (int i = 1; i <= n; i++) {
if (deg[i] < k) {
ok[i] = 0;
que.push(i);
c++;
}
}
while (!que.empty()) {
int u = que.front();
que.pop();
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
deg[v]--;
if (ok[v] && deg[v] < k) {
ok[v] = 0;
que.push(v);
c++;
}
}
}
ans[m] = n - c;
for (int i = m - 1; i > 0; i--) {
c = 0;
int x = u[i + 1], y = v[i + 1];
if (ok[x] && ok[y]) {
deg[x]--;
deg[y]--;
if (deg[x] < k) {
ok[x] = 0;
c++;
que.push(x);
}
if (deg[y] < k) {
ok[y] = 0;
c++;
que.push(y);
}
}
while (!que.empty()) {
int z = que.front();
que.pop();
for (int j = 0; j < G[z].size(); j++) {
int w = G[z][j];
if (id[z][j] >= i + 1) continue;
deg[w]--;
if (ok[w] && deg[w] < k) {
ok[w] = 0;
que.push(w);
c++;
}
}
}
ans[i] = ans[i + 1] - c;
}
for (int i = 1; i <= m; i++) {
printf("%d\n", ans[i]);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, m, k;
int du[maxn];
set<int> g[maxn];
vector<pair<int, int> > ar;
set<pair<int, int> > st;
set<int>::iterator it;
int ans[maxn];
void dfs() {
if (st.size() == 0) return;
if (st.begin()->first < k) {
int u = st.begin()->second;
st.erase(st.begin());
for (it = g[u].begin(); it != g[u].end(); it++) {
int v = *it;
if (st.count(make_pair(du[v], v))) {
st.erase(make_pair(du[v], v));
du[v]--;
st.insert(make_pair(du[v], v));
}
}
dfs();
}
}
int main() {
int u, v;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
du[u]++;
du[v]++;
g[u].insert(v);
g[v].insert(u);
ar.push_back(make_pair(u, v));
}
for (int i = 1; i <= n; i++) {
st.insert(make_pair(du[i], i));
}
dfs();
for (int i = m - 1; i >= 0; i--) {
ans[i] = st.size();
u = ar[i].first;
v = ar[i].second;
if (st.count(make_pair(du[u], u)) && st.count(make_pair(du[v], v))) {
st.erase(make_pair(du[u], u));
st.erase(make_pair(du[v], v));
du[u]--;
du[v]--;
st.insert(make_pair(du[u], u));
st.insert(make_pair(du[v], v));
g[u].erase(v);
g[v].erase(u);
dfs();
}
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
namespace Xrocks {}
using namespace Xrocks;
namespace Xrocks {
class in {
} user_input;
class out {
} output;
in& operator>>(in& X, int& Y) {
scanf("%d", &Y);
return X;
}
in& operator>>(in& X, char* Y) {
scanf("%s", Y);
return X;
}
in& operator>>(in& X, float& Y) {
scanf("%f", &Y);
return X;
}
in& operator>>(in& X, double& Y) {
scanf("%lf", &Y);
return X;
}
in& operator>>(in& X, char& C) {
scanf("%c", &C);
return X;
}
in& operator>>(in& X, string& Y) {
cin >> Y;
return X;
}
in& operator>>(in& X, long long& Y) {
scanf("%lld", &Y);
return X;
}
template <typename T>
in& operator>>(in& X, vector<T>& Y) {
for (auto& x : Y) user_input >> x;
return X;
}
template <typename T>
out& operator<<(out& X, const T& Y) {
cout << Y;
return X;
}
template <typename T>
out& operator<<(out& X, vector<T>& Y) {
for (auto& x : Y) output << x << " ";
return X;
}
out& operator<<(out& X, const int& Y) {
printf("%d", Y);
return X;
}
out& operator<<(out& X, const char& C) {
printf("%c", C);
return X;
}
out& operator<<(out& X, const string& Y) {
printf("%s", Y.c_str());
return X;
}
out& operator<<(out& X, const long long& Y) {
printf("%lld", Y);
return X;
}
out& operator<<(out& X, const float& Y) {
printf("%f", Y);
return X;
}
out& operator<<(out& X, const double& Y) {
printf("%lf", Y);
return X;
}
out& operator<<(out& X, const char Y[]) {
printf("%s", Y);
return X;
}
template <typename T>
T max(T A) {
return A;
}
template <typename T, typename... args>
T max(T A, T B, args... S) {
return max(A > B ? A : B, S...);
}
template <typename T>
T min(T A) {
return A;
}
template <typename T, typename... args>
T min(T A, T B, args... S) {
return min(A < B ? A : B, S...);
}
template <typename T>
void vectorize(int y, vector<T>& A) {
A.resize(y);
}
template <typename T, typename... args>
void vectorize(int y, vector<T>& A, args&&... S) {
A.resize(y);
vectorize(y, S...);
}
long long fast(long long a, long long b, long long pr) {
if (b == 0) return 1 % pr;
long long ans = 1 % pr;
while (b) {
if (b & 1) ans = (ans * a) % pr;
b >>= 1;
a = (a * a) % pr;
}
return ans;
}
int readInt() {
int n = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar_unlocked();
n = n * sign;
return n;
}
long long readLong() {
long long n = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar_unlocked();
n = n * sign;
return n;
}
long long readBin() {
long long n = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '1') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '1')
n = (n << 1) + (ch - '0'), ch = getchar_unlocked();
return n;
}
long long inv_(long long val,
long long pr = static_cast<long long>(998244353)) {
return fast(val, pr - 2, pr);
}
} // namespace Xrocks
class solve {
public:
solve() {
int n, m, k;
user_input >> n >> m >> k;
vector<pair<int, int> > Edges(m);
vector<int> Ans(m);
vector<int> degree(n);
vector<vector<pair<int, int> > > adj(n);
set<pair<int, int> > Good_set;
vector<int> in_good_set(n, true);
for (int i = 0; i < m; i++) {
user_input >> Edges[i].first >> Edges[i].second;
Edges[i].first--;
Edges[i].second--;
adj[Edges[i].first].push_back({Edges[i].second, i});
adj[Edges[i].second].push_back({Edges[i].first, i});
degree[Edges[i].first]++;
degree[Edges[i].second]++;
}
for (int i = 0; i < n; i++) {
Good_set.insert({degree[i], i});
}
while (!Good_set.empty() && Good_set.begin()->first < k) {
int node = Good_set.begin()->second;
for (auto& y : adj[node]) {
int x = y.first;
if (in_good_set[x]) {
Good_set.erase({degree[x], x});
--degree[x];
Good_set.insert({degree[x], x});
}
}
Good_set.erase({degree[node], node});
in_good_set[node] = false;
}
for (int i = m - 1; i >= 0; i--) {
Ans[i] = Good_set.size();
int u = Edges[i].first, v = Edges[i].second;
if (in_good_set[u] && in_good_set[v]) {
Good_set.erase({degree[u], u});
--degree[u];
Good_set.insert({degree[u], u});
Good_set.erase({degree[v], v});
--degree[v];
Good_set.insert({degree[v], v});
while (!Good_set.empty() && Good_set.begin()->first < k) {
int node = Good_set.begin()->second;
for (auto& y : adj[node]) {
int x = y.first;
if (y.second >= i) continue;
if (in_good_set[x]) {
Good_set.erase({degree[x], x});
--degree[x];
Good_set.insert({degree[x], x});
}
}
Good_set.erase({degree[node], node});
in_good_set[node] = false;
}
}
}
for (int i = 0; i < m; i++) {
output << Ans[i] << "\n";
}
}
};
int32_t main() {
int t = 1, i = 1;
if (0 || 0) scanf("%d", &t);
while (t--) {
if (0) printf("Case #%d: ", i++);
new solve;
}
output << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
const int maxm = 1.5e7 + 10;
const int mod = 998244353;
using namespace std;
int n, m, k, ans;
int num[maxn], vis[maxn], sum[maxn];
pair<int, int> a[maxn];
set<int> st[maxn];
void check(int x) {
if (num[x] >= k || !vis[x]) return;
vis[x] = 0;
ans--;
queue<int> q;
q.push(x);
while (!q.empty()) {
int tmp = q.front();
q.pop();
set<int>::iterator it = st[tmp].begin();
while (it != st[tmp].end()) {
num[*it]--;
if (vis[*it] && num[*it] < k) {
q.push(*it);
vis[*it] = 0;
ans--;
}
it++;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
ans = n;
for (int i = 1; i <= n; i++) vis[i] = 1;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[i].first = x, a[i].second = y;
num[x]++, num[y]++;
st[x].insert(y), st[y].insert(x);
}
for (int i = 1; i <= n; i++) check(i);
for (int i = m - 1; i >= 0; i--) {
sum[i] = ans;
if (vis[a[i].second]) num[a[i].first]--;
if (vis[a[i].first]) num[a[i].second]--;
st[a[i].first].erase(a[i].second);
st[a[i].second].erase(a[i].first);
check(a[i].first), check(a[i].second);
}
for (int i = 0; i < m; i++) printf("%d\n", sum[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 3;
int n, m, k, deg[N], x[N], y[N], ans[N], cnt;
bool del[N];
set<int> G[N];
set<int>::iterator it;
void Del(int rt) {
if (deg[rt] >= k || del[rt]) return;
queue<int> q;
q.push(rt);
del[rt] = 1;
cnt--;
while (!q.empty()) {
int u = q.front();
q.pop();
for (it = G[u].begin(); it != G[u].end(); it++) {
int v = *it;
deg[v]--;
if (deg[v] < k && !del[v]) {
del[v] = 1;
q.push(v);
cnt--;
}
}
}
}
int main() {
memset(deg, 0, sizeof deg);
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d%d", x + i, y + i);
deg[x[i]]++;
deg[y[i]]++;
G[x[i]].insert(y[i]);
G[y[i]].insert(x[i]);
}
cnt = n;
for (int i = 1; i <= n; i++) Del(i);
for (int i = m; i; i--) {
ans[i] = cnt;
if (!del[x[i]]) deg[y[i]]--;
if (!del[y[i]]) deg[x[i]]--;
G[x[i]].erase(y[i]);
G[y[i]].erase(x[i]);
Del(x[i]);
Del(y[i]);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int l[200100], r[200100];
int n, m, k;
int de[200100];
bool ex[200100];
struct ind {
int id, de;
ind(int a, int b) : id(a), de(b) {}
bool operator<(const ind &b) const {
return de != b.de ? de < b.de : id < b.id;
}
};
vector<int> pa[200100];
set<ind> S;
int fd(int id, int x) { return l[id] == x ? r[id] : l[id]; }
void erase(int x) {
if (de[x] < k) return;
S.erase(ind(x, de[x]));
de[x]--;
S.insert(ind(x, de[x]));
}
void dele(int x) {
S.erase(ind(x, de[x]));
for (auto y : pa[x])
if (!ex[y] && de[fd(y, x)] >= k) erase(fd(y, x));
}
int main() {
scanf("%d%d%d", &n, &m, &k);
int a, b;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &a, &b);
++de[a], ++de[b];
l[i] = a, r[i] = b;
pa[a].push_back(i);
pa[b].push_back(i);
}
for (int i = 1; i <= n; ++i) S.insert(ind(i, de[i]));
int as[200100];
for (int i = m; i >= 1; --i) {
while (S.size()) {
if ((*S.begin()).de < k)
dele((*S.begin()).id);
else
break;
}
as[i] = S.size();
int x = l[i], y = r[i];
if (de[x] >= k && de[y] >= k) erase(x), erase(y);
ex[i] = 1;
}
for (int i = 1; i <= m; ++i) printf("%d\n", as[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
set<int> v[200005];
int x[200005];
int y[200005];
int an[200005];
set<pair<int, int> > s;
void r(int i, int k) {
if (v[x[i]].size() >= k && v[y[i]].size() >= k) {
s.erase(pair<int, int>(v[x[i]].size(), x[i]));
s.erase(pair<int, int>(v[y[i]].size(), y[i]));
v[x[i]].erase(y[i]);
v[y[i]].erase(x[i]);
s.insert(pair<int, int>(v[x[i]].size(), x[i]));
s.insert(pair<int, int>(v[y[i]].size(), y[i]));
}
}
void solve(int k) {
if (s.empty() || s.begin()->first >= k) return;
int x = s.begin()->second;
s.erase(s.begin());
for (auto it = v[x].begin(); it != v[x].end(); it++)
if (v[*it].size() >= k) {
s.erase(pair<int, int>(v[*it].size(), *it));
v[*it].erase(x);
s.insert(pair<int, int>(v[*it].size(), *it));
}
solve(k);
}
int main() {
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
v[x[i]].insert(y[i]);
v[y[i]].insert(x[i]);
}
for (int i = 0; i < n; i++) {
s.insert(pair<int, int>(v[i + 1].size(), i + 1));
}
for (int i = m - 1; i >= 0; i--) {
solve(k);
an[i] = s.size();
r(i, k);
}
for (int i = 0; i < m; i++) cout << an[i] << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int u[200005], v[200005];
int cnt[200005];
unordered_set<int> adj[200005];
unordered_set<int> take;
stack<int> ans;
queue<int> cac, toerase;
int n, m, k;
void emptycac() {
while (cac.size()) {
int node = cac.front();
cac.pop();
for (auto j : adj[node]) {
if (take.count(j)) {
adj[j].erase(node);
if (adj[j].size() < k) {
take.erase(j);
cac.push(j);
}
}
}
while (toerase.size()) {
take.erase(toerase.front());
toerase.pop();
}
}
}
signed main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> u[i] >> v[i];
adj[u[i]].insert(v[i]);
adj[v[i]].insert(u[i]);
}
for (int i = 1; i <= n; i++) {
if (adj[i].size() >= k) {
take.insert(i);
for (auto j : adj[i]) {
take.insert(j);
}
}
}
for (auto i : take) {
if (adj[i].size() < k) {
cac.push(i);
toerase.push(i);
}
}
while (toerase.size()) {
take.erase(toerase.front());
toerase.pop();
}
emptycac();
for (int i = m; i >= 1; i--) {
ans.push(take.size());
if (take.count(u[i]) && take.count(v[i])) {
adj[u[i]].erase(v[i]);
adj[v[i]].erase(u[i]);
if (adj[v[i]].size() < k) {
take.erase(v[i]);
cac.push(v[i]);
}
if (adj[u[i]].size() < k) {
take.erase(u[i]);
cac.push(u[i]);
}
emptycac();
}
}
while (ans.size()) {
cout << ans.top() << endl;
ans.pop();
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int> > arr(m);
vector<vector<int> > G(n);
vector<int> in(n), vis(n);
for (auto& it : arr) {
int u, v;
cin >> u >> v;
in[--u]++;
in[--v]++;
it = {u, v};
G[u].push_back(v);
G[v].push_back(u);
}
queue<int> q;
for (int i = 0; i < n; i++) {
if (in[i] < k) {
q.push(i);
vis[i] = 1;
}
}
int cur = n - q.size();
set<pair<int, int> > cnt;
while (!q.empty()) {
auto x = q.front();
q.pop();
for (auto& it : G[x]) {
auto node = minmax(x, it);
if (cnt.find(node) == cnt.end()) {
cnt.insert(node);
if (!vis[it] && --in[it] < k) {
vis[it] = 1;
q.push(it);
cur--;
}
}
}
}
reverse(arr.begin(), arr.end());
vector<int> ans;
for (auto& it : arr) {
ans.push_back(cur);
auto node = minmax(it.first, it.second);
if (cnt.find(node) == cnt.end()) {
cnt.insert(node);
if (!vis[it.first] && --in[it.first] < k) {
vis[it.first] = 1;
q.push(it.first);
cur--;
}
if (!vis[it.second] && --in[it.second] < k) {
vis[it.second] = 1;
q.push(it.second);
cur--;
}
while (!q.empty()) {
auto x = q.front();
q.pop();
for (auto& jt : G[x]) {
auto node = minmax(x, jt);
if (cnt.find(node) == cnt.end()) {
cnt.insert(node);
if (!vis[jt] && --in[jt] < k) {
vis[jt] = 1;
q.push(jt);
cur--;
}
}
}
}
}
}
reverse(ans.begin(), ans.end());
for (auto& it : ans) cout << it << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
vector<int> v[maxn];
pair<long long, long long> a[maxn];
long long q[maxn], siz[maxn];
bool c[maxn];
long long n, m, k;
set<pair<long long, long long> > s;
map<pair<long long, long long>, bool> mark;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (long long y = 0; y < m; y++) {
cin >> a[y].first >> a[y].second;
v[a[y].first].push_back(a[y].second), v[a[y].second].push_back(a[y].first);
siz[a[y].second]++, siz[a[y].first]++;
}
for (long long y = 1; y <= n; y++)
s.insert(pair<long long, long long>(siz[y], y));
for (long long y = m - 1; y >= 0; y--) {
if (y != m - 1 && !mark[a[y + 1]]) {
mark[pair<long long, long long>(a[y + 1].second, a[y + 1].first)] =
mark[pair<long long, long long>(a[y + 1].first, a[y + 1].second)] = 1;
long long i = a[y + 1].second;
siz[i]--;
if (c[i] == 0) {
pair<long long, long long> x =
pair<long long, long long>(siz[i] + 1, i);
s.erase(x);
x.first--;
s.insert(x);
}
i = a[y + 1].first;
siz[i]--;
if (c[i] == 0) {
pair<long long, long long> x =
pair<long long, long long>(siz[i] + 1, i);
s.erase(x);
x.first--;
s.insert(x);
}
}
while (s.size() != 0) {
pair<long long, long long> x = *s.begin();
if (x.first >= k) break;
s.erase(x);
c[x.second] = 1;
for (long long ii = 0; ii < v[x.second].size(); ii++) {
long long i = v[x.second][ii];
if (!mark[pair<long long, long long>(x.second, i)]) {
mark[pair<long long, long long>(x.second, i)] =
mark[pair<long long, long long>(i, x.second)] = 1;
siz[i]--;
siz[x.second]--;
if (!c[i]) {
pair<long long, long long> z =
pair<long long, long long>(siz[i] + 1, i);
s.erase(z);
z.first--;
s.insert(z);
}
}
}
}
q[y] = s.size();
}
for (long long y = 0; y < m; y++) cout << q[y] << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210000;
int n, m, k;
int s[MAXN], t[MAXN];
int d[MAXN];
int ans[MAXN], vis[MAXN];
vector<int> edge[MAXN];
pair<int, int> mk(int x, int y) {
return x > y ? make_pair(y, x) : make_pair(x, y);
}
set<pair<int, int> > S;
queue<int> q;
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &s[i], &t[i]);
edge[s[i]].push_back(t[i]);
edge[t[i]].push_back(s[i]);
d[s[i]]++, d[t[i]]++;
}
int cnt = n;
for (int i = 1; i <= n; i++) {
if (d[i] < k) {
q.push(i);
vis[i] = 1;
cnt--;
}
}
while (!q.empty()) {
int now = q.front();
q.pop();
for (unsigned i = 0; i < edge[now].size(); i++) {
int v = edge[now][i];
if (S.count(mk(now, v))) continue;
S.insert(mk(now, v));
d[now]--, d[v]--;
if (d[v] < k && vis[v] == 0) {
q.push(v);
vis[v] = 1;
cnt--;
}
}
}
for (int i = m; i >= 1; --i) {
ans[i] = cnt;
if (vis[s[i]] || vis[t[i]] || S.count(mk(s[i], t[i]))) continue;
S.insert(mk(s[i], t[i]));
d[s[i]]--, d[t[i]]--;
if (d[s[i]] < k && vis[s[i]] == 0) {
q.push(s[i]);
vis[s[i]] = 1;
cnt--;
}
if (d[t[i]] < k && vis[t[i]] == 0) {
q.push(t[i]);
vis[t[i]] = 1;
cnt--;
}
while (!q.empty()) {
int now = q.front();
q.pop();
for (unsigned i = 0; i < edge[now].size(); i++) {
int v = edge[now][i];
if (S.count(mk(now, v))) continue;
d[now]--, d[v]--;
if (d[v] < k && vis[v] == 0) {
S.insert(mk(now, v));
q.push(v);
vis[v] = 1;
cnt--;
}
}
}
}
for (int i = 1; i <= m; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010, M = 400010, mod = 1e9 + 7;
int n, m, k;
int h[N], e[M], ne[M], idx;
int a[N], b[N], ans[N];
int ind[N], oud[N], cnt;
bool stn[N], stm[M];
struct Edge {
int a, b;
} edge[M];
void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
queue<int> q;
void delet_node() {
while (!q.empty()) {
int t = q.front();
q.pop();
for (int i = h[t]; ~i; i = ne[i]) {
if (stm[i]) continue;
int j = e[i];
ind[j]--;
if (ind[j] < k && !stn[j]) {
q.push(j), stn[j] = 1, cnt--;
}
}
}
}
void topsort() {
for (int i = 1; i <= n; i++) {
if (ind[i] < k) q.push(i), cnt--, stn[i] = 1;
}
delet_node();
for (int i = m; i >= 1; i--) {
ans[i] = cnt;
int a = edge[i].a, b = edge[i].b;
if (!stn[a] && !stn[b]) ind[a]--, ind[b]--;
stm[--idx] = 1, stm[--idx] = 1;
if (ind[a] < k && !stn[a]) q.push(a), stn[a] = 1, cnt--;
if (ind[b] < k && !stn[b]) q.push(b), stn[b] = 1, cnt--;
delet_node();
}
for (int i = 1; i <= m; i++) cout << ans[i] << endl;
}
int main() {
memset(h, -1, sizeof h);
scanf("%d%d%d", &n, &m, &k);
cnt = n;
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
edge[i] = {a, b};
add(a, b), add(b, a);
ind[a]++, ind[b]++;
}
topsort();
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const long long MOD = 1e9 + 7;
pair<int, int> es[200000];
vector<pair<int, int> > g[200000];
int degree[200000];
set<pair<int, int> > st;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (long long i = 0; i < m; i++) {
scanf("%d%d", &es[i].first, &es[i].second);
es[i].first--, es[i].second--;
g[es[i].first].push_back({es[i].second, i});
g[es[i].second].push_back({es[i].first, i});
degree[es[i].first]++, degree[es[i].second]++;
}
reverse(es, es + m);
for (long long i = 0; i < n; i++) st.insert({degree[i], i});
while (!st.empty() && st.begin()->first < k) {
auto v = st.begin();
for (pair<int, int> &i : g[v->second]) {
int to = i.first;
if (st.find({degree[to], to}) != st.end()) {
st.erase({degree[to], to});
degree[to]--;
st.insert({degree[to], to});
}
}
st.erase(v);
}
vector<int> out;
for (long long j = 0; j < m; j++) {
out.push_back(st.size());
int u = es[j].first, v = es[j].second;
if (st.find({degree[u], u}) != st.end() &&
st.find({degree[v], v}) != st.end()) {
st.erase({degree[u], u});
degree[u]--;
st.insert({degree[u], u});
st.erase({degree[v], v});
degree[v]--;
st.insert({degree[v], v});
while (!st.empty() && st.begin()->first < k) {
auto v = st.begin();
for (pair<int, int> &i : g[v->second]) {
if (i.second >= m - j - 1) continue;
int to = i.first;
if (st.find({degree[to], to}) != st.end()) {
st.erase({degree[to], to});
degree[to]--;
st.insert({degree[to], to});
}
}
st.erase(v);
}
}
}
reverse(begin(out), end(out));
for (int i : out) printf("%d\n", i);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename Pr = less<T>>
using pq = priority_queue<T, vector<T>, Pr>;
using i64 = long long int;
using ii = pair<int, int>;
using ii64 = pair<i64, i64>;
set<int> adj[200005];
bool removed[200005];
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
vector<ii> edges(m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &edges[i].first, &edges[i].second);
adj[edges[i].first].insert(edges[i].second);
adj[edges[i].second].insert(edges[i].first);
}
set<ii> nodes;
for (int i = 1; i <= n; i++) nodes.emplace(adj[i].size(), i);
reverse((edges).begin(), (edges).end());
vector<int> ans(m);
for (int i = 0; i < m; i++) {
while (!nodes.empty() && nodes.begin()->first < k) {
auto x = nodes.begin()->second;
removed[x] = true;
nodes.erase(nodes.begin());
for (auto& e : adj[x]) {
nodes.erase(ii(adj[e].size(), e));
adj[e].erase(x);
nodes.emplace(adj[e].size(), e);
}
}
ans[m - 1 - i] = nodes.size();
auto& [x, y] = edges[i];
if (removed[x] || removed[y]) continue;
nodes.erase(ii(adj[x].size(), x));
nodes.erase(ii(adj[y].size(), y));
adj[x].erase(y);
adj[y].erase(x);
nodes.emplace(adj[x].size(), x);
nodes.emplace(adj[y].size(), y);
}
for (auto& ai : ans) printf("%d\n", ai);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(long long& x, long long y, long long mod = 998244353) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, long long mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
vector<pair<int, int> > mp[200105];
int u[200105], v[200105], d[200105], ans[200105];
bool vis[200105], del[200105];
void fmain(int ID) {
scanf("%d%d%d", &n, &m, &k);
for (int(i) = 1; (i) <= (int)(m); (i)++) {
scanf("%d%d", u + i, v + i);
d[u[i]]++;
d[v[i]]++;
mp[u[i]].push_back({v[i], i});
mp[v[i]].push_back({u[i], i});
}
set<pair<int, int> > q;
for (int(i) = 1; (i) <= (int)(n); (i)++) q.insert({d[i], i});
int sz = n;
for (int i = m; i; i--) {
while (!q.empty() && q.begin()->first < k) {
int x = q.begin()->second;
q.erase(q.begin());
del[x] = 1;
sz--;
for (auto cp : mp[x])
if (!vis[cp.second] && !del[cp.first]) {
vis[cp.second] = 1;
int y = cp.first;
q.erase({d[y], y});
d[y]--;
q.insert({d[y], y});
}
}
ans[i] = sz;
if (vis[i]) continue;
vis[i] = 1;
int y = u[i];
q.erase({d[y], y});
d[y]--;
q.insert({d[y], y});
y = v[i];
q.erase({d[y], y});
d[y]--;
q.insert({d[y], y});
}
for (int(i) = 1; (i) <= (int)(m); (i)++) printf("%d\n", ans[i]);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
set<int> st[N], s;
int ans[N], x[N], y[N];
int n, m, k;
void dfs(int v) {
if (st[v].size() >= k || !s.count(v)) return;
s.erase(v);
for (auto u : st[v]) {
st[u].erase(v);
if (s.count(u) && st[u].size() < k) {
dfs(u);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x[i], &y[i]);
st[x[i]].insert(y[i]);
st[y[i]].insert(x[i]);
}
for (int i = 1; i <= n; ++i) s.insert(i);
for (int i = 1; i <= n; i++) {
if (st[i].size() < k) {
dfs(i);
}
}
ans[m] = s.size();
for (int i = m; i > 1; i--) {
st[x[i]].erase(y[i]);
st[y[i]].erase(x[i]);
if (st[x[i]].size() < k) dfs(x[i]);
if (st[y[i]].size() < k) dfs(y[i]);
ans[i - 1] = s.size();
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 2e5 + 9;
set<int> g[mxn];
int k;
set<int> se;
void can_now(int u) {
if (g[u].size() < k && se.find(u) != se.end()) {
se.erase(u);
for (auto &v : g[u]) {
g[v].erase(u);
can_now(v);
}
}
}
int res[mxn];
pair<int, int> e[mxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int i, j, n, m, t, u, v;
cin >> n >> m >> k;
for (i = 1; i <= m; i++) {
cin >> u >> v;
g[u].insert(v);
g[v].insert(u);
e[i] = {u, v};
}
for (i = 1; i <= n; i++) se.insert(i);
for (i = 1; i <= n; i++) can_now(i);
for (i = m; i >= 1; i--) {
res[i] = se.size();
u = e[i].first, v = e[i].second;
g[u].erase(v);
g[v].erase(u);
can_now(u);
can_now(v);
}
for (i = 1; i <= m; i++) cout << res[i] << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int a[200010], b[200010];
vector<pair<int, int> > G[200010];
int deg[200010];
int ans[200010], cnt;
queue<int> q;
inline void spfa(int x) {
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first;
int s = G[u][i].second;
if (s >= x) continue;
if (deg[v] >= k) {
deg[v]--;
if (deg[v] < k) {
q.push(v);
cnt--;
}
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d%d", a + i, b + i);
deg[a[i]]++;
deg[b[i]]++;
G[a[i]].push_back(pair<int, int>(b[i], i));
G[b[i]].push_back(pair<int, int>(a[i], i));
}
cnt = n;
for (int i = 1; i <= n; i++)
if (deg[i] < k) q.push(i), cnt--;
spfa(m + 1);
ans[m + 1] = cnt;
for (int i = m; i > 1; i--) {
if (deg[a[i]] >= k && deg[b[i]] >= k) {
deg[a[i]]--;
deg[b[i]]--;
if (deg[a[i]] < k) q.push(a[i]), cnt--;
if (deg[b[i]] < k) q.push(b[i]), cnt--;
}
spfa(i);
ans[i] = cnt;
}
for (int i = 2; i <= m + 1; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using namespace std;
const int maxn = 2e5 + 10;
int N, M, K;
set<int> g[maxn];
set<pair<int, int> > person;
int deg[maxn];
int ans[maxn];
pair<int, int> edges[maxn];
int main() {
scanf("%d %d %d", &N, &M, &K);
for (int i = 1; i <= M; ++i) {
scanf("%d %d", &edges[i].first, &edges[i].second);
g[edges[i].first].insert(edges[i].second);
g[edges[i].second].insert(edges[i].first);
++deg[edges[i].first];
++deg[edges[i].second];
}
for (int i = 1; i <= N; ++i) {
person.insert(make_pair(deg[i], i));
}
for (int i = M; i >= 1; --i) {
int x = edges[i].first, y = edges[i].second;
while (!person.empty()) {
auto it = person.begin();
if (it->first >= K) {
break;
}
int v = it->second;
for (int u : g[v]) {
person.erase(make_pair(deg[u], u));
if (deg[u]) person.insert(make_pair(--deg[u], u));
g[u].erase(v);
}
g[v].clear();
person.erase(make_pair(deg[v], v));
deg[v] = 0;
}
ans[i] = person.size();
if (g[x].find(y) != g[x].end()) {
person.erase(make_pair(deg[x], x));
person.erase(make_pair(deg[y], y));
g[y].erase(x);
g[x].erase(y);
if (deg[x]) person.insert(make_pair(--deg[x], x));
if (deg[y]) person.insert(make_pair(--deg[y], y));
}
}
for (int i = 1; i <= M; ++i) {
printf("%d\n", ans[i]);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m1, m2;
const long long int N = 3 * 1e5;
vector<long long int>::iterator itr, itr1;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int> > Edges(m);
vector<int> Ans(m);
vector<int> degree(n);
vector<vector<pair<int, int> > > adj(n);
set<pair<int, int> > Good_set;
vector<int> in_good_set(n, true);
for (int i = 0; i < m; i++) {
cin >> Edges[i].first >> Edges[i].second;
Edges[i].first--;
Edges[i].second--;
adj[Edges[i].first].push_back({Edges[i].second, i});
adj[Edges[i].second].push_back({Edges[i].first, i});
degree[Edges[i].first]++;
degree[Edges[i].second]++;
}
for (int i = 0; i < n; i++) {
Good_set.insert({degree[i], i});
}
while (!Good_set.empty() && Good_set.begin()->first < k) {
int node = Good_set.begin()->second;
for (auto &y : adj[node]) {
int x = y.first;
if (in_good_set[x]) {
Good_set.erase({degree[x], x});
--degree[x];
Good_set.insert({degree[x], x});
}
}
Good_set.erase({degree[node], node});
in_good_set[node] = false;
}
for (int i = m - 1; i >= 0; i--) {
Ans[i] = Good_set.size();
int u = Edges[i].first, v = Edges[i].second;
if (in_good_set[u] && in_good_set[v]) {
Good_set.erase({degree[u], u});
--degree[u];
Good_set.insert({degree[u], u});
Good_set.erase({degree[v], v});
--degree[v];
Good_set.insert({degree[v], v});
while (!Good_set.empty() && Good_set.begin()->first < k) {
int node = Good_set.begin()->second;
for (auto &y : adj[node]) {
int x = y.first;
if (y.second >= i) continue;
if (in_good_set[x]) {
Good_set.erase({degree[x], x});
--degree[x];
Good_set.insert({degree[x], x});
}
}
Good_set.erase({degree[node], node});
in_good_set[node] = false;
}
}
}
for (int i = 0; i < m; i++) {
cout << Ans[i] << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\n";
err(++it, args...);
}
vector<pair<int, int> > edge(200003);
vector<vector<pair<int, int> > > ad(200003);
int sz[200003];
stack<int> pq;
int node;
int process(int k, int j) {
int i, x, a, s;
while (!pq.empty()) {
s = pq.top();
pq.pop();
node--;
sz[s] = 0;
x = ad[s].size();
for (i = 0; i < x; i++) {
a = ad[s][i].first;
if (ad[s][i].second <= j) {
sz[a]--;
if (sz[a] == k - 1) pq.push(a);
}
}
}
return node;
}
int main() {
int n, m, k, i, a, b;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
a--, b--;
ad[a].emplace_back(b, i);
ad[b].emplace_back(a, i);
sz[a]++, sz[b]++;
edge[i] = {a, b};
}
vector<int> ans(m);
for (i = 0; i < n; i++)
if (sz[i] < k) pq.push(i);
node = n;
int j;
for (i = m - 1; i >= 0; i--) {
ans[i] = process(k, i);
tie(a, b) = edge[i];
if (sz[a] > 0 && sz[b] > 0) {
if (sz[a] == k) pq.push(a);
if (sz[b] == k) pq.push(b);
sz[a]--, sz[b]--;
}
}
for (i = 0; i < m; i++) printf("%d\n", ans[i]);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
int xList[200005], yList[200005];
int deg[200005], ans[200005];
set<int> Adj[200005];
set<pair<int, int> > s;
set<pair<int, int> >::iterator p;
void work(int u) {
s.erase(make_pair(deg[u], u));
int v;
set<int>::iterator k;
for (k = Adj[u].begin(); k != Adj[u].end(); k++) {
v = (*k);
if (!s.count(make_pair(deg[v], v))) {
deg[v]--;
continue;
}
s.erase(make_pair(deg[v], v));
deg[v]--;
if (deg[v] >= K)
s.insert(make_pair(deg[v], v));
else
work(v);
}
}
int main() {
scanf("%d%d%d", &N, &M, &K);
int u, v;
for (int i = 1; i <= M; i++) {
scanf("%d%d", &u, &v);
Adj[u].insert(v);
Adj[v].insert(u);
deg[u]++;
deg[v]++;
xList[i] = u;
yList[i] = v;
}
for (int i = 1; i <= N; i++) {
s.insert(make_pair(deg[i], i));
}
while (!s.empty()) {
p = s.begin();
if (p->first < K)
work(p->second);
else
break;
}
ans[M] = s.size();
for (int i = M; i >= 1; i--) {
u = xList[i];
v = yList[i];
ans[i - 1] = s.size();
if (!s.count(make_pair(deg[u], u)) || !s.count(make_pair(deg[v], v)))
continue;
Adj[u].erase(v);
Adj[v].erase(u);
if (s.count(make_pair(deg[u], u))) {
s.erase(make_pair(deg[u], u));
deg[u]--;
s.insert(make_pair(deg[u], u));
}
if (s.count(make_pair(deg[v], v))) {
s.erase(make_pair(deg[v], v));
deg[v]--;
s.insert(make_pair(deg[v], v));
}
while (!s.empty()) {
p = s.begin();
if (p->first < K)
work(p->second);
else
break;
}
ans[i - 1] = s.size();
}
for (int i = 1; i <= M; i++) printf("%d\n", ans[i]);
getchar();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int from, to, vis, next;
} e[400020];
int top, head[200020];
vector<int> g[200020];
int in[200020], gg[200020];
int n, m, k;
int ans[200020], cnt;
void add_edge(int from, int to) {
e[++top].to = to;
e[top].from = from;
e[top].next = head[from];
head[from] = top;
}
void add(int from, int to) {
add_edge(from, to);
add_edge(to, from);
}
queue<int> q;
void del(int pos) {
if (!gg[pos]) cnt--;
q.push(pos);
gg[pos] = 1;
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = head[now]; ~i; i = e[i].next) {
if (e[i].vis || gg[e[i].to]) continue;
in[e[i].to]--;
e[i].vis = 1;
e[i ^ 1].vis = 1;
if (in[e[i].to] < k) {
cnt--;
gg[e[i].to] = 1;
q.push(e[i].to);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
cnt = n;
top = -1;
memset(head, -1, sizeof(head));
int from, to;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &from, &to);
in[from]++, in[to]++;
add(from, to);
}
for (int i = 1; i <= n; i++) {
if (head[i] == -1) cnt--, gg[i] = 1;
}
for (int i = 1; i <= n; i++) {
if (in[i] < k && !gg[i]) del(i);
}
int ttt = m;
for (int i = 2 * m - 1; i >= 1; i -= 2) {
ans[ttt--] = cnt;
if (e[i].vis) continue;
in[e[i].from]--;
in[e[i].to]--;
e[i].vis = e[i ^ 1].vis = 1;
if (!gg[e[i].from] && in[e[i].from] < k) del(e[i].from);
if (!gg[e[i].to] && in[e[i].to] < k) del(e[i].to);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
int u[200005], v[200005];
set<int> e[200005];
int deg[200005];
bool alive[200005];
int alc;
queue<int> delet;
void del(int x) {
alive[x] = false;
alc--;
for (int y : e[x]) {
if (alive[y]) {
deg[y]--;
if (deg[y] == k - 1) {
delet.push(y);
}
}
}
}
void peck(int x) {
deg[x]--;
if (deg[x] == k - 1) {
delet.push(x);
}
}
void clearq() {
while (delet.size()) {
int x = delet.front();
delet.pop();
del(x);
}
}
int ans[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> u[i] >> v[i];
u[i]--;
v[i]--;
deg[u[i]]++;
deg[v[i]]++;
e[u[i]].insert(v[i]);
e[v[i]].insert(u[i]);
}
fill(alive, alive + n, true);
alc = n;
for (int i = 0; i < n; i++)
if (deg[i] < k) delet.push(i);
for (int i = m - 1; i >= 0; i--) {
clearq();
ans[i] = alc;
e[u[i]].erase(v[i]);
e[v[i]].erase(u[i]);
if (alive[u[i]] && alive[v[i]]) {
peck(u[i]);
peck(v[i]);
}
}
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, net;
};
int head[2000000];
int e_n;
edge edges[2000000];
int deg[2000000];
bool sd[2000000];
int v1[2000000], v2[2000000];
set<pair<int, int> > help;
set<pair<int, int> > tt;
void Init() {
help.clear();
e_n = 0;
memset(sd, 0, sizeof(sd));
memset(deg, 0, sizeof(deg));
memset(head, -1, sizeof(head));
}
void add(int f, int t) {
int tmp = head[f];
edges[e_n++] = edge{t, tmp};
head[f] = e_n - 1;
}
int main(void) {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, k;
Init();
cin >> n >> m >> k;
int i, j, x, y;
for (i = 1; i <= m; i++) {
cin >> x >> y;
v1[i] = x, v2[i] = y;
add(x, y);
add(y, x);
++deg[x], ++deg[y];
}
for (i = 1; i <= n; i++) {
help.insert(make_pair(deg[i], i));
}
list<int> res;
for (i = m; i >= 1; i--) {
while (!help.empty() && help.begin()->first < k) {
int cur = help.begin()->second;
sd[cur] = 1;
help.erase(help.begin());
for (j = head[cur]; j != -1; j = edges[j].net) {
int t = edges[j].to;
if (!tt.count(make_pair(cur, t))) {
help.erase(help.find(make_pair(deg[t], t)));
deg[t]--;
help.insert(make_pair(deg[t], t));
tt.insert(make_pair(cur, t));
tt.insert(make_pair(t, cur));
}
}
}
res.push_front(help.size());
if (sd[v1[i]] == 0 && sd[v2[i]] == 0) {
help.erase(help.find(make_pair(deg[v1[i]], v1[i])));
help.insert(make_pair(--deg[v1[i]], v1[i]));
help.erase(help.find(make_pair(deg[v2[i]], v2[i])));
help.insert(make_pair(--deg[v2[i]], v2[i]));
}
tt.insert(make_pair(v1[i], v2[i]));
tt.insert(make_pair(v2[i], v1[i]));
}
for (auto a : res) cout << a << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)2e5 + 5;
int n, m, k;
vector<pair<int, int> > out[maxn];
int la[maxn];
int pos[maxn];
int deg[maxn];
int add[maxn];
bool dead[maxn];
set<pair<int, int>, greater<pair<int, int> > > s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
fill(la, la + n, -1);
for (auto i = 0; i < m; ++i) {
int v, u;
cin >> v >> u;
--v;
--u;
out[v].push_back(make_pair(i, u));
out[u].push_back(make_pair(i, v));
++deg[v];
++deg[u];
if (deg[v] == k) {
pos[v] = out[v].size() - 1;
la[v] = i;
}
if (deg[u] == k) {
pos[u] = out[u].size() - 1;
la[u] = i;
}
}
for (auto i = 0; i < n; ++i)
if (la[i] == -1) la[i] = m;
for (auto i = 0; i < n; ++i) s.insert(make_pair(la[i], i));
while (!s.empty()) {
int v = s.begin()->second;
dead[v] = true;
s.erase(s.begin());
for (auto e : out[v]) {
int u = e.second;
if (dead[u] || la[u] == la[v]) continue;
if (la[u] < e.first) continue;
s.erase(make_pair(la[u], u));
++pos[u];
while (pos[u] != (int)out[u].size() && dead[out[u][pos[u]].second])
++pos[u];
if (pos[u] == (int)out[u].size())
la[u] = m;
else
la[u] = out[u][pos[u]].first;
la[u] = min(la[u], la[v]);
s.insert(make_pair(la[u], u));
}
}
for (auto i = 0; i < n; ++i) add[la[i]]++;
int curr = 0;
for (auto i = 0; i < m; ++i) {
curr += add[i];
cout << curr << '\n';
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int N = 200005;
int n, m, k, ans[N], in[N], cnt;
std::map<int, bool> vis[N];
std::vector<int> G[N];
std::vector<std::pair<int, int> > e;
std::queue<int> q;
void topo() {
while (!q.empty()) {
int u = q.front();
q.pop();
in[u] = 0;
for (int i = 0; i < (signed)G[u].size(); i++) {
int v = G[u][i];
if (vis[u][v]) continue;
vis[u][v] = vis[v][u] = 1, in[v]--;
if (in[v] == k - 1) cnt--, q.push(v);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1, x, y; i <= m; i++) {
scanf("%d%d", &x, &y);
e.push_back(std::make_pair(x, y));
G[x].push_back(y), G[y].push_back(x);
in[x]++, in[y]++;
}
cnt = n;
for (int i = 1; i <= n; i++)
if (in[i] < k) cnt--, q.push(i);
topo(), ans[m] = cnt;
for (int i = m; i >= 2; i--) {
int u = e[i - 1].first, v = e[i - 1].second;
if (vis[u][v]) {
ans[i - 1] = ans[i];
continue;
}
vis[u][v] = vis[v][u] = 1;
in[u]--, in[v]--;
if (in[u] == k - 1) cnt--, q.push(u);
if (in[v] == k - 1) cnt--, q.push(v);
topo(), ans[i - 1] = cnt;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf32 = 1e9 + 9;
const long long inf64 = 1e18 + 18;
const int N = 2e5 + 5;
const long long mod = 1e9 + 9;
vector<int> gr[N];
set<pair<int, int> > deg;
int pw[N];
bool used[N];
void solve() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
vector<pair<int, int> > edges(m);
vector<int> ans(m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &edges[i].first, &edges[i].second);
--edges[i].first, --edges[i].second;
gr[edges[i].first].push_back(edges[i].second);
gr[edges[i].second].push_back(edges[i].first);
}
for (int i = 0; i < n; ++i) {
deg.insert({gr[i].size(), i});
pw[i] = gr[i].size();
}
memset(used, true, N);
set<pair<int, int> > usedP;
for (int i = m - 1; i >= 0; --i) {
while (!deg.empty() && deg.begin()->first < k) {
pair<int, int> p = *deg.begin();
used[deg.begin()->second] = false;
deg.erase(deg.begin());
for (auto &x : gr[p.second]) {
if (used[x] &&
!(usedP.count({x, p.second}) || usedP.count({p.second, x}))) {
deg.erase({pw[x], x});
deg.insert({--pw[x], x});
}
}
}
ans[i] = deg.size();
if (!ans[i]) break;
if (used[edges[i].first] && used[edges[i].second]) {
deg.erase({pw[edges[i].first], edges[i].first});
deg.insert({--pw[edges[i].first], edges[i].first});
deg.erase({pw[edges[i].second], edges[i].second});
deg.insert({--pw[edges[i].second], edges[i].second});
usedP.insert({edges[i].first, edges[i].second});
}
}
for (auto &x : ans) printf("%d\n", x);
}
int main() {
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
struct pnt {
int hd;
int ind;
bool ded;
} p[1000000];
struct ent {
int twd;
int lst;
} e[1000000];
int cnt;
int n, m, k;
int lft;
int ans[1000000];
int u[1000000], v[1000000];
void ade(int f, int t) {
cnt++;
e[cnt].twd = t;
e[cnt].lst = p[f].hd;
p[f].hd = cnt;
p[f].ind++;
return;
}
void Delete(int x) {
if (p[x].ded) return;
p[x].ded = true;
lft--;
for (int i = p[x].hd; i; i = e[i].lst) {
int to = e[i].twd;
p[to].ind--;
if (p[to].ind < k) Delete(to);
}
return;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u[i], &v[i]);
ade(u[i], v[i]);
ade(v[i], u[i]);
}
lft = n;
for (int i = 1; i <= n; i++) {
if (p[i].ind < k) {
Delete(i);
}
}
for (int i = m; i; i--) {
ans[i] = lft;
p[u[i]].hd = e[p[u[i]].hd].lst;
p[v[i]].hd = e[p[v[i]].hd].lst;
if (!p[v[i]].ded) p[u[i]].ind--;
if (!p[u[i]].ded) p[v[i]].ind--;
if (p[v[i]].ind < k) Delete(v[i]);
if (p[u[i]].ind < k) Delete(u[i]);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int x[202020];
int y[202020];
set<int> v[202020];
int d[202020];
int z[202020];
vector<int> q;
int c;
vector<int> r;
int p[202020];
void lol() {
for (int i = 0; i < q.size(); i++) {
int x = q[i];
if (!z[x]) continue;
z[x] = 0;
c--;
for (auto y : v[x]) {
d[y]--;
if (d[y] < k) {
if (p[y]) continue;
p[y] = 1;
q.push_back(y);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) z[i] = 1;
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
v[x[i]].insert(y[i]);
d[x[i]]++;
v[y[i]].insert(x[i]);
d[y[i]]++;
}
c = n;
for (int i = 1; i <= n; i++) {
if (d[i] < k) q.push_back(i);
}
lol();
r.push_back(c);
for (int i = m; i >= 1; i--) {
q.clear();
if (z[x[i]] && z[y[i]]) {
v[x[i]].erase(y[i]);
v[y[i]].erase(x[i]);
d[x[i]]--;
d[y[i]]--;
if (d[x[i]] < k) q.push_back(x[i]);
if (d[y[i]] < k) q.push_back(y[i]);
lol();
}
if (i != 1) r.push_back(c);
}
reverse(r.begin(), r.end());
for (auto x : r) cout << x << "\n";
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int N, M, K;
int x[MAXN], y[MAXN];
unordered_set<int> adj[MAXN];
int ans[MAXN];
struct cmp {
bool operator()(const int &lhs, const int &rhs) const {
if (adj[lhs].size() != adj[rhs].size())
return adj[lhs].size() < adj[rhs].size();
return lhs < rhs;
}
};
set<int, cmp> in;
void load() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 0; i < M; i++) scanf("%d%d", x + i, y + i);
}
void reduce() {
if (in.empty()) return;
int x = *in.begin();
if (adj[x].size() >= K) return;
in.erase(x);
for (auto it : adj[x])
if (in.count(it)) {
in.erase(it);
adj[it].erase(x);
in.insert(it);
}
reduce();
}
void solve() {
for (int i = 0; i < M; i++) {
adj[x[i]].insert(y[i]);
adj[y[i]].insert(x[i]);
}
for (int i = 1; i <= N; i++) in.insert(i);
reduce();
for (int i = M - 1; i >= 0; i--) {
ans[i] = in.size();
if (in.count(x[i]) && in.count(y[i])) {
in.erase(x[i]);
in.erase(y[i]);
adj[x[i]].erase(y[i]);
adj[y[i]].erase(x[i]);
in.insert(x[i]);
in.insert(y[i]);
reduce();
}
}
for (int i = 0; i < M; i++) printf("%d\n", ans[i]);
}
int main() {
load();
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int ans[N];
int deg[N];
bool trip[N];
set<int> g[N];
int cnt, k;
void remove(int u) {
if (!trip[u]) return;
queue<int> q;
q.push(u);
trip[u] = false;
while (!q.empty()) {
u = q.front();
q.pop();
cnt--;
for (int v : g[u]) {
deg[v]--;
g[v].erase(u);
if (trip[v] and deg[v] < k) {
trip[v] = false;
q.push(v);
}
}
g[u].clear();
}
}
int main() {
int n, m;
scanf("%d %d %d", &n, &m, &k);
vector<pair<int, int> > e;
cnt = n;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
deg[x]++;
deg[y]++;
e.emplace_back(x, y);
g[x].insert(y);
g[y].insert(x);
}
for (int i = 1; i <= n; i++) trip[i] = true;
for (int i = 1; i <= n; i++) {
if (trip[i] and deg[i] < k) remove(i);
}
ans[m - 1] = cnt;
for (int i = m - 2; i >= 0; i--) {
int a = e[i + 1].first, b = e[i + 1].second;
if (!trip[a] or !trip[b]) {
ans[i] = cnt;
continue;
}
deg[a]--;
deg[b]--;
g[a].erase(b);
g[b].erase(a);
if (deg[a] < k) remove(a);
if (deg[b] < k) remove(b);
ans[i] = cnt;
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 2e5 + 5;
const int mod = 1e9 + 7;
vector<int> g[nmax];
int destroyed;
pair<int, int> ej[nmax];
int deg[nmax], ans[nmax];
bool vis[nmax];
map<pair<int, int>, int> mp;
void dhongsho(int u, int k, int p) {
if (vis[u]) return;
vis[u] = true;
destroyed++;
for (auto v : g[u]) {
if (v == p or vis[v]) continue;
if (mp[{u, v}] == 0) continue;
deg[v]--;
if (deg[v] < k) dhongsho(v, k, u);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, k, u, v;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
g[u].push_back(v), g[v].push_back(u);
ej[i] = {u, v};
mp[{u, v}] = mp[{v, u}] = 1;
deg[u]++, deg[v]++;
}
for (int u = 1; u <= n; u++) {
if (deg[u] < k) dhongsho(u, k, -1);
}
for (int i = m; i >= 1; i--) {
ans[i] = n - destroyed;
u = ej[i].first, v = ej[i].second;
if (!vis[u] and !vis[v]) {
deg[u]--, deg[v]--;
mp[{u, v}] = mp[{v, u}] = 0;
if (deg[u] < k) dhongsho(u, k, v);
if (deg[v] < k) dhongsho(v, k, u);
}
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int n, m, k;
cin >> n >> m >> k;
vector<pair<long long int, long long int> > edges(m);
set<long long int> adj[n];
for (int i = 0; i < m; ++i) {
long long int u, v;
cin >> u >> v;
u--;
v--;
adj[u].insert(v);
adj[v].insert(u);
edges[i].first = u;
edges[i].second = v;
}
set<pair<long long int, long long int> > myset;
set<pair<long long int, long long int> >::iterator it;
for (int i = 0; i < n; ++i) {
myset.insert({adj[i].size(), i});
}
set<long long int>::iterator itt;
vector<long long int> ans(m, 0);
for (int i = m - 1; i > -1; --i) {
while (!myset.empty() && myset.begin()->first < k) {
long long int ind = myset.begin()->second;
myset.erase(myset.begin());
for (auto v : adj[ind]) {
it = myset.find({adj[v].size(), v});
itt = adj[v].find(ind);
if (it != myset.end() && itt != adj[v].end()) {
myset.erase(it);
adj[v].erase(itt);
myset.insert({adj[v].size(), v});
}
}
}
ans[i] = myset.size();
long long int u = edges[i].first, v = edges[i].second;
it = myset.find({adj[u].size(), u});
itt = adj[u].find(v);
if (it != myset.end() && itt != adj[u].end()) {
myset.erase(it);
adj[u].erase(itt);
myset.insert({adj[u].size(), u});
}
it = myset.find({adj[v].size(), v});
itt = adj[v].find(u);
if (it != myset.end() && itt != adj[v].end()) {
myset.erase(it);
adj[v].erase(itt);
myset.insert({adj[v].size(), v});
}
}
for (int i = 0; i < m; ++i) {
cout << ans[i] << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<set<int> > g;
int n, m, k;
vector<pair<int, int> > q;
set<int> s;
void remove(int v) {
if (g[v].size() < k && s.erase(v)) {
for (auto to : g[v]) g[to].erase(v), remove(to);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
q.resize(m);
g.resize(n);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
x--, y--;
g[x].insert(y), g[y].insert(x);
q.push_back(make_pair(x, y));
}
for (int i = 0; i < n; ++i) s.insert(i);
for (int i = 0; i < n; ++i) remove(i);
vector<int> ans;
for (int i = 0; i < m; ++i) {
ans.push_back(s.size());
auto cur = q.back();
q.pop_back();
g[cur.first].erase(cur.second);
g[cur.second].erase(cur.first);
remove(cur.first);
remove(cur.second);
}
for (int i = 0; i < m; ++i) cout << ans[m - i - 1] << '\n';
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> p[maxn];
int vis[maxn];
int ans[maxn];
int num[maxn];
int v[maxn], w[maxn];
int now;
int n, m, k;
void dfs(int j, int v) {
ans[j]--;
for (int i = 0; i < p[v].size(); i++) {
num[p[v][i]]--;
if (vis[p[v][i]] == 1) {
if (num[p[v][i]] < k) {
vis[p[v][i]] = 0;
dfs(j, p[v][i]);
}
}
}
vis[v] = -1;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &v[i], &w[i]);
p[v[i]].push_back(w[i]);
p[w[i]].push_back(v[i]);
}
for (int i = 1; i <= n; i++) {
num[i] = p[i].size();
if (p[i].size() >= k) vis[i] = 1;
}
ans[m] = n;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) dfs(m, i);
}
for (int i = m; i >= 2; i--) {
p[v[i]].pop_back();
p[w[i]].pop_back();
if (vis[v[i]] == 1) num[w[i]]--;
if (vis[w[i]] == 1) num[v[i]]--;
ans[i - 1] = ans[i];
if (vis[w[i]] == 1 && num[w[i]] < k) {
vis[w[i]] = 0;
dfs(i - 1, w[i]);
}
if (vis[v[i]] == 1 && num[v[i]] < k) {
vis[v[i]] = 0;
dfs(i - 1, v[i]);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> G[N];
int n, m, k;
int qu[N], qv[N], vis[N], du[N], ans[N], res;
void dfs(int u) {
if (vis[u]) return;
if (du[u] < k) {
vis[u] = 1;
for (int v : G[u])
if (!vis[v]) du[v]--;
for (int v : G[u]) {
if (!vis[v]) {
dfs(v);
}
}
res--;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> qu[i] >> qv[i];
G[qu[i]].push_back(qv[i]);
G[qv[i]].push_back(qu[i]);
du[qu[i]]++;
du[qv[i]]++;
}
res = n;
for (int i = 1; i <= n; i++) {
dfs(i);
}
ans[m] = res;
for (int i = m; i >= 1; i--) {
if (!vis[qu[i]] && !vis[qv[i]]) {
if (du[qu[i]] - 1 < k) {
du[qu[i]]--;
dfs(qu[i]);
} else if (du[qv[i]] - 1 < k) {
du[qv[i]]--;
dfs(qv[i]);
} else {
du[qu[i]]--;
du[qv[i]]--;
}
}
G[qu[i]].pop_back();
G[qv[i]].pop_back();
ans[i - 1] = res;
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, k, sum;
int x[N], y[N];
vector<int> Edge[N];
int del[N], deg[N];
int ans[N];
inline 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 x * f;
}
queue<int> Q;
inline void Topsort(int Start) {
if (del[Start] || deg[Start] >= k) return;
while (!Q.empty()) Q.pop();
Q.push(Start);
del[Start] = 1, --sum;
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (vector<int>::iterator it = Edge[x].begin(); it != Edge[x].end();
++it) {
int v = *it;
if (del[v]) continue;
--deg[v];
if (deg[v] < k) del[v] = 1, --sum, Q.push(v);
}
}
}
int main() {
n = read(), m = read(), k = read();
for (int i = 1; i <= m; ++i) {
x[i] = read(), y[i] = read();
Edge[x[i]].push_back(y[i]), ++deg[x[i]];
Edge[y[i]].push_back(x[i]), ++deg[y[i]];
}
sum = n;
for (int i = 1; i <= n; ++i) Topsort(i);
ans[m] = sum;
for (int i = m; i >= 2; --i) {
Edge[x[i]].pop_back();
if (!del[y[i]]) --deg[x[i]];
Edge[y[i]].pop_back();
if (!del[x[i]]) --deg[y[i]];
Topsort(x[i]), Topsort(y[i]);
ans[i - 1] = sum;
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
set<int> s, G[N];
int n, m, k;
int U[N], V[N], ans[N];
void check(int u) {
if (G[u].size() < k && s.erase(u)) {
for (auto v : G[u]) {
G[v].erase(u);
check(v);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) s.insert(i);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &U[i], &V[i]);
G[U[i]].insert(V[i]);
G[V[i]].insert(U[i]);
}
for (int i = 1; i <= n; i++) check(i);
for (int i = m; i >= 1; --i) {
ans[i] = s.size();
G[U[i]].erase(V[i]);
G[V[i]].erase(U[i]);
check(U[i]);
check(V[i]);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
pair<int, int> edge[maxn];
int deg[maxn], ans[maxn];
bool del[maxn], vis[maxn];
set<pair<int, int> > dic;
vector<pair<int, int> > g[maxn];
int main() {
int n, m, k, u, v;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(pair<int, int>(v, i));
g[v].push_back(pair<int, int>(u, i));
deg[u]++, deg[v]++;
edge[i] = pair<int, int>(u, v);
}
for (int v = 1; v <= n; v++) dic.insert(pair<int, int>(deg[v], v));
while (!dic.empty() && dic.begin()->first < k) {
int v = dic.begin()->second;
dic.erase(dic.begin());
del[v] = true;
for (int i = 0; i < (int)g[v].size(); i++) {
int adj = g[v][i].first;
if (del[adj]) continue;
dic.erase(pair<int, int>(deg[adj], adj));
dic.insert(pair<int, int>(--deg[adj], adj));
}
}
for (int i = m - 1; i >= 0; i--) {
ans[i] = dic.size();
u = edge[i].first, v = edge[i].second;
if (!del[u] && !del[v] && !vis[i]) {
dic.erase(pair<int, int>(deg[u], u));
dic.insert(pair<int, int>(--deg[u], u));
dic.erase(pair<int, int>(deg[v], v));
dic.insert(pair<int, int>(--deg[v], v));
vis[i] = true;
}
while (!dic.empty() && dic.begin()->first < k) {
int v = dic.begin()->second;
dic.erase(dic.begin());
del[v] = true;
for (int i = 0; i < (int)g[v].size(); i++) {
int adj = g[v][i].first;
if (del[adj] || vis[g[v][i].second]) continue;
dic.erase(pair<int, int>(deg[adj], adj));
dic.insert(pair<int, int>(--deg[adj], adj));
vis[g[v][i].second] = true;
}
}
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
template <typename T>
inline T const &MAX(T const &a, T const &b) {
return a > b ? a : b;
}
template <typename T>
inline T const &MIN(T const &a, T const &b) {
return a < b ? a : b;
}
inline void add(long long &a, long long b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
inline void sub(long long &a, long long b) {
a -= b;
if (a < 0) a += 1000000007;
}
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long qp(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % 1000000007;
a = a * a % 1000000007, b >>= 1;
}
return ans;
}
inline long long qp(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % c;
a = a * a % c, b >>= 1;
}
return ans;
}
using namespace std;
const double eps = 1e-8;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 200000 + 10, maxn = 1000000 + 10, inf = 0x3f3f3f3f;
int ans[N], d[N];
bool vis[N];
vector<pair<int, int> > v[N];
set<pair<int, int> > s;
pair<int, int> p[N];
void gao(int x) {
auto y = s.lower_bound(make_pair(d[x], x));
if (y != s.end()) {
s.erase(y);
d[x]--;
s.insert(make_pair(d[x], x));
}
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(make_pair(b, i)), v[b].push_back(make_pair(a, i));
d[a]++, d[b]++;
p[i] = make_pair(a, b);
}
for (int i = 1; i <= n; i++) s.insert(make_pair(d[i], i));
for (int i = m; i >= 1; i--) {
while (s.size() > 0 && (s.begin())->first < k) {
int te = s.begin()->second;
s.erase(s.begin());
for (int i = 0; i < v[te].size(); i++) {
if (vis[v[te][i].second]) continue;
gao(v[te][i].first);
vis[v[te][i].second] = 1;
}
}
ans[i] = s.size();
if (vis[i] == 1) continue;
gao(p[i].first), gao(p[i].second);
vis[i] = 1;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 11 | CPP |
Subsets and Splits