Search is not available for this dataset
name
stringlengths 2
88
| description
stringlengths 31
8.62k
| public_tests
dict | private_tests
dict | solution_type
stringclasses 2
values | programming_language
stringclasses 5
values | solution
stringlengths 1
983k
|
|---|---|---|---|---|---|---|
1012_E. Cycle sort | You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | {
"input": [
"5 5\n3 2 3 1 1\n",
"4 3\n2 1 4 3\n",
"2 0\n2 2\n"
],
"output": [
"1\n5\n1 4 2 3 5 \n",
"-1\n",
"0\n"
]
} | {
"input": [
"5 0\n884430748 884430748 708433020 708433020 708433020\n",
"2 1\n1 1\n",
"2 0\n2 1\n",
"5 2\n65390026 770505072 65390026 65390026 65390026\n",
"5 4\n812067558 674124159 106041640 106041640 674124159\n",
"5 4\n167616600 574805150 651016425 150949603 379708534\n",
"5 5\n472778319 561757623 989296065 99763286 352037329\n",
"5 4\n201429826 845081337 219611799 598937628 680006294\n",
"2 2\n2 1\n",
"5 0\n1000000000 1000000000 1000000000 1000000000 1000000000\n",
"5 6\n971458729 608568364 891718769 464295315 98863653\n",
"5 5\n641494999 641494999 228574099 535883079 535883079\n",
"5 5\n815605413 4894095 624809427 264202135 152952491\n",
"1 0\n258769137\n",
"2 0\n1 1\n",
"1 0\n2\n",
"5 4\n335381650 691981363 691981363 335381650 335381650\n",
"5 4\n81224924 319704343 319704343 210445208 128525140\n",
"5 4\n579487081 564229995 665920667 665920667 644707366\n",
"5 200000\n682659092 302185582 518778252 29821187 14969298\n"
],
"output": [
"-1\n",
"0\n",
"-1\n",
"1\n2\n2 5 \n",
"-1\n",
"-1\n",
"1\n5\n1 3 5 2 4 \n",
"1\n4\n2 5 4 3 \n",
"1\n2\n1 2 \n",
"0\n",
"2\n2\n1 5\n3\n2 3 4\n",
"1\n5\n1 4 2 5 3 \n",
"2\n3\n1 5 2\n2\n3 4\n",
"0\n",
"0\n",
"0\n",
"1\n4\n2 4 3 5 \n",
"1\n4\n2 4 3 5 \n",
"2\n2\n1 2\n2\n3 5\n",
"2\n2\n1 5\n3\n2 3 4\n"
]
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
const int NN = 200011;
int a[NN], b[NN], arr[NN];
VI vec[NN], cyc[NN];
int nc;
int dp[NN], vst[NN];
int n, s;
void dfs(int u) {
if (vec[u].empty()) return;
int v = vec[u].back();
vec[u].pop_back();
dfs(a[v]);
cyc[nc].push_back(v);
}
int solve() {
cin >> n >> s;
for (int i = 1; i <= n; i++) scanf("%d", a + i), arr[i] = a[i], dp[i] = i;
sort(arr + 1, arr + n + 1);
int m = unique(arr + 1, arr + n + 1) - arr - 1;
for (int i = 1; i <= n; i++) {
b[i] = a[i] = lower_bound(arr + 1, arr + m + 1, a[i]) - arr;
}
sort(b + 1, b + n + 1);
for (int i = 1; i <= n; i++)
if (a[i] ^ b[i]) {
vec[b[i]].push_back(i);
}
for (int i = 1; i <= m; i++) {
if (not vec[i].empty()) {
dfs(i);
int r = ((int)cyc[nc].size());
for (int j = 0; j < r; j++) {
dp[cyc[nc][(j + 1) % r]] = cyc[nc][j];
s--;
}
nc++;
}
if (s < 0) return puts("-1");
}
s = min(s, nc);
if (s >= 2) {
cout << nc - s + 2 << endl;
cout << s << endl;
for (int i = 0; i < s; i++) printf("%d ", cyc[i][0]);
puts("");
int tmp = dp[cyc[s - 1][0]];
for (int i = s; --i;) {
dp[cyc[i][0]] = dp[cyc[i - 1][0]];
}
dp[cyc[0][0]] = tmp;
} else
cout << nc << endl;
for (int i = 1; i <= n; i++) {
if (dp[i] == i or vst[i]) continue;
VI ans;
for (int u = i; not vst[u];) {
ans.push_back(u);
vst[u] = 1;
u = dp[u];
}
printf("%d\n", ans.size());
for (int u : ans) printf("%d ", u);
puts("");
}
}
int main() { solve(); }
|
1012_E. Cycle sort | You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | {
"input": [
"5 5\n3 2 3 1 1\n",
"4 3\n2 1 4 3\n",
"2 0\n2 2\n"
],
"output": [
"1\n5\n1 4 2 3 5 \n",
"-1\n",
"0\n"
]
} | {
"input": [
"5 0\n884430748 884430748 708433020 708433020 708433020\n",
"2 1\n1 1\n",
"2 0\n2 1\n",
"5 2\n65390026 770505072 65390026 65390026 65390026\n",
"5 4\n812067558 674124159 106041640 106041640 674124159\n",
"5 4\n167616600 574805150 651016425 150949603 379708534\n",
"5 5\n472778319 561757623 989296065 99763286 352037329\n",
"5 4\n201429826 845081337 219611799 598937628 680006294\n",
"2 2\n2 1\n",
"5 0\n1000000000 1000000000 1000000000 1000000000 1000000000\n",
"5 6\n971458729 608568364 891718769 464295315 98863653\n",
"5 5\n641494999 641494999 228574099 535883079 535883079\n",
"5 5\n815605413 4894095 624809427 264202135 152952491\n",
"1 0\n258769137\n",
"2 0\n1 1\n",
"1 0\n2\n",
"5 4\n335381650 691981363 691981363 335381650 335381650\n",
"5 4\n81224924 319704343 319704343 210445208 128525140\n",
"5 4\n579487081 564229995 665920667 665920667 644707366\n",
"5 200000\n682659092 302185582 518778252 29821187 14969298\n"
],
"output": [
"-1\n",
"0\n",
"-1\n",
"1\n2\n2 5 \n",
"-1\n",
"-1\n",
"1\n5\n1 3 5 2 4 \n",
"1\n4\n2 5 4 3 \n",
"1\n2\n1 2 \n",
"0\n",
"2\n2\n1 5\n3\n2 3 4\n",
"1\n5\n1 4 2 5 3 \n",
"2\n3\n1 5 2\n2\n3 4\n",
"0\n",
"0\n",
"0\n",
"1\n4\n2 4 3 5 \n",
"1\n4\n2 4 3 5 \n",
"2\n2\n1 2\n2\n3 5\n",
"2\n2\n1 5\n3\n2 3 4\n"
]
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void ckmin(T &a, U b) {
if (a > b) a = b;
}
template <class T, class U>
void ckmax(T &a, U b) {
if (a < b) a = b;
}
const int MAXN = 400013;
int N, S, M, ans, n;
int val[MAXN], arr[MAXN], sorted[MAXN];
vector<int> moves[MAXN];
vector<int> cyc[MAXN];
bitset<MAXN> vis;
vector<int> compress;
int freq[MAXN];
pair<int, int> range[MAXN];
vector<int> edge[MAXN];
vector<int> tour;
int indexof(vector<int> &v, int x) {
return upper_bound((v).begin(), (v).end(), x) - v.begin() - 1;
}
void dfs(int u) {
vis[u] = true;
if (!edge[u].empty()) {
int v = edge[u].back();
if (edge[v].empty()) {
swap(edge[u][0], edge[u][((int)(edge[u]).size()) - 1]);
v = edge[u].back();
}
edge[u].pop_back();
dfs(v);
}
tour.push_back(u);
}
void solve() {
int k = min(M, S - n);
if (k <= 2) {
ans = M;
for (auto i = (0); i < (M); i++) {
moves[i] = cyc[i];
}
} else {
ans = M - k + 2;
for (auto i = (0); i < (M - k); i++) {
moves[i] = cyc[i];
}
for (auto i = (M - k); i < (M); i++) {
moves[M - k].insert(moves[M - k].end(), (cyc[i]).begin(), (cyc[i]).end());
moves[M - k + 1].push_back(cyc[i][0]);
}
reverse((moves[M - k + 1]).begin(), (moves[M - k + 1]).end());
}
}
int32_t main() {
cout << fixed << setprecision(12);
cerr << fixed << setprecision(4);
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N >> S;
for (auto i = (0); i < (N); i++) {
cin >> val[i];
compress.push_back(val[i]);
}
sort((compress).begin(), (compress).end());
compress.erase(unique((compress).begin(), (compress).end()), compress.end());
for (auto i = (0); i < (N); i++) {
val[i] = indexof(compress, val[i]);
sorted[i] = val[i];
}
sort(sorted, sorted + N);
for (auto i = (0); i < (N); i++) {
if (val[i] == sorted[i]) {
vis[i] = true;
arr[i] = i;
continue;
}
edge[i].push_back(val[i] + N);
edge[sorted[i] + N].push_back(i);
}
for (auto i = (0); i < (N); i++) {
if (vis[i]) continue;
tour.clear();
dfs(i);
reverse((tour).begin(), (tour).end());
for (int j = 0; j + 2 < ((int)(tour).size()); j += 2) {
int u = tour[j];
int v = tour[j + 2];
arr[u] = v;
}
tour.clear();
}
vis.reset();
for (auto i = (0); i < (N); i++) {
if (vis[i]) continue;
if (arr[i] == i) {
continue;
}
cyc[M].push_back(i);
do {
vis[cyc[M].back()] = true;
cyc[M].push_back(arr[cyc[M].back()]);
} while (cyc[M].back() != i);
cyc[M].pop_back();
M++;
}
for (auto i = (0); i < (M); i++) {
n += ((int)(cyc[i]).size());
}
if (S < n) {
cout << "-1\n";
return 0;
}
solve();
assert(ans == min(M, max(2, 2 + M - S + n)));
cout << ans << '\n';
for (auto i = (0); i < (ans); i++) {
cout << ((int)(moves[i]).size()) << '\n';
for (int x : moves[i]) {
cout << x + 1 << " \n"[x == moves[i].back()];
}
}
}
|
1012_E. Cycle sort | You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | {
"input": [
"5 5\n3 2 3 1 1\n",
"4 3\n2 1 4 3\n",
"2 0\n2 2\n"
],
"output": [
"1\n5\n1 4 2 3 5 \n",
"-1\n",
"0\n"
]
} | {
"input": [
"5 0\n884430748 884430748 708433020 708433020 708433020\n",
"2 1\n1 1\n",
"2 0\n2 1\n",
"5 2\n65390026 770505072 65390026 65390026 65390026\n",
"5 4\n812067558 674124159 106041640 106041640 674124159\n",
"5 4\n167616600 574805150 651016425 150949603 379708534\n",
"5 5\n472778319 561757623 989296065 99763286 352037329\n",
"5 4\n201429826 845081337 219611799 598937628 680006294\n",
"2 2\n2 1\n",
"5 0\n1000000000 1000000000 1000000000 1000000000 1000000000\n",
"5 6\n971458729 608568364 891718769 464295315 98863653\n",
"5 5\n641494999 641494999 228574099 535883079 535883079\n",
"5 5\n815605413 4894095 624809427 264202135 152952491\n",
"1 0\n258769137\n",
"2 0\n1 1\n",
"1 0\n2\n",
"5 4\n335381650 691981363 691981363 335381650 335381650\n",
"5 4\n81224924 319704343 319704343 210445208 128525140\n",
"5 4\n579487081 564229995 665920667 665920667 644707366\n",
"5 200000\n682659092 302185582 518778252 29821187 14969298\n"
],
"output": [
"-1\n",
"0\n",
"-1\n",
"1\n2\n2 5 \n",
"-1\n",
"-1\n",
"1\n5\n1 3 5 2 4 \n",
"1\n4\n2 5 4 3 \n",
"1\n2\n1 2 \n",
"0\n",
"2\n2\n1 5\n3\n2 3 4\n",
"1\n5\n1 4 2 5 3 \n",
"2\n3\n1 5 2\n2\n3 4\n",
"0\n",
"0\n",
"0\n",
"1\n4\n2 4 3 5 \n",
"1\n4\n2 4 3 5 \n",
"2\n2\n1 2\n2\n3 5\n",
"2\n2\n1 5\n3\n2 3 4\n"
]
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <typename T>
vector<T>& operator--(vector<T>& v) {
for (auto& i : v) --i;
return v;
}
template <typename T>
vector<T>& operator++(vector<T>& v) {
for (auto& i : v) ++i;
return v;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& i : v) is >> i;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (auto& i : v) os << i << ' ';
return os;
}
template <typename T, typename U>
pair<T, U>& operator--(pair<T, U>& p) {
--p.first;
--p.second;
return p;
}
template <typename T, typename U>
pair<T, U>& operator++(pair<T, U>& p) {
++p.first;
++p.second;
return p;
}
template <typename T, typename U>
istream& operator>>(istream& is, pair<T, U>& p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, pair<T, U>& p) {
os << p.first << ' ' << p.second;
return os;
}
template <typename T, typename U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return make_pair(a.first - b.first, a.second - b.second);
}
template <typename T, typename U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return make_pair(a.first + b.first, a.second + b.second);
}
template <typename T, typename U>
void umin(T& a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
void umax(T& a, U b) {
if (a < b) a = b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, s;
cin >> n >> s;
vector<int> a(n);
cin >> a;
auto b = a;
sort(b.begin(), b.end());
map<int, deque<int>> where;
for (int i = 0; i < n; ++i) {
if (a[i] != b[i]) {
where[a[i]].push_back(i);
}
}
42;
42;
42;
int tot = 0;
vector<vector<int>> ans;
auto x = a;
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
vector<vector<int>> g(x.size());
vector<pair<int, int>> e;
for (int i = 0; i < a.size(); ++i) {
if (a[i] != b[i]) {
e.emplace_back(
(lower_bound((x).begin(), (x).end(), (a[i])) - (x).begin()),
(lower_bound((x).begin(), (x).end(), (b[i])) - (x).begin()));
g[e.back().first].push_back(e.back().second);
}
}
vector<bool> u(x.size(), false);
vector<int> ind(g.size(), 0);
for (int i = 0; i < x.size(); ++i) {
if (!u[i] && !g[i].empty()) {
vector<int> path;
function<void(int)> go = [&](int v) {
u[v] = true;
while (ind[v] < g[v].size()) {
int i = ind[v];
++ind[v];
go(g[v][i]);
}
path.push_back(v);
};
go(i);
vector<int> cyc;
path.pop_back();
for (int k : path) {
cyc.push_back(where[x[k]][0] + 1);
where[x[k]].pop_front();
}
42;
ans.push_back(cyc);
tot += cyc.size();
}
}
if (tot > s) {
cout << -1 << '\n';
return 0;
}
cout << ans.size() << '\n';
for (auto v : ans) {
cout << v.size() << '\n';
cout << v << '\n';
}
return 0;
}
|
1012_E. Cycle sort | You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | {
"input": [
"5 5\n3 2 3 1 1\n",
"4 3\n2 1 4 3\n",
"2 0\n2 2\n"
],
"output": [
"1\n5\n1 4 2 3 5 \n",
"-1\n",
"0\n"
]
} | {
"input": [
"5 0\n884430748 884430748 708433020 708433020 708433020\n",
"2 1\n1 1\n",
"2 0\n2 1\n",
"5 2\n65390026 770505072 65390026 65390026 65390026\n",
"5 4\n812067558 674124159 106041640 106041640 674124159\n",
"5 4\n167616600 574805150 651016425 150949603 379708534\n",
"5 5\n472778319 561757623 989296065 99763286 352037329\n",
"5 4\n201429826 845081337 219611799 598937628 680006294\n",
"2 2\n2 1\n",
"5 0\n1000000000 1000000000 1000000000 1000000000 1000000000\n",
"5 6\n971458729 608568364 891718769 464295315 98863653\n",
"5 5\n641494999 641494999 228574099 535883079 535883079\n",
"5 5\n815605413 4894095 624809427 264202135 152952491\n",
"1 0\n258769137\n",
"2 0\n1 1\n",
"1 0\n2\n",
"5 4\n335381650 691981363 691981363 335381650 335381650\n",
"5 4\n81224924 319704343 319704343 210445208 128525140\n",
"5 4\n579487081 564229995 665920667 665920667 644707366\n",
"5 200000\n682659092 302185582 518778252 29821187 14969298\n"
],
"output": [
"-1\n",
"0\n",
"-1\n",
"1\n2\n2 5 \n",
"-1\n",
"-1\n",
"1\n5\n1 3 5 2 4 \n",
"1\n4\n2 5 4 3 \n",
"1\n2\n1 2 \n",
"0\n",
"2\n2\n1 5\n3\n2 3 4\n",
"1\n5\n1 4 2 5 3 \n",
"2\n3\n1 5 2\n2\n3 4\n",
"0\n",
"0\n",
"0\n",
"1\n4\n2 4 3 5 \n",
"1\n4\n2 4 3 5 \n",
"2\n2\n1 2\n2\n3 5\n",
"2\n2\n1 5\n3\n2 3 4\n"
]
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
int n, limit;
int nxt[N], lab[N], flag[N];
pair<int, int> a[N];
vector<int> ans1, ans2;
vector<vector<int> > ans3;
vector<pair<int, int> > v;
int root(int u) {
if (lab[u] < 0) return u;
return lab[u] = root(lab[u]);
}
void join(int u, int v) {
int l1 = root(u), l2 = root(v);
if (l1 == l2) return;
if (lab[l1] > lab[l2]) swap(l1, l2);
lab[l1] += lab[l2];
lab[l2] = l1;
}
void show(vector<int> &s) {
cout << s.size() << '\n';
for (auto &x : s) cout << x << ' ';
cout << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> limit;
memset(lab, -1, sizeof lab);
for (int i = 1; i <= n; ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) {
int j1 = i, j2 = i;
while (j2 < n && a[j2 + 1].first == a[j2].first) j2++;
for (; i <= j2; ++i) {
while (j1 <= a[i].second && a[i].second <= j2 && a[i].second != i)
swap(a[i], a[a[i].second]);
}
i = j2;
}
for (int i = 1; i <= n; ++i)
if (a[i].second != i) {
nxt[a[i].second] = i;
join(a[i].second, i);
v.push_back(a[i]);
}
for (int i = 0; i < v.size(); ++i) {
while (i + 1 < v.size() && v[i + 1].first == v[i].first) {
i++;
int idx1 = v[i].second, idx2 = v[i - 1].second;
if (root(idx1) == root(idx2)) continue;
join(idx1, idx2);
swap(nxt[idx1], nxt[idx2]);
}
}
int sum = 0, tmp = 0;
for (int i = 1; i <= n; ++i)
if (a[i].second != i && !flag[root(a[i].second)]) {
flag[root(a[i].second)] = true;
tmp++;
sum += abs(lab[root(a[i].second)]);
}
if (limit == 199950) cout << tmp << ' ' << sum - limit << '\n';
if (limit < sum) {
cout << -1;
return 0;
}
int addmx = sum - limit;
int cnt = 0;
memset(flag, 0, sizeof flag);
for (int i = 1; i <= n; ++i)
if (a[i].second != i && !flag[root(a[i].second)]) {
flag[root(a[i].second)] = true;
cnt++;
if (cnt <= addmx) {
ans2.push_back(a[i].second);
int cur = a[i].second;
do {
ans1.push_back(cur);
cur = nxt[cur];
} while (cur != a[i].second);
} else {
vector<int> cycle;
int cur = a[i].second;
do {
cycle.push_back(cur);
cur = nxt[cur];
} while (cur != a[i].second);
ans3.push_back(cycle);
}
}
if (ans1.size()) ans3.push_back(ans1);
reverse(ans2.begin(), ans2.end());
if (ans2.size() > 1) ans3.push_back(ans2);
cout << ans3.size() << '\n';
for (auto &s : ans3) show(s);
return 0;
}
|
1012_E. Cycle sort | You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | {
"input": [
"5 5\n3 2 3 1 1\n",
"4 3\n2 1 4 3\n",
"2 0\n2 2\n"
],
"output": [
"1\n5\n1 4 2 3 5 \n",
"-1\n",
"0\n"
]
} | {
"input": [
"5 0\n884430748 884430748 708433020 708433020 708433020\n",
"2 1\n1 1\n",
"2 0\n2 1\n",
"5 2\n65390026 770505072 65390026 65390026 65390026\n",
"5 4\n812067558 674124159 106041640 106041640 674124159\n",
"5 4\n167616600 574805150 651016425 150949603 379708534\n",
"5 5\n472778319 561757623 989296065 99763286 352037329\n",
"5 4\n201429826 845081337 219611799 598937628 680006294\n",
"2 2\n2 1\n",
"5 0\n1000000000 1000000000 1000000000 1000000000 1000000000\n",
"5 6\n971458729 608568364 891718769 464295315 98863653\n",
"5 5\n641494999 641494999 228574099 535883079 535883079\n",
"5 5\n815605413 4894095 624809427 264202135 152952491\n",
"1 0\n258769137\n",
"2 0\n1 1\n",
"1 0\n2\n",
"5 4\n335381650 691981363 691981363 335381650 335381650\n",
"5 4\n81224924 319704343 319704343 210445208 128525140\n",
"5 4\n579487081 564229995 665920667 665920667 644707366\n",
"5 200000\n682659092 302185582 518778252 29821187 14969298\n"
],
"output": [
"-1\n",
"0\n",
"-1\n",
"1\n2\n2 5 \n",
"-1\n",
"-1\n",
"1\n5\n1 3 5 2 4 \n",
"1\n4\n2 5 4 3 \n",
"1\n2\n1 2 \n",
"0\n",
"2\n2\n1 5\n3\n2 3 4\n",
"1\n5\n1 4 2 5 3 \n",
"2\n3\n1 5 2\n2\n3 4\n",
"0\n",
"0\n",
"0\n",
"1\n4\n2 4 3 5 \n",
"1\n4\n2 4 3 5 \n",
"2\n2\n1 2\n2\n3 5\n",
"2\n2\n1 5\n3\n2 3 4\n"
]
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, k, tot, x, ans, a[1000000], b[1000000], f[1000000], ed[1000000],
nt[1000000], nm[1000000], ss[1000000];
map<int, int> mp, rw;
bool v[1000000];
int gf(int x) {
if (f[x] == x) return x;
f[x] = gf(f[x]);
return f[x];
}
int main() {
scanf("%d %d", &n, &k);
for (int i = (1); i <= (n); i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
sort(b + 1, b + n + 1);
for (int i = (1); i <= (n); i++)
if (b[i] != b[i - 1]) mp[b[i]] = i;
for (int i = (1); i <= (n); i++)
if (a[i] != b[i])
k--;
else
v[i] = 1;
for (int i = (1); i <= (n); i++)
for (; v[mp[b[i]]]; mp[b[i]]++) {
if (b[mp[b[i]]] != b[i]) {
mp[b[i]] = 0;
break;
}
}
if (k < 0) {
printf("-1");
return 0;
}
for (int i = (1); i <= (n); i++)
if (!v[i]) {
tot++;
for (x = i; x; x = mp[a[x]]) {
for (mp[b[x]]++; v[mp[b[x]]]; mp[b[x]]++) {
if (b[mp[b[x]]] != b[x]) {
mp[b[x]] = 0;
break;
}
}
if (b[mp[b[x]]] != b[x]) mp[b[x]] = 0;
v[x] = 1;
if (ed[tot]) {
nt[ed[tot]] = x;
f[x] = f[ed[tot]];
} else
f[x] = x;
ed[tot] = x;
nm[f[x]]++;
}
nt[ed[tot]] = f[ed[tot]];
}
for (int i = (1); i <= (n); i++)
if ((a[i] != b[i]) && (b[nt[i]] != a[i])) printf("%d!", i);
for (int i = (1); i <= (n); i++)
if (a[i] != b[i]) {
if (rw[b[i]]) {
if (gf(i) != gf(rw[b[i]])) {
nm[f[rw[b[i]]]] += nm[f[i]];
f[f[i]] = f[rw[b[i]]];
nt[i] ^= nt[rw[b[i]]];
nt[rw[b[i]]] ^= nt[i];
nt[i] ^= nt[rw[b[i]]];
}
} else
rw[b[i]] = i;
}
tot = 0;
for (int i = (1); i <= (n); i++)
if ((a[i] != b[i]) && (b[nt[i]] != a[i])) printf("%d!!", i);
for (int i = (1); i <= (n); i++)
if ((a[i] != b[i]) && (gf(i) == i)) ss[++tot] = i;
if ((tot > 2) && (k > 2)) {
ans = tot - ((tot) < (k) ? (tot) : (k)) + 1;
x = nt[ss[ans]];
for (int i = (ans + 1); i <= (tot); i++) {
nt[ss[i - 1]] = nt[ss[i]];
nm[ss[ans]] += nm[ss[i]];
}
nt[ss[tot]] = x;
} else
ans = tot;
if (ans < tot)
printf("%d\n", ans + 1);
else
printf("%d\n", ans);
for (int i = (1); i <= (ans); i++) {
printf("%d\n", nm[ss[i]]);
for (x = ss[i]; nt[x] != ss[i]; x = nt[x]) printf("%d ", x);
printf("%d\n", x);
}
if (ans < tot) {
printf("%d\n", tot - ans + 1);
for (int i = (tot); i >= (ans); i--) printf("%d ", nt[ss[i]]);
}
}
|
1012_E. Cycle sort | You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | {
"input": [
"5 5\n3 2 3 1 1\n",
"4 3\n2 1 4 3\n",
"2 0\n2 2\n"
],
"output": [
"1\n5\n1 4 2 3 5 \n",
"-1\n",
"0\n"
]
} | {
"input": [
"5 0\n884430748 884430748 708433020 708433020 708433020\n",
"2 1\n1 1\n",
"2 0\n2 1\n",
"5 2\n65390026 770505072 65390026 65390026 65390026\n",
"5 4\n812067558 674124159 106041640 106041640 674124159\n",
"5 4\n167616600 574805150 651016425 150949603 379708534\n",
"5 5\n472778319 561757623 989296065 99763286 352037329\n",
"5 4\n201429826 845081337 219611799 598937628 680006294\n",
"2 2\n2 1\n",
"5 0\n1000000000 1000000000 1000000000 1000000000 1000000000\n",
"5 6\n971458729 608568364 891718769 464295315 98863653\n",
"5 5\n641494999 641494999 228574099 535883079 535883079\n",
"5 5\n815605413 4894095 624809427 264202135 152952491\n",
"1 0\n258769137\n",
"2 0\n1 1\n",
"1 0\n2\n",
"5 4\n335381650 691981363 691981363 335381650 335381650\n",
"5 4\n81224924 319704343 319704343 210445208 128525140\n",
"5 4\n579487081 564229995 665920667 665920667 644707366\n",
"5 200000\n682659092 302185582 518778252 29821187 14969298\n"
],
"output": [
"-1\n",
"0\n",
"-1\n",
"1\n2\n2 5 \n",
"-1\n",
"-1\n",
"1\n5\n1 3 5 2 4 \n",
"1\n4\n2 5 4 3 \n",
"1\n2\n1 2 \n",
"0\n",
"2\n2\n1 5\n3\n2 3 4\n",
"1\n5\n1 4 2 5 3 \n",
"2\n3\n1 5 2\n2\n3 4\n",
"0\n",
"0\n",
"0\n",
"1\n4\n2 4 3 5 \n",
"1\n4\n2 4 3 5 \n",
"2\n2\n1 2\n2\n3 5\n",
"2\n2\n1 5\n3\n2 3 4\n"
]
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
int a[N], p[N], head[N], now = 0;
pair<int, int> b[N];
vector<int> cycle[N];
int findd(int x) {
if (head[x] < 0) {
return x;
}
int y = findd(head[x]);
head[x] = y;
return y;
}
void unionn(int x, int y) {
x = findd(x), y = findd(y);
head[x] += head[y];
head[y] = x;
}
bool samee(int x, int y) { return findd(x) == findd(y); }
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, i, j, k, l, s, sz = 0;
cin >> n >> s;
for (i = 1; i <= n; i++) {
head[i] = -1;
cin >> a[i];
b[i] = {a[i], i};
}
sort(b + 1, b + 1 + n);
i = j = 1;
while (i <= n) {
while (j <= n && b[i].first == b[j].first) {
j++;
}
now++;
while (i < j) {
a[b[i].second] = b[i].first = now;
i++;
}
}
for (i = 1; i <= n; i++) {
if (a[i] != b[i].first) {
sz++;
head[i] = -1;
b[sz] = {a[i], i};
a[sz] = i;
}
}
if (sz == 0) {
cout << 0;
return 0;
}
if (sz > s) {
cout << -1;
return 0;
}
sort(b + 1, b + 1 + sz);
sort(a + 1, a + 1 + sz);
for (i = 1; i <= sz; i++) {
p[b[i].second] = a[i];
if (!samee(b[i].second, a[i])) {
unionn(b[i].second, a[i]);
}
}
i = j = 1;
while (i <= sz) {
while (j <= sz && b[i].first == b[j].first) {
j++;
}
for (k = i + 1; k < j; k++) {
if (!samee(b[i].second, b[k].second)) {
swap(p[b[i].second], p[b[k].second]);
unionn(b[i].second, b[k].second);
}
}
i = j;
}
int cnt = 0;
for (i = 1; i <= n; i++) {
if (p[i]) {
cycle[cnt].push_back(i);
j = p[i];
while (j != i) {
cycle[cnt].push_back(j);
j = p[j];
}
for (k = 0; k < cycle[cnt].size(); k++) {
p[cycle[cnt][k]] = 0;
}
cnt++;
}
}
if (cnt <= 1 || s == sz + 1 || s == sz) {
cout << cnt << '\n';
for (i = 0; i < cnt; i++) {
cout << cycle[i].size() << '\n';
for (j = 0; j < cycle[i].size(); j++) {
cout << cycle[i][j] << ' ';
}
cout << '\n';
}
} else {
cout << cnt - min(cnt, s - sz) + 2 << '\n';
j = min(s - sz, cnt);
for (i = j; i < cnt; i++) {
cout << cycle[i].size() << '\n';
for (j = 0; j < cycle[i].size(); j++) {
cout << cycle[i][j] << ' ';
}
cout << '\n';
}
cout << j << '\n';
k = 0;
for (i = 0; i < j; i++) {
k += cycle[i].size();
cout << cycle[i][0] << ' ';
}
cout << '\n';
cout << k << '\n';
for (i = j - 1; i > -1; i--) {
for (l = 1; l < cycle[i].size(); l++) {
cout << cycle[i][l] << ' ';
}
cout << cycle[i][0] << ' ';
}
}
}
|
1012_E. Cycle sort | You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | {
"input": [
"5 5\n3 2 3 1 1\n",
"4 3\n2 1 4 3\n",
"2 0\n2 2\n"
],
"output": [
"1\n5\n1 4 2 3 5 \n",
"-1\n",
"0\n"
]
} | {
"input": [
"5 0\n884430748 884430748 708433020 708433020 708433020\n",
"2 1\n1 1\n",
"2 0\n2 1\n",
"5 2\n65390026 770505072 65390026 65390026 65390026\n",
"5 4\n812067558 674124159 106041640 106041640 674124159\n",
"5 4\n167616600 574805150 651016425 150949603 379708534\n",
"5 5\n472778319 561757623 989296065 99763286 352037329\n",
"5 4\n201429826 845081337 219611799 598937628 680006294\n",
"2 2\n2 1\n",
"5 0\n1000000000 1000000000 1000000000 1000000000 1000000000\n",
"5 6\n971458729 608568364 891718769 464295315 98863653\n",
"5 5\n641494999 641494999 228574099 535883079 535883079\n",
"5 5\n815605413 4894095 624809427 264202135 152952491\n",
"1 0\n258769137\n",
"2 0\n1 1\n",
"1 0\n2\n",
"5 4\n335381650 691981363 691981363 335381650 335381650\n",
"5 4\n81224924 319704343 319704343 210445208 128525140\n",
"5 4\n579487081 564229995 665920667 665920667 644707366\n",
"5 200000\n682659092 302185582 518778252 29821187 14969298\n"
],
"output": [
"-1\n",
"0\n",
"-1\n",
"1\n2\n2 5 \n",
"-1\n",
"-1\n",
"1\n5\n1 3 5 2 4 \n",
"1\n4\n2 5 4 3 \n",
"1\n2\n1 2 \n",
"0\n",
"2\n2\n1 5\n3\n2 3 4\n",
"1\n5\n1 4 2 5 3 \n",
"2\n3\n1 5 2\n2\n3 4\n",
"0\n",
"0\n",
"0\n",
"1\n4\n2 4 3 5 \n",
"1\n4\n2 4 3 5 \n",
"2\n2\n1 2\n2\n3 5\n",
"2\n2\n1 5\n3\n2 3 4\n"
]
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
struct ln {
int val;
ln* next;
};
vector<pair<int, int> >* nl;
vector<pair<int, int> > ar;
int* roi;
bool* btdt;
ln* fe(ln* ath, int cp) {
ln* sv = NULL;
for (int i = roi[cp]; i < nl[cp].size(); i = roi[cp]) {
int np = nl[cp][i].first;
int ind = nl[cp][i].second;
if (btdt[ind]) {
continue;
}
roi[cp]++;
btdt[ind] = 1;
ln* cn = new ln();
cn->val = ind;
cn->next = NULL;
ln* vas = fe(cn, np);
if (ar[vas->val].first != cp) {
sv = cn;
continue;
}
ath->next = cn;
ath = vas;
}
if (sv != NULL) {
ath->next = sv;
ath = sv;
}
return ath;
}
int main() {
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
int n, s;
cin >> n >> s;
int S = s;
nl = new vector<pair<int, int> >[n];
btdt = new bool[n];
roi = new int[n];
for (int i = 0; i < n; i++) {
roi[i] = 0;
vector<pair<int, int> > vpii;
nl[i] = vpii;
btdt[i] = 0;
int a;
cin >> a;
ar.push_back(make_pair(a, i));
}
vector<pair<int, int> > br = ar;
sort(br.begin(), br.end());
unordered_map<int, int> nct;
int cn = -1;
int an = -1;
for (int i = 0; i < n; i++) {
if (br[i].first != an) {
cn++;
an = br[i].first;
nct[an] = cn;
}
br[i].first = cn;
}
for (int i = 0; i < n; i++) {
ar[i].first = nct[ar[i].first];
}
for (int i = 0; i < n; i++) {
if (br[i].first == ar[i].first) {
continue;
}
s--;
nl[br[i].first].push_back(make_pair(ar[i].first, ar[i].second));
}
if (s < 0) {
cout << -1 << "\n";
return 0;
}
vector<ln*> atc;
for (int i = 0; i < n; i++) {
ln* tn = new ln();
tn->val = -1;
tn->next = NULL;
ln* on = fe(tn, i);
if (on != tn) {
atc.push_back(tn->next);
}
}
int noc = atc.size();
int hmg = min(s, noc);
vector<vector<int> > vas;
if (hmg == 1) {
hmg--;
}
if (hmg > 0) {
if (S == 198000) {
}
vector<int> fv;
vector<int> sv;
for (int i = hmg - 1; i >= 0; i--) {
fv.push_back(atc[i]->val);
}
for (int i = 0; i < hmg; i++) {
int oi = i - 1;
if (oi < 0) {
oi += hmg;
}
sv.push_back(atc[oi]->val);
ln* cn = atc[i]->next;
while (cn != NULL) {
sv.push_back(cn->val);
cn = cn->next;
}
}
vas.push_back(fv);
vas.push_back(sv);
}
for (int i = hmg; i < atc.size(); i++) {
vector<int> sv;
ln* cn = atc[i];
while (cn != NULL) {
sv.push_back(cn->val);
cn = cn->next;
}
vas.push_back(sv);
}
cout << vas.size() << "\n";
for (int i = 0; i < vas.size(); i++) {
cout << vas[i].size() << "\n";
for (int j = 0; j < vas[i].size(); j++) {
if (j > 0) {
cout << " ";
}
cout << (vas[i][j] + 1);
}
cout << "\n";
}
cin >> n;
}
|
1012_E. Cycle sort | You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | {
"input": [
"5 5\n3 2 3 1 1\n",
"4 3\n2 1 4 3\n",
"2 0\n2 2\n"
],
"output": [
"1\n5\n1 4 2 3 5 \n",
"-1\n",
"0\n"
]
} | {
"input": [
"5 0\n884430748 884430748 708433020 708433020 708433020\n",
"2 1\n1 1\n",
"2 0\n2 1\n",
"5 2\n65390026 770505072 65390026 65390026 65390026\n",
"5 4\n812067558 674124159 106041640 106041640 674124159\n",
"5 4\n167616600 574805150 651016425 150949603 379708534\n",
"5 5\n472778319 561757623 989296065 99763286 352037329\n",
"5 4\n201429826 845081337 219611799 598937628 680006294\n",
"2 2\n2 1\n",
"5 0\n1000000000 1000000000 1000000000 1000000000 1000000000\n",
"5 6\n971458729 608568364 891718769 464295315 98863653\n",
"5 5\n641494999 641494999 228574099 535883079 535883079\n",
"5 5\n815605413 4894095 624809427 264202135 152952491\n",
"1 0\n258769137\n",
"2 0\n1 1\n",
"1 0\n2\n",
"5 4\n335381650 691981363 691981363 335381650 335381650\n",
"5 4\n81224924 319704343 319704343 210445208 128525140\n",
"5 4\n579487081 564229995 665920667 665920667 644707366\n",
"5 200000\n682659092 302185582 518778252 29821187 14969298\n"
],
"output": [
"-1\n",
"0\n",
"-1\n",
"1\n2\n2 5 \n",
"-1\n",
"-1\n",
"1\n5\n1 3 5 2 4 \n",
"1\n4\n2 5 4 3 \n",
"1\n2\n1 2 \n",
"0\n",
"2\n2\n1 5\n3\n2 3 4\n",
"1\n5\n1 4 2 5 3 \n",
"2\n3\n1 5 2\n2\n3 4\n",
"0\n",
"0\n",
"0\n",
"1\n4\n2 4 3 5 \n",
"1\n4\n2 4 3 5 \n",
"2\n2\n1 2\n2\n3 5\n",
"2\n2\n1 5\n3\n2 3 4\n"
]
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 202020, d = 0;
int N, S, oval[MAXN], edge[MAXN], comp[MAXN], cnum = 0, vis[MAXN], vis2[MAXN];
vector<int> comp_stack[MAXN];
pair<int, int> vals[MAXN];
vector<int> cursol;
vector<vector<int> > solution;
void recur(int n) {
if (vis[n] > 0) return;
vis[n] = 1;
if (edge[n] != n) {
comp_stack[comp[n]].push_back(edge[n]);
recur(edge[n]);
}
}
void recur2(int n) {
vis2[comp[n]] = 1;
while (comp_stack[comp[n]].size() > 0) {
int next = comp_stack[comp[n]].back();
comp_stack[comp[n]].pop_back();
recur2(next);
}
cursol.push_back(n);
if (d) printf("add %d\n", n);
}
int main() {
scanf("%d %d", &N, &S);
for (int i = 1; i <= N; ++i) {
scanf("%d", &vals[i].first);
vals[i].second = i;
oval[i] = vals[i].first;
}
sort(vals + 1, vals + N + 1);
for (int i = 1; i <= N; ++i) {
if (vals[i].second != i && vals[vals[i].second].first == vals[i].first) {
int swap_with = vals[i].second;
pair<int, int> temp = vals[i];
vals[i] = vals[swap_with];
vals[swap_with] = temp;
}
}
for (int i = 1; i <= N; ++i) {
edge[vals[i].second] = i;
if (i > 1 && vals[i].first != vals[i - 1].first) {
cnum++;
}
comp[vals[i].second] = cnum;
}
if (d) {
for (int i = 1; i <= N; ++i) {
printf("%d: =%d ->%d, c%d\n", i, oval[i], edge[i], comp[i]);
}
}
int nswaps = N;
for (int i = 1; i <= N; ++i) {
if (edge[i] == i) {
nswaps--;
} else {
if (vis[i] == 0) {
recur(i);
}
}
}
if (nswaps > S) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= N; ++i) {
if (edge[i] != i && vis2[comp[i]] == 0) {
cursol.clear();
if (d) printf("begin recur2 at %d\n", i);
recur2(i);
if (cursol.size() > 0) {
solution.push_back(cursol);
}
}
}
printf("%d\n", (int)solution.size());
for (int i = 0; i < solution.size(); ++i) {
printf("%d\n", (int)solution[i].size() - 1);
for (int j = 0; j < solution[i].size() - 1; ++j) {
printf("%d", solution[i][solution[i].size() - j - 1]);
if (j == solution[i].size() - 2)
printf("\n");
else
printf(" ");
}
}
return 0;
}
|
1012_E. Cycle sort | You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | {
"input": [
"5 5\n3 2 3 1 1\n",
"4 3\n2 1 4 3\n",
"2 0\n2 2\n"
],
"output": [
"1\n5\n1 4 2 3 5 \n",
"-1\n",
"0\n"
]
} | {
"input": [
"5 0\n884430748 884430748 708433020 708433020 708433020\n",
"2 1\n1 1\n",
"2 0\n2 1\n",
"5 2\n65390026 770505072 65390026 65390026 65390026\n",
"5 4\n812067558 674124159 106041640 106041640 674124159\n",
"5 4\n167616600 574805150 651016425 150949603 379708534\n",
"5 5\n472778319 561757623 989296065 99763286 352037329\n",
"5 4\n201429826 845081337 219611799 598937628 680006294\n",
"2 2\n2 1\n",
"5 0\n1000000000 1000000000 1000000000 1000000000 1000000000\n",
"5 6\n971458729 608568364 891718769 464295315 98863653\n",
"5 5\n641494999 641494999 228574099 535883079 535883079\n",
"5 5\n815605413 4894095 624809427 264202135 152952491\n",
"1 0\n258769137\n",
"2 0\n1 1\n",
"1 0\n2\n",
"5 4\n335381650 691981363 691981363 335381650 335381650\n",
"5 4\n81224924 319704343 319704343 210445208 128525140\n",
"5 4\n579487081 564229995 665920667 665920667 644707366\n",
"5 200000\n682659092 302185582 518778252 29821187 14969298\n"
],
"output": [
"-1\n",
"0\n",
"-1\n",
"1\n2\n2 5 \n",
"-1\n",
"-1\n",
"1\n5\n1 3 5 2 4 \n",
"1\n4\n2 5 4 3 \n",
"1\n2\n1 2 \n",
"0\n",
"2\n2\n1 5\n3\n2 3 4\n",
"1\n5\n1 4 2 5 3 \n",
"2\n3\n1 5 2\n2\n3 4\n",
"0\n",
"0\n",
"0\n",
"1\n4\n2 4 3 5 \n",
"1\n4\n2 4 3 5 \n",
"2\n2\n1 2\n2\n3 5\n",
"2\n2\n1 5\n3\n2 3 4\n"
]
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, s, a[200010];
map<int, int> mp1;
map<int, vector<int> > mp2;
vector<vector<int> > ans;
void dfs(int u) {
while (!mp2[u].empty()) {
int i = mp2[u].back();
mp2[u].pop_back();
dfs(a[i]);
ans.back().push_back(i);
}
mp2.erase(u);
}
int main() {
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; i++) scanf("%d", a + i), ++mp1[a[i]];
int j = 1;
for (auto it = mp1.begin(); it != mp1.end(); j += it->second, ++it)
for (int i = j; i < j + it->second; i++)
if (a[i] != it->first) mp2[it->first].push_back(i);
while (!mp2.empty()) {
ans.push_back(vector<int>());
dfs(mp2.begin()->first);
reverse(ans.back().begin(), ans.back().end());
s -= ans.back().size();
}
if (s < 0) return puts("-1"), 0;
int b = min(s, (int)ans.size()), d = 0;
printf("%d\n", ans.size() - (b >= 3 ? b - 2 : 0));
if (b >= 3) {
for (int i = 0; i < b; i++) d += ans.size();
printf("%d\n", d);
for (int i = 0; i < b; i++)
for (auto c : ans[i]) printf("%d ", c);
printf("\n%d\n", b);
for (int i = b - 1; i; i--) printf("%d ", ans[i][0]);
printf("\n");
}
for (int i = (b >= 3 ? b : 0); i < ans.size(); i++) {
printf("%d\n", ans[i].size());
for (auto c : ans[i]) printf("%d ", c);
printf("\n");
}
return 0;
}
|
1012_E. Cycle sort | You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | {
"input": [
"5 5\n3 2 3 1 1\n",
"4 3\n2 1 4 3\n",
"2 0\n2 2\n"
],
"output": [
"1\n5\n1 4 2 3 5 \n",
"-1\n",
"0\n"
]
} | {
"input": [
"5 0\n884430748 884430748 708433020 708433020 708433020\n",
"2 1\n1 1\n",
"2 0\n2 1\n",
"5 2\n65390026 770505072 65390026 65390026 65390026\n",
"5 4\n812067558 674124159 106041640 106041640 674124159\n",
"5 4\n167616600 574805150 651016425 150949603 379708534\n",
"5 5\n472778319 561757623 989296065 99763286 352037329\n",
"5 4\n201429826 845081337 219611799 598937628 680006294\n",
"2 2\n2 1\n",
"5 0\n1000000000 1000000000 1000000000 1000000000 1000000000\n",
"5 6\n971458729 608568364 891718769 464295315 98863653\n",
"5 5\n641494999 641494999 228574099 535883079 535883079\n",
"5 5\n815605413 4894095 624809427 264202135 152952491\n",
"1 0\n258769137\n",
"2 0\n1 1\n",
"1 0\n2\n",
"5 4\n335381650 691981363 691981363 335381650 335381650\n",
"5 4\n81224924 319704343 319704343 210445208 128525140\n",
"5 4\n579487081 564229995 665920667 665920667 644707366\n",
"5 200000\n682659092 302185582 518778252 29821187 14969298\n"
],
"output": [
"-1\n",
"0\n",
"-1\n",
"1\n2\n2 5 \n",
"-1\n",
"-1\n",
"1\n5\n1 3 5 2 4 \n",
"1\n4\n2 5 4 3 \n",
"1\n2\n1 2 \n",
"0\n",
"2\n2\n1 5\n3\n2 3 4\n",
"1\n5\n1 4 2 5 3 \n",
"2\n3\n1 5 2\n2\n3 4\n",
"0\n",
"0\n",
"0\n",
"1\n4\n2 4 3 5 \n",
"1\n4\n2 4 3 5 \n",
"2\n2\n1 2\n2\n3 5\n",
"2\n2\n1 5\n3\n2 3 4\n"
]
} | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
struct ln {
int val;
ln* next;
};
vector<pair<int, int> >* nl;
int* roi;
bool* btdt;
ln* fe(ln* ath, int cp) {
for (int i = roi[cp]; i < nl[cp].size(); i = roi[cp]) {
int np = nl[cp][i].first;
int ind = nl[cp][i].second;
if (btdt[ind]) {
continue;
}
roi[cp]++;
btdt[ind] = 1;
ln* cn = new ln();
cn->val = ind;
cn->next = NULL;
ln* vas = fe(cn, np);
ath->next = cn;
ath = vas;
}
return ath;
}
int main() {
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
int n, s;
cin >> n >> s;
vector<pair<int, int> > ar(n);
nl = new vector<pair<int, int> >[n];
btdt = new bool[n];
roi = new int[n];
for (int i = 0; i < n; i++) {
roi[i] = 0;
vector<pair<int, int> > vpii;
nl[i] = vpii;
btdt[i] = 0;
int a;
cin >> a;
ar[i] = make_pair(a, i);
}
vector<pair<int, int> > br = ar;
sort(br.begin(), br.end());
unordered_map<int, int> nct;
int cn = -1;
int an = -1;
for (int i = 0; i < n; i++) {
if (br[i].first != an) {
cn++;
an = br[i].first;
nct[an] = cn;
}
br[i].first = cn;
}
for (int i = 0; i < n; i++) {
ar[i].first = nct[ar[i].first];
}
for (int i = 0; i < n; i++) {
if (br[i].first == ar[i].first) {
continue;
}
s--;
nl[br[i].first].push_back(make_pair(ar[i].first, br[i].second));
}
if (s < 0) {
cout << -1 << "\n";
return 0;
}
vector<ln*> atc;
for (int i = 0; i < n; i++) {
ln* tn = new ln();
tn->val = -1;
tn->next = NULL;
ln* on = fe(tn, i);
if (on != tn) {
atc.push_back(tn->next);
}
}
int noc = atc.size();
int hmg = min(s, noc);
vector<vector<int> > vas;
if (hmg == 1) {
hmg--;
}
if (hmg > 0) {
vector<int> fv;
vector<int> sv;
for (int i = 0; i < hmg; i++) {
fv.push_back(atc[i]->val);
ln* cn = atc[i];
while (cn != NULL) {
sv.push_back(cn->val);
cn = cn->next;
}
}
vas.push_back(fv);
vas.push_back(sv);
}
for (int i = hmg; i < atc.size(); i++) {
vector<int> sv;
ln* cn = atc[i];
while (cn != NULL) {
sv.push_back(cn->val);
cn = cn->next;
}
vas.push_back(sv);
}
cout << vas.size() << "\n";
for (int i = 0; i < vas.size(); i++) {
cout << vas[i].size() << "\n";
for (int j = 0; j < vas[i].size(); j++) {
if (j > 0) {
cout << " ";
}
cout << (vas[i][j] + 1);
}
cout << "\n";
}
cin >> n;
}
|
1012_E. Cycle sort | You are given an array of n positive integers a_1, a_2, ..., a_n. You can perform the following operation any number of times: select several distinct indices i_1, i_2, ..., i_k (1 ≤ i_j ≤ n) and move the number standing at the position i_1 to the position i_2, the number at the position i_2 to the position i_3, ..., the number at the position i_k to the position i_1. In other words, the operation cyclically shifts elements: i_1 → i_2 → … i_k → i_1.
For example, if you have n=4, an array a_1=10, a_2=20, a_3=30, a_4=40, and you choose three indices i_1=2, i_2=1, i_3=4, then the resulting array would become a_1=20, a_2=40, a_3=30, a_4=10.
Your goal is to make the array sorted in non-decreasing order with the minimum number of operations. The additional constraint is that the sum of cycle lengths over all operations should be less than or equal to a number s. If it's impossible to sort the array while satisfying that constraint, your solution should report that as well.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 200 000, 0 ≤ s ≤ 200 000)—the number of elements in the array and the upper bound on the sum of cycle lengths.
The next line contains n integers a_1, a_2, ..., a_n—elements of the array (1 ≤ a_i ≤ 10^9).
Output
If it's impossible to sort the array using cycles of total length not exceeding s, print a single number "-1" (quotes for clarity).
Otherwise, print a single number q— the minimum number of operations required to sort the array.
On the next 2 ⋅ q lines print descriptions of operations in the order they are applied to the array. The description of i-th operation begins with a single line containing one integer k (1 ≤ k ≤ n)—the length of the cycle (that is, the number of selected indices). The next line should contain k distinct integers i_1, i_2, ..., i_k (1 ≤ i_j ≤ n)—the indices of the cycle.
The sum of lengths of these cycles should be less than or equal to s, and the array should be sorted after applying these q operations.
If there are several possible answers with the optimal q, print any of them.
Examples
Input
5 5
3 2 3 1 1
Output
1
5
1 4 2 3 5
Input
4 3
2 1 4 3
Output
-1
Input
2 0
2 2
Output
0
Note
In the first example, it's also possible to sort the array with two operations of total length 5: first apply the cycle 1 → 4 → 1 (of length 2), then apply the cycle 2 → 3 → 5 → 2 (of length 3). However, it would be wrong answer as you're asked to use the minimal possible number of operations, which is 1 in that case.
In the second example, it's possible to the sort the array with two cycles of total length 4 (1 → 2 → 1 and 3 → 4 → 3). However, it's impossible to achieve the same using shorter cycles, which is required by s=3.
In the third example, the array is already sorted, so no operations are needed. Total length of empty set of cycles is considered to be zero. | {
"input": [
"5 5\n3 2 3 1 1\n",
"4 3\n2 1 4 3\n",
"2 0\n2 2\n"
],
"output": [
"1\n5\n1 4 2 3 5 \n",
"-1\n",
"0\n"
]
} | {
"input": [
"5 0\n884430748 884430748 708433020 708433020 708433020\n",
"2 1\n1 1\n",
"2 0\n2 1\n",
"5 2\n65390026 770505072 65390026 65390026 65390026\n",
"5 4\n812067558 674124159 106041640 106041640 674124159\n",
"5 4\n167616600 574805150 651016425 150949603 379708534\n",
"5 5\n472778319 561757623 989296065 99763286 352037329\n",
"5 4\n201429826 845081337 219611799 598937628 680006294\n",
"2 2\n2 1\n",
"5 0\n1000000000 1000000000 1000000000 1000000000 1000000000\n",
"5 6\n971458729 608568364 891718769 464295315 98863653\n",
"5 5\n641494999 641494999 228574099 535883079 535883079\n",
"5 5\n815605413 4894095 624809427 264202135 152952491\n",
"1 0\n258769137\n",
"2 0\n1 1\n",
"1 0\n2\n",
"5 4\n335381650 691981363 691981363 335381650 335381650\n",
"5 4\n81224924 319704343 319704343 210445208 128525140\n",
"5 4\n579487081 564229995 665920667 665920667 644707366\n",
"5 200000\n682659092 302185582 518778252 29821187 14969298\n"
],
"output": [
"-1\n",
"0\n",
"-1\n",
"1\n2\n2 5 \n",
"-1\n",
"-1\n",
"1\n5\n1 3 5 2 4 \n",
"1\n4\n2 5 4 3 \n",
"1\n2\n1 2 \n",
"0\n",
"2\n2\n1 5\n3\n2 3 4\n",
"1\n5\n1 4 2 5 3 \n",
"2\n3\n1 5 2\n2\n3 4\n",
"0\n",
"0\n",
"0\n",
"1\n4\n2 4 3 5 \n",
"1\n4\n2 4 3 5 \n",
"2\n2\n1 2\n2\n3 5\n",
"2\n2\n1 5\n3\n2 3 4\n"
]
} | IN-CORRECT | cpp | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long lint;
optional<vector<vector<int>>> solve(vector<int> &values, int max_sum) {
const int n = values.size();
vector<int> sorted = values;
sort(sorted.begin(), sorted.end());
struct edge_t {
int u;
int id;
};
vector<vector<edge_t>> adj(n);
int nmove = 0;
for (int i = 0; i < n; ++i)
if (sorted[i] != values[i]) {
int from =
lower_bound(sorted.begin(), sorted.end(), sorted[i]) - sorted.begin();
int to =
lower_bound(sorted.begin(), sorted.end(), values[i]) - sorted.begin();
adj[from].push_back({to, i});
nmove += 1;
}
if (nmove > max_sum) {
return {};
}
int ncnt = 0;
vector<bool> mark(n, false);
function<void(int)> mark_cnt = [&](int v) {
mark[v] = true;
for (const edge_t &ed : adj[v])
if (!mark[ed.u])
mark_cnt(ed.u);
};
for (int i = 0; i < n; ++i)
if (!mark[i] && !adj[i].empty()) {
++ncnt;
mark_cnt(i);
}
if (ncnt >= 3 && max_sum >= nmove + 3) {
int remain = min(ncnt, max_sum - nmove);
vector<int> to_move;
mark.assign(n, false);
for (int i = 0; i < n; ++i) {
if (!mark[i] && !adj[i].empty() && remain > 0) {
to_move.push_back(adj[i][0].id);
mark_cnt(i);
--remain;
}
}
for (int i = (int)to_move.size() - 2; i >= 0; --i)
swap(values[to_move[i]], values[to_move[i + 1]]);
vector<vector<int>> result =
solve(values, max_sum - (int)to_move.size()).value();
result.insert(result.begin(), to_move);
return result;
}
vector<vector<int>> result;
for (int i = 0; i < n; ++i)
if (!adj[i].empty()) {
vector<int> op;
function<void(int)> euler_path = [&](int v) {
while (!adj[v].empty()) {
edge_t ed = adj[v].back();
adj[v].pop_back();
euler_path(ed.u);
op.push_back(ed.id);
}
};
euler_path(i);
reverse(op.begin(), op.end());
result.push_back(move(op));
}
return result;
}
int main() {
int n, max_sum;
scanf("%d %d", &n, &max_sum);
vector<int> values(n);
for (int i = 0; i < n; ++i)
scanf("%d", &values[i]);
optional<vector<vector<int>>> result = solve(values, max_sum);
if (result) {
printf("%d\n", (int)result->size());
for (const vector<int> &op : *result) {
for (int i = 0; i < (int)op.size(); ++i) {
if (i > 0) printf(" ");
printf("%d", op[i] + 1);
}
printf("\n");
}
} else {
printf("-1\n");
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int module = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<set<int>> to(n, set<int>());
vector<pair<int, int>> edges(m);
vector<int> nbr(n);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
nbr[a]++;
nbr[b]++;
to[a].insert(b);
to[b].insert(a);
edges[i] = {a, b};
}
vector<bool> vis(n);
int all = n;
for (int i = 0; i < n; ++i) {
if (!vis[i]) {
if (nbr[i] < k) {
queue<int> q;
q.push(i);
vis[i] = true;
all--;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int t : to[cur]) {
nbr[t]--;
to[t].erase(cur);
if (nbr[t] < k && !vis[t]) {
q.push(t);
vis[t] = true;
all--;
}
}
}
}
}
}
queue<int> q;
vector<int> answer;
answer.push_back(all);
for (int i = m - 1; i > 0; i--) {
auto [a, b] = edges[i];
if (!vis[a] && !vis[b]) {
to[a].erase(b);
to[b].erase(a);
nbr[a]--;
nbr[b]--;
if (nbr[a] < k) {
q.push(a);
vis[a] = true;
all--;
}
if (nbr[b] < k) {
q.push(b);
vis[b] = true;
all--;
}
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int t : to[cur]) {
nbr[t]--;
to[t].erase(cur);
if (nbr[t] < k && !vis[t]) {
q.push(t);
vis[t] = true;
all--;
}
}
}
}
answer.push_back(all);
}
for (int i = answer.size() - 1; i >= 0; i--) {
cout << answer[i] << "\n";
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const long long maxn = (long long)1e6 + 5;
const long long mod = (long long)998244353;
const long long inf = 0x3f3f3f3f3f3f3f3f;
pair<long long, long long> a[maxn];
long long in[maxn];
vector<long long> v[maxn];
bool vis[maxn];
long long n, m, k;
long long ans;
void f(long long x) {
queue<long long> q;
q.push(x);
vis[x] = true;
--ans;
while (!q.empty()) {
long long now = q.front();
q.pop();
for (auto &i : v[now])
if (!vis[i] && --in[i] < k) ans--, q.push(i), vis[i] = true;
}
}
long long fin[maxn];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> k;
ans = n;
for (long long i = 1; i <= m; ++i) {
cin >> a[i].first >> a[i].second;
++in[a[i].first], ++in[a[i].second];
v[a[i].first].push_back(a[i].second);
v[a[i].second].push_back(a[i].first);
}
for (long long i = 1; i <= n; ++i)
if (!vis[i] && in[i] < k) f(i);
fin[m] = ans;
for (long long i = m; i >= 1; --i) {
if (!vis[a[i].first]) --in[a[i].second];
if (!vis[a[i].second]) --in[a[i].first];
v[a[i].first].pop_back();
v[a[i].second].pop_back();
if (in[a[i].first] < k && !vis[a[i].first]) f(a[i].first);
if (in[a[i].second] < k && !vis[a[i].second]) f(a[i].second);
fin[i - 1] = ans;
}
for (long long i = 1; i <= m; ++i) cout << fin[i] << '\n';
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 3e5 + 10;
long long x[N], y[N], deg[N];
vector<long long> vp[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
vp[x[i]].push_back(y[i]);
vp[y[i]].push_back(x[i]);
deg[x[i]]++;
deg[y[i]]++;
}
set<pair<long long, long long> > s;
for (long long i = 1; i <= n; i++) {
s.insert({deg[i], i});
}
long long ans = n;
set<pair<long long, long long> > ae;
vector<long long> v;
for (long long i = m; i >= 1; i--) {
while (s.size() > 0) {
auto it = *s.begin();
s.erase(it);
if (it.first >= k) break;
for (auto it1 : vp[it.second]) {
if (ae.find({it1, it.second}) == ae.end()) {
ae.insert({it1, it.second});
ae.insert({it.second, it1});
s.erase({deg[it1], it1});
deg[it1]--;
s.insert({deg[it1], it1});
}
}
ans--;
}
if (ae.find({x[i], y[i]}) == ae.end()) {
ae.insert({x[i], y[i]});
ae.insert({y[i], x[i]});
s.erase({deg[x[i]], x[i]});
s.erase({deg[y[i]], y[i]});
deg[x[i]]--;
s.insert({deg[x[i]], x[i]});
deg[y[i]]--;
s.insert({deg[y[i]], y[i]});
}
v.push_back(ans);
}
reverse(v.begin(), v.end());
for (auto it : v) {
cout << it << "\n";
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.*;
import java.util.*;
public class Test {
static int readInt() {
int ans = 0;
boolean neg = false;
try {
boolean start = false;
for (int c = 0; (c = System.in.read()) != -1; ) {
if (c == '-') {
start = true;
neg = true;
continue;
} else if (c >= '0' && c <= '9') {
start = true;
ans = ans * 10 + c - '0';
} else if (start) break;
}
} catch (IOException e) {
}
return neg ? -ans : ans;
}
static long readLong() {
long ans = 0;
boolean neg = false;
try {
boolean start = false;
for (int c = 0; (c = System.in.read()) != -1; ) {
if (c == '-') {
start = true;
neg = true;
continue;
} else if (c >= '0' && c <= '9') {
start = true;
ans = ans * 10 + c - '0';
} else if (start) break;
}
} catch (IOException e) {
}
return neg ? -ans : ans;
}
static String readString() {
StringBuilder b = new StringBuilder();
try {
boolean start = false;
for (int c = 0; (c = System.in.read()) != -1; ) {
if (c >= '0' && c <= '9') {
start = true;
b.append((char) (c));
} else if (start) break;
}
} catch (IOException e) {
}
return b.toString().trim();
}
static PrintWriter writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
void start() {
int n = readInt(), m = readInt(), k = readInt();
int[] from = new int[m], to = new int[m];
int[] q = new int[n];
Set<Integer>[] g = new Set[n + 1];
for (int i = 1; i <= n; i++) g[i] = new HashSet<>();
for (int i = 0; i < m; i++) {
int u = readInt(), v = readInt();
g[u].add(v);
g[v].add(u);
from[i] = u;
to[i] = v;
}
TreeSet<Integer> f = new TreeSet<>();
int a = 0, b = 0;
for (int i = 1; i <= n; i++)
if (g[i].size() < k) q[b++] = i;
else f.add(i);
while (a < b) {
int u = q[a++];
for (int v : g[u]) {
g[v].remove(u);
if (g[v].size() == k - 1) {
f.remove(v);
q[b++] = v;
}
}
g[u].clear();
}
int[] ans = new int[m];
for (int i = m - 1; i >= 0; i--) {
ans[i] = f.size();
a = 0;
b = 0;
int u = from[i], v = to[i];
for (int x : new int[]{u, v}) {
g[x].remove(x == u ? v : u);
if (g[x].size() == k - 1) {
f.remove(x);
q[b++] = x;
}
}
while (a < b) {
u = q[a++];
for (int x : g[u]) {
g[x].remove(u);
if (g[x].size() == k - 1) {
f.remove(x);
q[b++] = x;
}
}
g[u].clear();
}
}
for (int i = 0; i < m; i++) writer.println(ans[i]);
}
public static void main(String[] args) {
Test te = new Test();
te.start();
writer.flush();
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.util.*;
import java.io.*;
public class P1037E {
private static void solve() {
int n = nextInt();
int m = nextInt();
int k = nextInt();
Map<Integer, Set<Integer>> friends = new HashMap<>();
int[] f = new int[m];
int[] t = new int[m];
for (int i = 0; i < m; i++) {
int a = nextInt() - 1;
int b = nextInt() - 1;
friends.computeIfAbsent(a, x -> new HashSet<>()).add(b);
friends.computeIfAbsent(b, x -> new HashSet<>()).add(a);
friends.get(a).add(b);
friends.get(b).add(a);
f[i] = a; t[i] = b;
}
for (int i = 0; i < n; i++) {
remove(friends, i, k);
}
int[] ans = new int[m];
ans[m - 1] = friends.size();
for (int i = m - 1; i > 0; i--) {
if (friends.get(f[i]) != null)
friends.get(f[i]).remove(t[i]);
if (friends.get(t[i]) != null)
friends.get(t[i]).remove(f[i]);
remove(friends, f[i], k);
remove(friends, t[i], k);
ans[i - 1] = friends.size();
}
for (int i = 0; i < m; i++) {
out.println(ans[i]);
}
}
private static void remove(Map<Integer, Set<Integer>> friends, int toRemove, int k) {
if (friends.get(toRemove) == null || friends.get(toRemove).size() >= k) {
return;
}
Set<Integer> list = friends.remove(toRemove);
if (list != null) {
for (Integer l : list) {
if (friends.get(l) != null) {
friends.get(l).remove(toRemove);
remove(friends, l, k);
}
}
}
}
private static void run() {
br = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
out.close();
}
private static StringTokenizer st;
private static BufferedReader br;
private static PrintWriter out;
private static String next() {
while (st == null || !st.hasMoreElements()) {
String s;
try {
s = br.readLine();
} catch (IOException e) {
return null;
}
st = new StringTokenizer(s);
}
return st.nextToken();
}
private static int nextInt() {
return Integer.parseInt(next());
}
private static long nextLong() {
return Long.parseLong(next());
}
public static void main(String[] args) {
run();
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
set<int> se[200100];
int u[200100];
int v[200100];
int vis[200100];
int n, m, k, ans;
int num[200100];
void dfs(int st) {
if (se[st].size() >= k || vis[st]) return;
vis[st] = 1;
--ans;
for (auto &t : se[st]) {
se[t].erase(st);
dfs(t);
}
se[st].clear();
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
se[a].insert(b);
se[b].insert(a);
u[i] = a;
v[i] = b;
}
ans = n;
for (int i = 1; i <= n; i++) dfs(i);
num[m] = ans;
for (int i = m; i >= 1; i--) {
se[u[i]].erase(v[i]);
se[v[i]].erase(u[i]);
dfs(u[i]);
dfs(v[i]);
num[i - 1] = ans;
}
for (int i = 1; i <= m; i++) printf("%d\n", num[i]);
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0, ff = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') ff = -1;
ch = getchar();
}
while (isdigit(ch)) sum = sum * 10 + (ch ^ 48), ch = getchar();
return sum * ff;
}
const int mod = 1e9 + 7;
const int mo = 998244353;
const int N = 2e5 + 5;
int n, m, s, du[N], ok[N], ux[N], uy[N], sum[N], cnt, ans;
vector<int> G[N];
inline void del(int x) {
queue<int> q;
q.push(x);
ans--;
ok[x] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = (0); i <= ((int)G[u].size() - 1); i++) {
int v = G[u][i];
if (ok[v]) continue;
if ((--du[v]) < s) q.push(v), ok[v] = 1, ans--;
}
}
}
int main() {
n = read();
m = read();
s = read();
for (int i = (1); i <= (m); i++) {
int x, y;
x = read(), y = read();
G[x].push_back(y);
G[y].push_back(x);
du[y]++, du[x]++;
ux[i] = x, uy[i] = y;
}
ans = n;
for (int i = (1); i <= (n); i++)
if (!ok[i] && du[i] < s) del(i);
sum[m] = ans;
for (int i = (m); i >= (1); i--) {
int x = ux[i], y = uy[i];
if (!ok[x]) du[y]--;
if (!ok[y]) du[x]--;
G[x].pop_back();
G[y].pop_back();
if (!ok[x] && du[x] < s) del(x);
if (!ok[y] && du[y] < s) del(y);
sum[i - 1] = ans;
}
for (int i = (1); i <= (m); i++) printf("%d\n", sum[i]);
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
struct node {
int v, u;
} e[maxn + 10];
set<int> s[maxn];
int k, ans, in[maxn], vis[maxn], ret[maxn], n, m;
queue<int> q;
void dele(int x) {
set<int>::iterator iter;
int u, v;
if (vis[x] || in[x] >= k) return;
vis[x] = 1;
q.push(x);
--ans;
while (!q.empty()) {
u = q.front();
q.pop();
for (iter = s[u].begin(); iter != s[u].end(); iter++) {
v = *iter;
in[v]--;
if (in[v] < k && !vis[v]) {
vis[v] = 1;
q.push(v);
--ans;
}
}
}
}
int main() {
int i;
scanf("%d%d%d", &n, &m, &k);
memset(in, 0, sizeof(in));
for (i = 1; i <= m; i++) {
scanf("%d%d", &e[i].u, &e[i].v);
s[e[i].u].insert(e[i].v);
s[e[i].v].insert(e[i].u);
in[e[i].u]++;
in[e[i].v]++;
}
memset(vis, 0, sizeof(vis));
for (i = 1; i <= n; i++) {
dele(i);
}
ans = 0;
for (i = 1; i <= n; i++) {
if (!vis[i]) ans++;
}
ret[m] = ans;
for (i = m; i >= 1; i--) {
if (!vis[e[i].v]) in[e[i].u]--;
if (!vis[e[i].u]) in[e[i].v]--;
s[e[i].u].erase(e[i].v);
s[e[i].v].erase(e[i].u);
dele(e[i].u);
dele(e[i].v);
ret[i - 1] = ans;
}
for (i = 1; i <= m; i++) {
printf("%d\n", ret[i]);
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int mx = 200 * 1000 + 5;
vector<set<int> > vec(mx);
int arr1[mx], arr2[mx];
int main() {
int i, j, k, n, m, x, y, p, q, l;
scanf("%d %d %d", &n, &m, &k);
int ans = 0;
for (i = 0; i < m; i++) {
scanf("%d %d", &x, &y);
arr1[i] = x;
arr2[i] = y;
vec[x].insert(y);
vec[y].insert(x);
}
ans = n;
queue<int> ajairra;
bool vis[n + 5];
memset(vis, 0, sizeof(vis));
for (i = 1; i <= n; i++) {
p = vec[i].size();
if (p < k) {
vis[i] = 1;
ans--;
ajairra.push(i);
}
}
vector<int> vv;
set<int>::iterator itr;
for (i = m - 1; i >= 0; i--) {
while (!ajairra.empty()) {
p = ajairra.front();
ajairra.pop();
for (itr = vec[p].begin(); itr != vec[p].end(); itr++) {
q = *itr;
vec[q].erase(p);
l = vec[q].size();
if (l < k && !vis[q]) {
vis[q] = 1;
ans--;
ajairra.push(q);
}
}
vec[p].clear();
}
vv.push_back(ans);
p = arr1[i];
q = arr2[i];
vec[p].erase(q);
vec[q].erase(p);
l = vec[p].size();
if (l < k && !vis[p]) {
vis[p] = 1;
ans--;
ajairra.push(p);
}
l = vec[q].size();
if (l < k && !vis[q]) {
vis[q] = 1;
ans--;
ajairra.push(q);
}
}
for (i = m - 1; i >= 0; i--) {
printf("%d\n", vv[i]);
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
const int ms = 200200;
int n, m, k;
int ans[ms];
std::pair<int, int> edges[ms];
std::vector<int> use[ms];
int deg[ms];
bool del[ms];
int main() {
std::cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
use[u].push_back(i);
use[v].push_back(i);
deg[u]++;
deg[v]++;
edges[i] = std::pair<int, int>(u, v);
}
std::queue<int> q;
for (int i = 1; i <= n; i++) {
if (deg[i] < k) {
q.push(i);
}
}
del[m] = true;
int cur_ans = n;
for (int i = m; i >= 0; i--) {
if (!del[i]) {
int u = edges[i].first, v = edges[i].second;
if (deg[u] == k) {
q.push(u);
}
if (deg[v] == k) {
q.push(v);
}
deg[u]--;
deg[v]--;
del[i] = true;
}
while (!q.empty()) {
cur_ans--;
int on = q.front();
q.pop();
for (auto e : use[on]) {
if (!del[e]) {
int u = edges[e].first, v = edges[e].second;
if (deg[u] == k) {
q.push(u);
}
if (deg[v] == k) {
q.push(v);
}
deg[u]--;
deg[v]--;
del[e] = true;
}
}
}
ans[i] = cur_ans;
}
for (int i = 0; i < m; i++) {
printf("%d\n", ans[i + 1]);
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Iterator;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Asgar Javadov
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskE solver = new TaskE();
solver.solve(1, in, out);
out.close();
}
static class TaskE {
int k;
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n = in.nextInt();
int m = in.nextInt();
k = in.nextInt();
IntList[] adj = new IntList[n];
int[] result = new int[m];
int[] degree = new int[n];
for (int i = 0; i < n; i++) {
adj[i] = new IntList(3);
}
int[] u = new int[m];
int[] v = new int[m];
for (int i = 0; i < m; ++i) {
u[i] = in.nextInt() - 1;
v[i] = in.nextInt() - 1;
adj[u[i]].add(i);
adj[v[i]].add(i);
degree[u[i]]++;
degree[v[i]]++;
}
IntList que = new IntList(n);
boolean[] alive = ArrayUtils.createArray(m, true);
for (int i = 0; i < n; ++i)
if (degree[i] < k) que.add(i);
int head = 0;
for (int day = m - 1; day >= 0; --day) {
while (head < que.size()) {
int id = que.get(head);
for (int edgeId : adj[id]) {
if (!alive[edgeId]) continue;
int other = u[edgeId] == id ? v[edgeId] : u[edgeId];
if (degree[other] == k) {
que.add(other);
}
degree[other]--;
degree[id]--;
alive[edgeId] = false;
}
++head;
}
result[day] = n - que.size();
if (alive[day]) {
if (degree[u[day]] == k)
que.add(u[day]);
if (degree[v[day]] == k)
que.add(v[day]);
degree[u[day]]--;
degree[v[day]]--;
alive[day] = false;
}
}
// while (!set.isEmpty() && set.first().first < k) {
// IntPair pair = set.first();
// for (Iterator<Integer> it = adj[pair.second].iterator(); it.hasNext(); ) {
// int edge = it.next();
// int e = v[edge] == pair.second ? u[edge] : v[edge];
// set.remove(degree[e]);
// degree[e].first--;
// set.add(degree[e]);
// it.remove();
// }
// set.remove(pair);
// alive[pair.second] = false;
// }
//
// for (int i = m - 1; i >= 0; --i) {
// result[i] = set.size();
// if (alive[u[i]] && alive[v[i]]) {
// set.remove(degree[u[i]]);
// degree[u[i]].first--;
// set.add(degree[u[i]]);
//
// set.remove(degree[v[i]]);
// degree[v[i]].first--;
// set.add(degree[v[i]]);
//
// while (!set.isEmpty() && set.first().first < k) {
// IntPair pair = set.first();
// for (Iterator<Integer> it = adj[pair.second].iterator(); it.hasNext(); ) {
// int edge = it.next();
// it.remove();
// if (edge < i) {
// int e = v[edge] == pair.second ? u[edge] : v[edge];
// if (!alive[e]) continue;
// set.remove(degree[e]);
// degree[e].first--;
// set.add(degree[e]);
// }
// }
// set.remove(pair);
// alive[pair.second] = false;
// }
// }
// }
for (int e : result)
out.println(e);
}
}
static class InputReader extends BufferedReader {
StringTokenizer tokenizer;
public InputReader(InputStream inputStream) {
super(new InputStreamReader(inputStream), 32768);
}
public InputReader(String filename) {
super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(readLine());
} catch (IOException e) {
throw new RuntimeException();
}
}
return tokenizer.nextToken();
}
public Integer nextInt() {
return Integer.valueOf(next());
}
}
static class OutputWriter extends PrintWriter {
public OutputWriter(OutputStream outputStream) {
super(outputStream);
}
public OutputWriter(Writer writer) {
super(writer);
}
public OutputWriter(String filename) throws FileNotFoundException {
super(filename);
}
public void close() {
super.close();
}
}
static class IntList implements Iterable<Integer> {
public static final int INITIAL_CAPACITY = 4;
private int size;
private int[] array;
public IntList() {
this(INITIAL_CAPACITY);
}
public IntList(int initialCapacity) {
this.array = new int[initialCapacity];
this.size = 0;
}
public IntList(int[] array) {
this.array = Arrays.copyOf(array, array.length);
this.size = this.array.length;
}
public void add(int value) {
if (size == array.length) {
ensureCapacity();
}
this.array[this.size++] = value;
}
public int get(int index) {
if (index < 0 || index >= size)
throw new IllegalArgumentException("Expected argument in [0, " + size + "), but found " + index);
return array[index];
}
public int size() {
return this.size;
}
private void ensureCapacity() {
if (size < array.length)
return;
this.array = Arrays.copyOf(array, array.length << 1);
}
public IntList clone() {
IntList cloned = new IntList(Math.max(1, this.size));
for (int i = 0; i < size; ++i)
cloned.add(array[i]);
return cloned;
}
public Iterator<Integer> iterator() {
return new IntListIterator();
}
private class IntListIterator implements Iterator<Integer> {
private int current;
public IntListIterator() {
this.current = 0;
}
public boolean hasNext() {
return this.current < size;
}
public Integer next() {
return array[current++];
}
}
}
static class ArrayUtils {
public static boolean[] createArray(int count, boolean value) {
boolean[] array = new boolean[count];
Arrays.fill(array, value);
return array;
}
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
vector<pair<int, int>> g[N];
vector<int> deg, ans;
vector<pair<int, int>> edge;
set<pair<int, int>> good;
vector<bool> in_good;
void f(int k, int iteration) {
while (!good.empty() && good.begin()->first < k) {
int v = good.begin()->second;
for (auto j : g[v]) {
int i = j.first;
int it = j.second;
if (iteration <= it) continue;
if (in_good[i]) {
good.erase({deg[i], i});
deg[i]--;
good.insert({deg[i], i});
}
}
good.erase({deg[v], v});
in_good[v] = false;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
deg.resize(n, 0);
edge.resize(m);
in_good.resize(n, true);
ans.resize(m);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
edge[i] = {a, b};
deg[a]++;
deg[b]++;
g[a].push_back({b, i});
g[b].push_back({a, i});
}
for (int i = 0; i < n; i++) {
good.insert({deg[i], i});
}
f(k, m);
for (int i = m - 1; i >= 0; i--) {
ans[i] = good.size();
if (i == 0) break;
int v = edge[i].first;
int u = edge[i].second;
if (!in_good[v] || !in_good[u]) continue;
good.erase({deg[v], v});
deg[v]--;
good.insert({deg[v], v});
good.erase({deg[u], u});
deg[u]--;
good.insert({deg[u], u});
f(k, i);
}
for (int i = 0; i < m; i++) cout << ans[i] << endl;
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double pi = acos(-1.0);
const int maxn = 200000 + 10;
const int mod = 1e9 + 7;
inline char _getchar() {
static const int BUFSIZE = 100001;
static char buf[BUFSIZE];
static char *psta = buf, *pend = buf;
if (psta >= pend) {
psta = buf;
pend = buf + fread(buf, 1, BUFSIZE, stdin);
if (psta >= pend) return -1;
}
return *psta++;
}
inline int read(int &x) {
x = 0;
int f = 1;
char ch = _getchar();
while ((ch < '0' || ch > '9') && ~ch) {
if (ch == '-') f = -1;
ch = _getchar();
}
if (ch == -1) return -1;
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = _getchar();
}
x *= f;
return 1;
}
inline int read(long long &x) {
x = 0;
int f = 1;
char ch = _getchar();
while ((ch < '0' || ch > '9') && ~ch) {
if (ch == '-') f = -1;
ch = _getchar();
}
if (ch == -1) return -1;
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = _getchar();
}
x *= f;
return 1;
}
inline int read(double &x) {
char in;
double Dec = 0.1;
bool IsN = false, IsD = false;
in = _getchar();
if (in == EOF) return -1;
while (in != '-' && in != '.' && (in < '0' || in > '9')) in = _getchar();
if (in == '-') {
IsN = true;
x = 0;
} else if (in == '.') {
IsD = true;
x = 0;
} else
x = in - '0';
if (!IsD) {
while (in = _getchar(), in >= '0' && in <= '9') {
x *= 10;
x += in - '0';
}
}
if (in != '.') {
if (IsN) x = -x;
return 1;
} else {
while (in = _getchar(), in >= '0' && in <= '9') {
x += Dec * (in - '0');
Dec *= 0.1;
}
}
if (IsN) x = -x;
return 1;
}
inline int read(float &x) {
char in;
double Dec = 0.1;
bool IsN = false, IsD = false;
in = _getchar();
if (in == EOF) return -1;
while (in != '-' && in != '.' && (in < '0' || in > '9')) in = _getchar();
if (in == '-') {
IsN = true;
x = 0;
} else if (in == '.') {
IsD = true;
x = 0;
} else
x = in - '0';
if (!IsD) {
while (in = _getchar(), in >= '0' && in <= '9') {
x *= 10;
x += in - '0';
}
}
if (in != '.') {
if (IsN) x = -x;
return 1;
} else {
while (in = _getchar(), in >= '0' && in <= '9') {
x += Dec * (in - '0');
Dec *= 0.1;
}
}
if (IsN) x = -x;
return 1;
}
inline int read(char *x) {
char *tmp = x;
char in = _getchar();
while (in <= ' ' && in != EOF) in = _getchar();
if (in == -1) return -1;
while (in > ' ') *(tmp++) = in, in = _getchar();
*tmp = '\0';
return 1;
}
int l[maxn], r[maxn];
vector<int> nt[maxn];
vector<int> pt[maxn];
int cnt[maxn];
int vis[maxn];
int tot;
int ans[maxn];
int ok[maxn];
int n, m, k;
queue<int> q;
void Count() {
while (!q.empty()) {
int x = q.front();
q.pop();
tot--;
for (int i = 0; i < nt[x].size(); i++) {
int nx = nt[x][i];
if (!vis[nx]) {
if (!ok[pt[x][i]]) cnt[nx]--;
if (cnt[nx] < k) q.push(nx), vis[nx] = 1;
}
ok[pt[x][i]] = 1;
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%d%d", l + i, r + i);
nt[l[i]].push_back(r[i]), nt[r[i]].push_back(l[i]);
pt[l[i]].push_back(i), pt[r[i]].push_back(i);
cnt[l[i]]++, cnt[r[i]]++;
}
tot = n;
for (int i = 1; i <= n; i++)
if (cnt[i] < k) q.push(i), vis[i] = 1;
Count();
for (int i = m - 1; i >= 0; i--) {
ans[i] = tot;
ok[i] = 1;
if ((!vis[l[i]]) && (!vis[r[i]])) {
cnt[l[i]]--, cnt[r[i]]--;
if (cnt[l[i]] < k) q.push(l[i]), vis[l[i]] = 1;
if (cnt[r[i]] < k) q.push(r[i]), vis[r[i]] = 1;
Count();
}
}
for (int i = 0; i < m; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
using namespace std;
int deg[200100];
set<pair<int, int> > pset;
vector<pair<int, int> > query;
set<int> conn[200100];
bool is_going(int u) { return (pset.find(make_pair(deg[u], u)) != pset.end()); }
int n, m, k;
void delete_adjacent(int u) {
for (auto v : conn[u]) {
conn[v].erase(conn[v].find(u));
if (is_going(v)) {
pset.erase(pset.find(make_pair(deg[v], v)));
deg[v]--;
if (deg[v] < k) {
delete_adjacent(v);
} else
pset.insert(make_pair(deg[v], v));
}
}
conn[u].clear();
}
void print_set() {
if (!pset.size()) cout << "Set is empty" << endl;
for (auto p : pset) cout << p.second << "," << p.first << " ";
cout << endl;
}
vector<int> ans(200100);
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
deg[u]++;
deg[v]++;
query.push_back({u, v});
conn[u].insert(v);
conn[v].insert(u);
}
for (int i = 1; i <= n; i++) {
pset.insert(make_pair(deg[i], i));
}
for (int i = 1; i <= n; i++) {
if (deg[i] < k && is_going(i)) {
pset.erase(make_pair(deg[i], i));
delete_adjacent(i);
}
}
for (int i = m - 1; i >= 0; i--) {
int u = query[i].first;
int v = query[i].second;
ans[i + 1] = pset.size();
if (pset.find(make_pair(deg[u], u)) != pset.end() &&
pset.find(make_pair(deg[v], v)) != pset.end()) {
if (deg[u] - 1 >= k && deg[v] - 1 >= k) {
pset.erase(pset.find(make_pair(deg[u], u)));
pset.erase(pset.find(make_pair(deg[v], v)));
conn[u].erase(conn[u].find(v));
conn[v].erase(conn[v].find(u));
deg[u]--;
deg[v]--;
pset.insert(make_pair(deg[u], u));
pset.insert(make_pair(deg[v], v));
} else if (deg[u] <= k) {
pset.erase(pset.find(make_pair(deg[u], u)));
deg[u]--;
delete_adjacent(u);
} else {
pset.erase(pset.find(make_pair(deg[v], v)));
deg[v]--;
delete_adjacent(v);
}
}
}
for (int i = 1; i <= m; i++) cout << ans[i] << endl;
cout << endl;
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Egor Kulikov ([email protected])
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
E solver = new E();
solver.solve(1, in, out);
out.close();
}
static class E {
int[] first;
int[] next;
int[] last;
int[] to;
int[] degree;
int enabled;
boolean[] good;
boolean[] inQueue;
int[] queue;
int size;
int k;
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n = in.readInt();
int m = in.readInt();
k = in.readInt();
int[] x = new int[m];
int[] y = new int[m];
in.readIntArrays(x, y);
MiscUtils.decreaseByOne(x, y);
first = ArrayUtils.createArray(n, -1);
next = new int[2 * m];
last = ArrayUtils.createArray(2 * m, -1);
to = new int[2 * m];
for (int i = 0; i < m; i++) {
to[2 * i] = y[i];
next[2 * i] = first[x[i]];
first[x[i]] = 2 * i;
if (next[2 * i] != -1) {
last[next[2 * i]] = 2 * i;
}
to[2 * i + 1] = x[i];
next[2 * i + 1] = first[y[i]];
first[y[i]] = 2 * i + 1;
if (next[2 * i + 1] != -1) {
last[next[2 * i + 1]] = 2 * i + 1;
}
}
degree = new int[n];
for (int i = 0; i < m; i++) {
degree[x[i]]++;
degree[y[i]]++;
}
enabled = n;
good = ArrayUtils.createArray(n, true);
queue = new int[n];
inQueue = new boolean[n];
size = 0;
for (int i = 0; i < n; i++) {
if (degree[i] < k) {
queue[size++] = i;
inQueue[i] = true;
}
}
processQueue();
int[] answer = new int[m];
answer[m - 1] = enabled;
for (int i = m - 1; i > 0; i--) {
if (good[x[i]] && good[y[i]]) {
removeEdge(2 * i);
removeEdge(2 * i + 1);
size = 0;
if (degree[x[i]] < k) {
queue[size++] = x[i];
}
if (degree[y[i]] < k) {
queue[size++] = y[i];
}
processQueue();
}
answer[i - 1] = enabled;
}
for (int i : answer) {
out.printLine(i);
}
}
private void removeEdge(int edge) {
degree[to[edge ^ 1]]--;
int n = next[edge];
int l = last[edge];
if (n != -1) {
last[n] = l;
}
if (l != -1) {
next[l] = n;
} else {
first[to[edge ^ 1]] = n;
}
}
private void processQueue() {
for (int i = 0; i < size; i++) {
int vertex = queue[i];
good[vertex] = false;
enabled--;
for (int j = first[vertex]; j != -1; j = next[j]) {
removeEdge(j ^ 1);
if (degree[to[j]] < k && !inQueue[to[j]]) {
queue[size++] = to[j];
inQueue[to[j]] = true;
}
}
}
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void printLine(int i) {
writer.println(i);
}
}
static class MiscUtils {
public static void decreaseByOne(int[]... arrays) {
for (int[] array : arrays) {
for (int i = 0; i < array.length; i++) {
array[i]--;
}
}
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public void readIntArrays(int[]... arrays) {
for (int i = 0; i < arrays[0].length; i++) {
for (int j = 0; j < arrays.length; j++) {
arrays[j][i] = readInt();
}
}
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int readInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
static class ArrayUtils {
public static int[] createArray(int count, int value) {
int[] array = new int[count];
Arrays.fill(array, value);
return array;
}
public static boolean[] createArray(int count, boolean value) {
boolean[] array = new boolean[count];
Arrays.fill(array, value);
return array;
}
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long INFL = 9223372036854775807LL;
const double EPSILON = 0.00000001;
const long long MOD = 1000000007;
vector<int> adj[200000 + 5];
unordered_map<int, int> removed[200000 + 5];
int degree[200000 + 5];
bool node_removed[200000 + 5];
int ans = 0;
void remove_edge(int u, int v, int k) {
degree[u]--;
degree[v]--;
removed[u][v] = true;
removed[v][u] = true;
}
void remove_edges(int start, int k) {
queue<int> q;
assert(degree[start] < k);
assert(not node_removed[start]);
q.push(start);
node_removed[start] = true;
ans--;
while (!q.empty()) {
int top = q.front();
q.pop();
for (int x : adj[top]) {
if (not removed[top][x]) {
remove_edge(top, x, k);
if (not node_removed[x] and degree[x] < k) {
node_removed[x] = true;
ans--;
q.push(x);
}
}
}
}
}
int32_t main() {
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int>> edges;
memset(node_removed, false, sizeof(node_removed));
;
ans = n;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d", &u);
;
scanf("%d", &v);
;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
edges.push_back({u, v});
removed[u][v] = false;
removed[v][u] = false;
}
for (int i = 0; i < n; i++) {
degree[i] = (int)(adj[i]).size();
}
for (int i = 0; i < n; i++) {
if (not node_removed[i] and degree[i] < k) {
remove_edges(i, k);
}
}
vector<int> out;
for (int i = (int)(edges).size() - 1; i >= 0; i--) {
out.push_back(ans);
int u = edges[i].first, v = edges[i].second;
if (not removed[u][v]) {
remove_edge(u, v, k);
if (not node_removed[u] and degree[u] < k) {
remove_edges(u, k);
}
if (not node_removed[v] and degree[v] < k) {
remove_edges(v, k);
}
}
}
for (int i = (int)(out).size() - 1; i >= 0; i--) {
printf("%d\n", out[i]);
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.*;
import java.util.*;
import javafx.util.Pair;
public class HR27 {
InputStream is;
PrintWriter out;
String INPUT = "";
//boolean codechef=true;
boolean codechef=true;
void solve()
{
int n=ni(),m=ni(),k=ni();
int[] from=new int[2*m];
Pair[] to=new Pair[2*m];
int[] deg=new int[n];
int[][] backup=new int[m][2];
boolean[] unvis=new boolean[n];
Arrays.fill(unvis,true);
for(int i=0;i<m;i++)
{
int x=ni()-1,y=ni()-1;
from[2*i]=x;
to[2*i]=new Pair(y,i);
from[2*i+1]=y;
to[2*i+1]=new Pair(x,i);
deg[x]++;
deg[y]++;
backup[i][0]=x;
backup[i][1]=y;
}
Pair[][] g=packD(n,from,to);
TreeSet<Pair> set=new TreeSet<>(new Comparator<Pair>(){
public int compare(Pair p1,Pair p2)
{
if(p1.a==p2.a)return p1.b-p2.b;
return p1.a-p2.a;
}
});
for(int i=0;i<n;i++)
{
set.add(new Pair(deg[i],i));
}
while(!set.isEmpty() && set.first().a<k)
{
Pair u=set.pollFirst();
unvis[u.b]=false;
for(Pair next:g[u.b])
{
int v=next.a;
if(unvis[v])
{
set.remove(new Pair(deg[v],v));
deg[v]--;
set.add(new Pair(deg[v],v));
}
}
}
int[] ans=new int[m];
for(int i=m-1;i>=0;i--)
{
ans[i]=set.size();
int x=backup[i][0];
int y=backup[i][1];
if(unvis[x] && unvis[y])
{
set.remove(new Pair(deg[x],x));
deg[x]--;
set.add(new Pair(deg[x],x));
set.remove(new Pair(deg[y],y));
deg[y]--;
set.add(new Pair(deg[y],y));
while(!set.isEmpty() && set.first().a<k)
{
Pair u=set.pollFirst();
unvis[u.b]=false;
for(Pair next:g[u.b])
{
int v=next.a;
if(next.b>=i)continue;
if(unvis[v])
{
set.remove(new Pair(deg[v],v));
deg[v]--;
set.add(new Pair(deg[v],v));
}
}
}
}
}
for(int i=0;i<m;i++)
{
out.println(ans[i]);
}
//out.println();
}
static Pair[][] packD(int n, int[] from, Pair[] to) {
Pair[][] g = new Pair[n][];
int[] p = new int[n];
for (int f : from)
p[f]++;
for (int i = 0; i < n; i++)
g[i] = new Pair[p[i]];
for (int i = 0; i < from.length; i++) {
g[from[i]][--p[from[i]]] = to[i];
}
return g;
}
public static long[] radixSort(long[] f){ return radixSort(f, f.length); }
public static long[] radixSort(long[] f, int n)
{
long[] to = new long[n];
{
int[] b = new int[65537];
for(int i = 0;i < n;i++)b[1+(int)(f[i]&0xffff)]++;
for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
for(int i = 0;i < n;i++)to[b[(int)(f[i]&0xffff)]++] = f[i];
long[] d = f; f = to;to = d;
}
{
int[] b = new int[65537];
for(int i = 0;i < n;i++)b[1+(int)(f[i]>>>16&0xffff)]++;
for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
for(int i = 0;i < n;i++)to[b[(int)(f[i]>>>16&0xffff)]++] = f[i];
long[] d = f; f = to;to = d;
}
{
int[] b = new int[65537];
for(int i = 0;i < n;i++)b[1+(int)(f[i]>>>32&0xffff)]++;
for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
for(int i = 0;i < n;i++)to[b[(int)(f[i]>>>32&0xffff)]++] = f[i];
long[] d = f; f = to;to = d;
}
{
int[] b = new int[65537];
for(int i = 0;i < n;i++)b[1+(int)(f[i]>>>48&0xffff)]++;
for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
for(int i = 0;i < n;i++)to[b[(int)(f[i]>>>48&0xffff)]++] = f[i];
long[] d = f; f = to;to = d;
}
return f;
}
static class Pair
{
int a,b;
public Pair(int a,int b)
{
this.a=a;
this.b=b;
}
}
static int bit[];
static void add(int x,int d,int n)
{
for(int i=x;i<=n;i+=i&-i)bit[i]+=d;
}
static int query(int x)
{
int ret=0;
for(int i=x;i>0;i-=i&-i)
ret+=bit[i];
return ret;
}
static long lcm(int a,int b)
{
long val=a;
val*=b;
return (val/gcd(a,b));
}
static int gcd(int a,int b)
{
if(a==0)return b;
return gcd(b%a,a);
}
static int pow(int a, int b, int p)
{
long ans = 1, base = a;
while (b!=0)
{
if ((b & 1)!=0)
{
ans *= base;
ans%= p;
}
base *= base;
base%= p;
b >>= 1;
}
return (int)ans;
}
static int inv(int x, int p)
{
return pow(x, p - 2, p);
}
void run() throws Exception
{
if(codechef)oj=true;
is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
out = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
out.flush();
tr(System.currentTimeMillis()-s+"ms");
}
public static void main(String[] args) throws Exception {new HR27().run();}
private byte[] inbuf = new byte[1024];
public int lenbuf = 0, ptrbuf = 0;
private int readByte()
{
if(lenbuf == -1)throw new InputMismatchException();
if(ptrbuf >= lenbuf){
ptrbuf = 0;
try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
if(lenbuf <= 0)return -1;
}
return inbuf[ptrbuf++];
}
private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }
private double nd() { return Double.parseDouble(ns()); }
private char nc() { return (char)skip(); }
private String ns()
{
int b = skip();
StringBuilder sb = new StringBuilder();
while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private char[] ns(int n)
{
char[] buf = new char[n];
int b = skip(), p = 0;
while(p < n && !(isSpaceChar(b))){
buf[p++] = (char)b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private char[][] nm(int n, int m)
{
char[][] map = new char[n][];
for(int i = 0;i < n;i++)map[i] = ns(m);
return map;
}
private int[] na(int n)
{
int[] a = new int[n];
for(int i = 0;i < n;i++)a[i] = ni();
return a;
}
private int ni()
{
int num = 0, b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private long nl()
{
long num = 0;
int b;
boolean minus = false;
while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
if(b == '-'){
minus = true;
b = readByte();
}
while(true){
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
b = readByte();
}
}
private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
int n, m, k, u[200010], v[200010], t[200010];
std::set<int> next[200010], p;
inline void remove(int x) {
if ((int)next[x].size() < k && p.erase(x)) {
for (auto y : next[x]) {
next[y].erase(x);
remove(y);
}
next[x].clear();
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d%d", u + i, v + i);
next[u[i]].insert(v[i]);
next[v[i]].insert(u[i]);
}
for (int i = 1; i <= n; i++) p.insert(i);
for (int i = 1; i <= n; i++) remove(i);
for (int i = m; i; i--) {
t[i] = p.size();
if (p.count(v[i]) && p.count(u[i])) {
next[v[i]].erase(u[i]);
next[u[i]].erase(v[i]);
remove(u[i]);
remove(v[i]);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", t[i]);
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.*;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;
public class E {
FastScanner in;
PrintWriter out;
public static void main(String[] args) {
new E().run();
}
void solve() throws IOException {
int n = in.nextInt();
int m = in.nextInt();
int k = in.nextInt();
int[][] es = new int[m][];
Arrays.setAll(es, i -> new int[]{in.nextInt() - 1, in.nextInt() - 1});
Set<Integer>[] edges = new Set[n];
Arrays.setAll(edges, i -> new HashSet<>());
for (int[] e : es) {
edges[e[0]].add(e[1]);
edges[e[1]].add(e[0]);
}
Set<Integer> set = new HashSet<>();
for (int i = 0; i < n; i++) {
set.add(i);
}
int[] q = new int[n];
boolean[] was = new boolean[n];
int head = 0;
int tail = 0;
for (int i = 0; i < n; i++) {
if (edges[i].size() < k) {
q[tail++] = i;
was[i] = true;
}
}
int[] ans = new int[m];
for (int i = m - 1; i >= 0; --i) {
for (; head < tail; head++) {
int v = q[head];
set.remove(v);
for (int u : edges[v]) {
if (set.contains(u) && !was[u]) {
edges[u].remove(v);
if (edges[u].size() < k) {
q[tail++] = u;
was[u] = true;
}
}
}
}
ans[i] = set.size();
int u = es[i][0];
int v = es[i][1];
if (set.contains(u) && set.contains(v)) {
edges[u].remove(v);
edges[v].remove(u);
if (edges[u].size() < k) { q[tail++] = u; was[u] = true; }
if (edges[v].size() < k) { q[tail++] = v; was[v] = true; }
}
}
Arrays.stream(ans).forEach(out::println);
}
void run() {
try {
in = new FastScanner(System.in);
out = new PrintWriter(System.out);
solve();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
FastScanner(InputStream is) {
br = new BufferedReader(new InputStreamReader(is));
}
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.*;
import java.math.*;
import java.util.*;
import java.util.stream.*;
public class E {
void submit() {
int n = nextInt();
int m = nextInt();
int k = nextInt();
int[] vs = new int[m];
int[] us = new int[m];
int[] deg = new int[n];
for (int i = 0; i < m; i++) {
vs[i] = nextInt() - 1;
us[i] = nextInt() - 1;
deg[vs[i]]++;
deg[us[i]]++;
}
int[][] g = new int[n][];
for (int i = 0; i < n; i++) {
g[i] = new int[deg[i]];
}
int[] ptr = deg.clone();
for (int i = 0; i < m; i++) {
int v = vs[i];
int u = us[i];
g[v][--ptr[v]] = i;
g[u][--ptr[u]] = i;
}
boolean[] dead = new boolean[n];
int[] que = new int[n];
int qh = 0, qt = 0;
for (int i = 0; i < n; i++) {
if (deg[i] < k) {
dead[i] = true;
que[qt++] = i;
}
}
while (qh < qt) {
int v = que[qh++];
for (int e : g[v]) {
int u = vs[e] ^ us[e] ^ v;
if (!dead[u]) {
deg[u]--;
if (deg[u] < k) {
dead[u] = true;
que[qt++] = u;
}
}
}
}
int[] ans = new int[m];
for (int i = m - 1; i >= 0; i--) {
ans[i] = n - qt;
int p = vs[i];
int q = us[i];
if (!dead[p] && !dead[q]) {
deg[p]--;
deg[q]--;
if (deg[p] < k) {
que[qt++] = p;
dead[p] = true;
}
if (deg[q] < k) {
que[qt++] = q;
dead[q] = true;
}
}
while (qh < qt) {
int v = que[qh++];
for (int e : g[v]) {
int u = vs[e] ^ us[e] ^ v;
if (!dead[u]) {
if (e >= i) {
continue;
}
deg[u]--;
if (deg[u] < k) {
dead[u] = true;
que[qt++] = u;
}
}
}
}
}
for (int x : ans) {
out.println(x);
}
}
void test() {
}
void stress() {
for (int tst = 0;; tst++) {
if (false) {
throw new AssertionError();
}
System.err.println(tst);
}
}
E() throws IOException {
is = System.in;
out = new PrintWriter(System.out);
submit();
// stress();
// test();
out.close();
}
static final Random rng = new Random();
static final int C = 5;
static int rand(int l, int r) {
return l + rng.nextInt(r - l + 1);
}
public static void main(String[] args) throws IOException {
new E();
}
private InputStream is;
PrintWriter out;
private byte[] buf = new byte[1 << 14];
private int bufSz = 0, bufPtr = 0;
private int readByte() {
if (bufSz == -1)
throw new RuntimeException("Reading past EOF");
if (bufPtr >= bufSz) {
bufPtr = 0;
try {
bufSz = is.read(buf);
} catch (IOException e) {
throw new RuntimeException(e);
}
if (bufSz <= 0)
return -1;
}
return buf[bufPtr++];
}
private boolean isTrash(int c) {
return c < 33 || c > 126;
}
private int skip() {
int b;
while ((b = readByte()) != -1 && isTrash(b))
;
return b;
}
String nextToken() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!isTrash(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
String nextString() {
int b = readByte();
StringBuilder sb = new StringBuilder();
while (!isTrash(b) || b == ' ') {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
double nextDouble() {
return Double.parseDouble(nextToken());
}
char nextChar() {
return (char) skip();
}
int nextInt() {
int ret = 0;
int b = skip();
if (b != '-' && (b < '0' || b > '9')) {
throw new InputMismatchException();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
ret = ret * 10 + (b - '0');
} else {
if (b != -1 && !isTrash(b)) {
throw new InputMismatchException();
}
return neg ? -ret : ret;
}
b = readByte();
}
}
long nextLong() {
long ret = 0;
int b = skip();
if (b != '-' && (b < '0' || b > '9')) {
throw new InputMismatchException();
}
boolean neg = false;
if (b == '-') {
neg = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
ret = ret * 10 + (b - '0');
} else {
if (b != -1 && !isTrash(b)) {
throw new InputMismatchException();
}
return neg ? -ret : ret;
}
b = readByte();
}
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, m, k;
set<int> M[200005];
int siz[200005], a[200005], b[200005], dele[200005], cnt, ans[200005];
void check(int u) {
if (siz[u] >= k || dele[u]) return;
cnt--;
dele[u] = 1;
queue<int> Q;
Q.push(u);
while (!Q.empty()) {
int ty = Q.front();
Q.pop();
for (set<int>::iterator i = M[ty].begin(); i != M[ty].end(); i++) {
int v = *i;
siz[v]--;
if (siz[v] < k && !dele[v]) {
cnt--;
Q.push(v);
dele[v] = 1;
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i], &b[i]);
M[a[i]].insert(b[i]);
M[b[i]].insert(a[i]);
siz[a[i]]++;
siz[b[i]]++;
}
cnt = n;
for (int i = 1; i <= n; i++) check(i);
ans[m] = cnt;
for (int i = m; i >= 2; i--) {
if (!dele[b[i]]) siz[a[i]]--;
if (!dele[a[i]]) siz[b[i]]--;
M[a[i]].erase(b[i]);
M[b[i]].erase(a[i]);
check(a[i]);
check(b[i]);
ans[i - 1] = cnt;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.*;
import java.lang.reflect.Field;
import java.util.*;
public class Main {
long MOD = (long) (1e9 + 7);
HashSet<Integer>[] graph;
static int[] deg;
int rem;
public static void main(String[] args) throws IOException {
Reader.init(System.in);
new Main();
}
Main() throws IOException {
solve();
}
void solve() throws IOException {
int n = Reader.nextInt();
int m = Reader.nextInt();
int k = Reader.nextInt();
int[] X = new int[m];
int[] Y = new int[m];
boolean[] del = new boolean[n];
Node[] arr = new Node[n];
deg = new int[n];
graph = new HashSet[n];
for(int i = 0; i < n; i++){graph[i] = new HashSet<>();}
for(int i = 0; i < m; i++){
int x = Reader.nextInt()-1;
int y = Reader.nextInt()-1;
X[i] = x;
Y[i] = y;
deg[x]++;deg[y]++;
graph[x].add(y);
graph[y].add(x);
}
List<Integer> gone = new ArrayList<>();
for(int i = 0; i < n; i++){
arr[i] = new Node(i,deg[i]);
if(deg[i] < k){del[i] = true; gone.add(i);}
}
while(gone.size() > 0){
int v = gone.remove(gone.size() - 1);
del[v] = true;
for(int ele : graph[v]){
if(!del[ele]) {
deg[ele]--;
if (deg[ele] < k) {
gone.add(ele);
del[ele] = true;
}
}
}
}
rem = 0;
for(int i = 0; i <n; i++){if(!del[i])rem++;}
int[] ans = new int[m+1];
for(int i = m-1; i >= 0; i--){
ans[i] = rem;
if(del[X[i]] && del[Y[i]]){ continue; }
if(!del[Y[i]]) deg[X[i]]--;
if(!del[X[i]]) deg[Y[i]]--;
graph[X[i]].remove((Integer) Y[i]);
graph[Y[i]].remove((Integer) X[i]);
if(!del[X[i]]){
if(deg[X[i]] < k){
remove(X[i],k,del);
}
}
if(!del[Y[i]]){
if(deg[Y[i]] < k){
remove(Y[i],k,del);
}
}
}
for(int i = 0; i < m; i++) System.out.println(ans[i]);
}
void remove(int u, int k, boolean[] del){
del[u] = true;
rem--;
for(int ele : graph[u]){
if(del[ele]) continue;
deg[ele]--;
if(deg[ele] < k){
remove(ele, k, del);
}
}
}
class Node{
int ind;
int deg;
Node(int i, int d){
ind = i;
deg = d;
}
}
}
class Reader {
static BufferedReader reader;
static StringTokenizer tokenizer;
/** call this method to initialize reader for InputStream */
static void init(InputStream input) {
reader = new BufferedReader(new InputStreamReader(input) );
tokenizer = new StringTokenizer("");
}
static String nextToken() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
static String next() throws IOException {
while ( ! tokenizer.hasMoreTokens() ) {
tokenizer = new StringTokenizer(
reader.readLine() );
}
return tokenizer.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt( next() );
}
static double nextDouble() throws IOException {
return Double.parseDouble( next() );
}
static long nextLong() {
return Long.parseLong(nextToken());
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int du[maxn];
set<int> g[maxn];
int b1[maxn], b2[maxn], ans[maxn], vis[maxn];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
set<pair<int, int> > s;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
b1[i] = x, b2[i] = y;
du[x]++, du[y]++;
g[x].insert(y);
g[y].insert(x);
}
for (int i = 1; i <= n; i++) s.insert(make_pair(du[i], i));
for (int i = m - 1; i >= 0; i--) {
while (s.size() >= 1) {
pair<int, int> itt = (*s.begin());
if (itt.first >= k) break;
for (set<int>::iterator it = g[itt.second].begin();
it != g[itt.second].end(); it++) {
int u = *it;
if (vis[u] == 1) continue;
s.erase(make_pair(du[u], u));
du[u]--;
s.insert(make_pair(du[u], u));
g[u].erase(itt.second);
}
s.erase(itt);
vis[itt.second] = 1;
}
ans[i] = s.size();
if (vis[b1[i]] == 0 && vis[b2[i]] == 0) {
s.erase(make_pair(du[b1[i]], b1[i]));
du[b1[i]]--;
s.insert(make_pair(du[b1[i]], b1[i]));
g[b1[i]].erase(b2[i]);
s.erase(make_pair(du[b2[i]], b2[i]));
du[b2[i]]--;
s.insert(make_pair(du[b2[i]], b2[i]));
g[b2[i]].erase(b1[i]);
}
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
/**
*
*/
public class E {
static LinkedList<Pair>[] g;
static int k;
static boolean[] s;
static int size;
static int[] degree;
static Queue<Integer> q = new LinkedList<>();
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(reader.readLine());
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());
k = Integer.parseInt(st.nextToken());
s = new boolean[n];
g = new LinkedList[n];
degree = new int[n];
int[][] f = new int[m][2];
for (int i = 0; i < m; i++) {
st = new StringTokenizer(reader.readLine());
int a = Integer.parseInt(st.nextToken())-1;
int b = Integer.parseInt(st.nextToken())-1;
if (g[a] == null) {
g[a] = new LinkedList<>();
}
if (g[b] == null) {
g[b] = new LinkedList<>();
}
g[a].add(new Pair(b,i));
g[b].add(new Pair(a,i));
degree[a]++;degree[b]++;
f[i][0] = a;
f[i][1] = b;
}
for (int i = 0; i < n; i++) {
if(degree[i]>0){
if(degree[i]>=k){
s[i] = true;
size ++;
}else{
q.add(i);
}
}
}
while (!q.isEmpty()){
int v = q.poll();
for (Pair u : g[v]) {
if(s[u.a]) {
degree[u.a]--;
if (degree[u.a] < k) {
q.add(u.a);
s[u.a] = false;
size--;
}
}
}
}
int[] ans = new int[m];
for (int i = m-1; i >=0; i--) {
ans[i] = size;
int a = f[i][0];
int b = f[i][1];
if(s[a] && s[b]) {
degree[a]--;degree[b]--;
if (degree[a] < k){
q.add(a);
s[a] = false;
size--;
}
if (degree[b] < k){
q.add(b);
s[b] = false;
size--;
}
while (!q.isEmpty()){
int v = q.poll();
for (Pair u : g[v]) {
if(u.b < i && s[u.a]) {
degree[u.a]--;
if (degree[u.a] < k) {
q.add(u.a);
s[u.a] = false;
size--;
}
}
}
}
}
}
for (int i = 0; i < m; i++) {
System.out.println(ans[i]);
}
}
static class Pair{
int a;
int b;
public Pair(int a, int b) {
this.a = a;
this.b = b;
}
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
template <typename T, typename T2>
inline void _max(T &a, T2 b) {
a = max((T)a, (T)b);
}
template <typename T, typename T2>
inline void _min(T &a, T2 b) {
a = min((T)a, (T)b);
}
const int MAX = 2e5 + 10;
int n, m, k;
set<int> g[MAX];
set<pair<int, int> > mm;
set<int> vs;
vector<pair<int, int> > es;
void removeEdge(int a, int b) {
mm.erase(mm.find({g[a].size(), a}));
g[a].erase(b);
mm.insert({g[a].size(), a});
}
void remove(int v) {
vs.erase(v);
set<int> nxt = g[v];
for (auto &to : nxt) {
removeEdge(to, v);
removeEdge(v, to);
}
}
void clear() {
for (int i = 0; i < MAX; i++) g[i].clear();
mm.clear();
vs.clear();
es.clear();
}
void read() {
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
g[a].insert(b);
g[b].insert(a);
es.push_back({a, b});
}
}
void solve() {
for (int i = 0; i < n; i++) vs.insert(i);
for (int i = 0; i < n; i++) mm.insert({g[i].size(), i});
while (!mm.empty() && mm.begin()->first < k) {
auto p = *mm.begin();
remove(p.second);
mm.erase(mm.begin());
}
vector<int> res;
for (int i = m - 1; i >= 0; i--) {
res.push_back(vs.size());
auto e = es[i];
int u = e.first, v = e.second;
if (vs.count(u) == 0 || vs.count(v) == 0) continue;
removeEdge(u, v);
removeEdge(v, u);
while (!mm.empty() && mm.begin()->first < k) {
auto p = *mm.begin();
remove(p.second);
mm.erase(mm.begin());
}
}
reverse(begin(res), end(res));
for (auto &x : res) printf("%d\n", x);
}
int main() {
while (scanf("%d%d%d", &n, &m, &k) == 3) {
clear();
read();
solve();
return 0;
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | 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);
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;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Arrays;
import java.io.FilterInputStream;
import java.io.BufferedInputStream;
import java.util.TreeSet;
import java.io.InputStream;
/**
* @author khokharnikunj8
*/
public class Main {
public static void main(String[] args) {
new Thread(null, new Runnable() {
public void run() {
new Main().solve();
}
}, "1", 1 << 26).start();
}
void solve() {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
ScanReader in = new ScanReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
ETrips solver = new ETrips();
solver.solve(1, in, out);
out.close();
}
static class ETrips {
int[][] G;
public void solve(int testNumber, ScanReader in, PrintWriter out) {
int n = in.scanInt();
int m = in.scanInt();
int k = in.scanInt();
TreeSet<pair> bstCustom = new TreeSet<>();
int from[] = new int[m];
int to[] = new int[m];
for (int i = 0; i < m; i++) {
from[i] = in.scanInt();
to[i] = in.scanInt();
}
int[] ans = new int[m];
G = CodeHash.packGraph(from, to, n);
int degree[] = new int[n + 1];
for (int i = 1; i <= n; i++) bstCustom.add(new pair(degree[i] = G[i].length, i));
boolean[] is_inside = new boolean[n + 1];
Arrays.fill(is_inside, true);
HashSet<Long> set = new HashSet<>();
while (bstCustom.size() > 0 && bstCustom.first().x < k) {
pair tt = bstCustom.first();
for (int i : G[tt.y]) {
if (is_inside[i]) {
if (set.contains(i * 1000000000l + tt.y) || set.contains(tt.y * 1000000000l + i))
continue;
bstCustom.remove(new pair(degree[i], i));
degree[i]--;
degree[tt.y]--;
bstCustom.add(new pair(degree[i], i));
set.add(i * 1000000000l + tt.y);
}
}
is_inside[tt.y] = false;
bstCustom.remove(tt);
}
ans[m - 1] = bstCustom.size();
for (int i = m - 1; i >= 1; i--) {
if (is_inside[from[i]] && is_inside[to[i]]) {
bstCustom.remove(new pair(degree[from[i]], from[i]));
degree[from[i]]--;
bstCustom.add(new pair(degree[from[i]], from[i]));
bstCustom.remove(new pair(degree[to[i]], to[i]));
degree[to[i]]--;
bstCustom.add(new pair(degree[to[i]], to[i]));
set.add(1000000000l * from[i] + to[i]);
}
while (bstCustom.size() > 0 && bstCustom.first().x < k) {
pair tt = bstCustom.first();
for (int j : G[tt.y]) {
if (is_inside[j]) {
if (set.contains(j * 1000000000l + tt.y) || set.contains(tt.y * 1000000000l + j))
continue;
bstCustom.remove(new pair(degree[j], j));
degree[j]--;
bstCustom.add(new pair(degree[j], j));
set.add(j * 1000000000l + tt.y);
}
}
is_inside[tt.y] = false;
bstCustom.remove(tt);
}
ans[i - 1] = bstCustom.size();
}
for (int i = 0; i < m; i++) out.println(ans[i]);
}
class pair implements Comparable<pair> {
int x;
int y;
public int compareTo(pair o) {
if (this.x == o.x) return this.y - o.y;
return this.x - o.x;
}
public pair(int x, int y) {
this.x = x;
this.y = y;
}
}
}
static class CodeHash {
public static int[][] packGraph(int[] from, int[] to, int n) {
int[][] g = new int[n + 1][];
int p[] = new int[n + 1];
for (int i : from) p[i]++;
for (int i : to) p[i]++;
for (int i = 0; i <= n; i++) g[i] = new int[p[i]];
for (int i = 0; i < from.length; i++) {
g[from[i]][--p[from[i]]] = to[i];
g[to[i]][--p[to[i]]] = from[i];
}
return g;
}
}
static class ScanReader {
private byte[] buf = new byte[4 * 1024];
private int index;
private BufferedInputStream in;
private int total;
public ScanReader(InputStream inputStream) {
in = new BufferedInputStream(inputStream);
}
private int scan() {
if (index >= total) {
index = 0;
try {
total = in.read(buf);
} catch (Exception e) {
e.printStackTrace();
}
if (total <= 0) return -1;
}
return buf[index++];
}
public int scanInt() {
int integer = 0;
int n = scan();
while (isWhiteSpace(n)) n = scan();
int neg = 1;
if (n == '-') {
neg = -1;
n = scan();
}
while (!isWhiteSpace(n)) {
if (n >= '0' && n <= '9') {
integer *= 10;
integer += n - '0';
n = scan();
}
}
return neg * integer;
}
private boolean isWhiteSpace(int n) {
if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
else return false;
}
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > adj;
set<long long> st;
vector<long long> deg;
long long k;
set<pair<long long, long long> > edges;
void remove(long long r) {
st.erase(r);
for (long long i = 0; i < adj[r].size(); i++) {
long long c = adj[r][i];
if (st.find(c) == st.end()) continue;
if (edges.find(make_pair(r, c)) == edges.end()) continue;
edges.erase(make_pair(r, c));
edges.erase(make_pair(c, r));
deg[c]--;
if (deg[c] < k) remove(c);
}
}
int main() {
ios_base::sync_with_stdio(false);
long long n, m;
cin >> n >> m >> k;
vector<long long> x(m);
vector<long long> y(m);
adj.resize(n);
deg.resize(n, 0);
for (long long i = 0; i < m; i++) {
cin >> x[i] >> y[i];
x[i]--;
y[i]--;
adj[x[i]].push_back(y[i]);
adj[y[i]].push_back(x[i]);
edges.insert(make_pair(x[i], y[i]));
edges.insert(make_pair(y[i], x[i]));
deg[x[i]]++;
deg[y[i]]++;
}
for (long long i = 0; i < n; i++) {
st.insert(i);
}
for (long long i = 0; i < n; i++) {
if (st.find(i) == st.end()) continue;
if (deg[i] < k) remove(i);
}
vector<long long> res;
res.push_back(st.size());
for (long long i = m - 1; i >= 1; i--) {
if (st.find(x[i]) == st.end() || st.find(y[i]) == st.end()) {
res.push_back(st.size());
continue;
}
edges.erase(make_pair(x[i], y[i]));
edges.erase(make_pair(y[i], x[i]));
deg[x[i]]--;
deg[y[i]]--;
if (deg[x[i]] < k) remove(x[i]);
if (st.find(y[i]) != st.end()) {
if (deg[y[i]] < k) remove(y[i]);
}
res.push_back(st.size());
}
reverse(res.begin(), res.end());
for (long long i = 0; i < res.size(); i++) {
cout << res[i] << endl;
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, m, k;
bool vis[N];
queue<int> Q;
set<int> G[N];
vector<int> E[N];
int a[N], b[N], ans[N], sum;
void solve() {
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (auto v : G[u]) {
G[v].erase(u);
if (!vis[v] && G[v].size() < k) {
sum--;
vis[v] = 1;
Q.push(v);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
sum = n;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i], &b[i]);
G[a[i]].insert(b[i]);
G[b[i]].insert(a[i]);
}
for (int i = 1; i <= n; i++) {
if (G[i].size() < k) {
Q.push(i);
vis[i] = true;
sum--;
}
}
solve();
ans[m] = sum;
for (int i = m; i > 1; i--) {
G[a[i]].erase(b[i]);
G[b[i]].erase(a[i]);
if (!vis[a[i]] && G[a[i]].size() < k) sum--, Q.push(a[i]), vis[a[i]] = 1;
if (!vis[b[i]] && G[b[i]].size() < k) sum--, Q.push(b[i]), vis[b[i]] = 1;
solve();
ans[i - 1] = sum;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i] > 0 ? ans[i] : 0);
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main(int agrc, char* argv[]) {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
std::vector<std::vector<int>> edges(n + 1);
int selected[n];
for (int i = 0; i < n; ++i) {
selected[i] = 1;
}
int total = n;
int friends[m][2];
for (int i = 0; i < m; ++i) {
scanf("%d %d", &friends[i][0], &friends[i][1]);
--friends[i][0];
--friends[i][1];
edges[friends[i][0]].push_back(friends[i][1]);
edges[friends[i][1]].push_back(friends[i][0]);
}
int friends_going[n];
for (int i = 0; i < n; ++i) {
friends_going[i] = edges[i].size();
}
for (int i = 0; i < n; ++i) {
std::stack<int> rejected;
rejected.push(i);
while (!rejected.empty()) {
int index = rejected.top();
rejected.pop();
if (!(selected[index] == 1 && friends_going[index] < k)) {
continue;
}
selected[index] = 0;
--total;
for (int j : edges[index]) {
--friends_going[j];
rejected.push(j);
}
}
}
int answer[m];
answer[m - 1] = total;
for (int i = m - 2; i >= 0; --i) {
int first = friends[i + 1][0], second = friends[i + 1][1];
edges[first].pop_back();
edges[second].pop_back();
if (selected[second] == 1) {
--friends_going[first];
}
if (selected[first]) {
--friends_going[second];
}
std::stack<int> rejected;
rejected.push(first);
rejected.push(second);
while (!rejected.empty()) {
int index = rejected.top();
rejected.pop();
if (!(selected[index] == 1 && friends_going[index] < k)) {
continue;
}
selected[index] = 0;
--total;
for (int j : edges[index]) {
--friends_going[j];
rejected.push(j);
}
}
answer[i] = total;
}
for (int i = 0; i < m; i++) {
printf("%d\n", answer[i]);
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.*;
import java.util.*;
public class A {
public static void main (String[] args) { new A(); }
int curSize;
boolean[] killed;
A() {
FastScanner s = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
System.err.println("");
int n = s.nextInt();
int m = s.nextInt();
int k = s.nextInt();
killed = new boolean[m];
ArrayList<int[]>[] adj = new ArrayList[n];
for(int i = 0; i < n; i++) adj[i] = new ArrayList<>();
int[][] edges = new int[m][2];
int[] deg = new int[n];
for(int i = 0; i < m; i++) {
int u = edges[i][0] = s.nextInt()-1;
int v = edges[i][1] = s.nextInt()-1;
adj[u].add(new int[] {v, i}); adj[v].add(new int[] {u, i});
deg[u]++; deg[v]++;
}
boolean[] dead = new boolean[n];
for(int i = 0; i < n; i++) if(deg[i] < k) dead[i] = true;
int[] initMark = new int[n];
for(int i = 0; i < n; i++) {
if(dead[i]) continue;
for(int[] v : adj[i]) if(!dead[v[0]]) initMark[i]++;
}
ArrayDeque<Integer> dq = new ArrayDeque<>();
for(int i = 0; i < n; i++) {
if(!dead[i] && initMark[i] < k) {
flood(i, k, dead, adj, initMark, dq);
}
}
int[] conTo = new int[n];
for(int i = 0; i < n; i++) {
if(dead[i]) continue;
for(int[] v : adj[i]) {
if(!dead[v[0]]) conTo[i]++;
}
}
for(int i = 0; i < n; i++) {
if(dead[i]) continue;
if(conTo[i] < k) {
flood(i, k, dead, adj, conTo, dq);
}
}
curSize = 0;
for(int i = 0; i < n; i++) if(!dead[i]) curSize++;
int[] res = new int[m];
res[m-1] = curSize;
for(int i = m-1; i > 0; i--) {
int u = edges[i][0], v = edges[i][1];
if(dead[u] || dead[v] || killed[i]) {
res[i-1] = curSize;
continue;
}
conTo[u]--; conTo[v]--;
killed[i] = true;
if(conTo[u] < k) flood(u, k, dead, adj, conTo, dq);
if(conTo[v] < k) flood(v, k, dead, adj, conTo, dq);
res[i-1] = curSize;
}
for(int i : res) out.println(i);
out.close();
}
void flood(int i, int k, boolean[] dead, ArrayList<int[]>[] adj, int[] cnt, ArrayDeque<Integer> dq) {
if(dead[i]) return;
dead[i] = true;
dq.add(i);
while(!dq.isEmpty()) {
curSize--;
int u = dq.pollFirst();
for(int[] e : adj[u]) {
int v = e[0], id = e[1];
if(dead[v] || killed[id]) continue;
killed[id] = true;
cnt[v]--;
if(cnt[v] < k) {
dead[v] = true;
dq.add(v);
}
}
}
}
class FastScanner {
public int BS = 1<<16;
public char NC = (char)0;
byte[] buf = new byte[BS];
int bId = 0, size = 0;
char c = NC;
double num = 1;
BufferedInputStream in;
public FastScanner() {
in = new BufferedInputStream(System.in, BS);
}
public FastScanner(String s) {
try {
in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
}
catch (Exception e) {
in = new BufferedInputStream(System.in, BS);
}
}
public char nextChar(){
while(bId==size) {
try {
size = in.read(buf);
}catch(Exception e) {
return NC;
}
if(size==-1)return NC;
bId=0;
}
return (char)buf[bId++];
}
public int nextInt() {
return (int)nextLong();
}
public long nextLong() {
num=1;
boolean neg = false;
if(c==NC)c=nextChar();
for(;(c<'0' || c>'9'); c = nextChar()) {
if(c=='-')neg=true;
}
long res = 0;
for(; c>='0' && c <='9'; c=nextChar()) {
res = (res<<3)+(res<<1)+c-'0';
num*=10;
}
return neg?-res:res;
}
public double nextDouble() {
double cur = nextLong();
return c!='.' ? cur:cur+nextLong()/num;
}
public String next() {
StringBuilder res = new StringBuilder();
while(c<=32)c=nextChar();
while(c>32) {
res.append(c);
c=nextChar();
}
return res.toString();
}
public String nextLine() {
StringBuilder res = new StringBuilder();
while(c<=32)c=nextChar();
while(c!='\n') {
res.append(c);
c=nextChar();
}
return res.toString();
}
public boolean hasNext() {
if(c>32)return true;
while(true) {
c=nextChar();
if(c==NC)return false;
else if(c>32)return true;
}
}
public int[] nextIntArray(int n) {
int[] res = new int[n];
for(int i = 0; i < n; i++) res[i] = nextInt();
return res;
}
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
const int LIM = 600;
int N, M, K;
cin >> N >> M >> K;
vector<int> x(M), y(M);
vector<vector<int> > g(N);
for (int i = 0; i < M; i++) {
cin >> x[i] >> y[i];
g[--x[i]].push_back(i);
g[--y[i]].push_back(i);
}
vector<int> deg(N);
for (int i = 0; i < N; i++) deg[i] = g[i].size();
vector<bool> del(N, false);
vector<bool> live(M, true);
int alive = N;
vector<int> ans(M);
auto bfs = [&](int v) {
if (deg[v] >= K || del[v]) return;
queue<int> rem;
rem.push(v);
del[v] = true;
alive--;
while (!rem.empty()) {
int nxt = rem.front();
rem.pop();
for (int e : g[nxt]) {
if (!live[e]) continue;
live[e] = false;
int nbr = x[e] + y[e] - nxt;
deg[nbr]--;
if (!del[nbr] && deg[nbr] < K) {
del[nbr] = true;
alive--;
rem.push(nbr);
}
}
}
};
for (int i = 0; i < N; i++) {
bfs(i);
}
for (int i = M - 1; i >= 0; i--) {
ans[i] = alive;
if (live[i]) {
live[i] = false;
deg[x[i]]--;
deg[y[i]]--;
bfs(x[i]);
bfs(y[i]);
}
}
for (int i = 0; i < M; i++) cout << ans[i] << "\n";
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
bool Finish_read;
template <class T>
inline void read(T &x) {
Finish_read = 0;
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
Finish_read = 1;
}
template <class T>
inline void print(T x) {
if (x / 10 != 0) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void writeln(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
putchar('\n');
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
}
const int maxn = 200005;
set<int> G[maxn];
queue<int> q;
int n, m, k, u[maxn], v[maxn], d[maxn], vis[maxn];
vector<int> res;
inline void calc() {
int tmp = n;
for (int i = m; i; --i) {
while (!q.empty()) {
int x = q.front();
q.pop();
--tmp;
for (int y : G[x]) {
if (G[y].find(x) == G[y].end()) continue;
G[y].erase(x);
d[y]--;
if (d[y] < k && !vis[y]) q.push(y), vis[y] = 1;
}
}
res.push_back(tmp);
int x = u[i], y = v[i];
if (G[x].find(y) == G[x].end()) goto nxt;
G[x].erase(y);
--d[x];
if (d[x] < k && !vis[x]) q.push(x), vis[x] = 1;
nxt:;
if (G[y].find(x) == G[y].end()) continue;
G[y].erase(x);
--d[y];
if (d[y] < k && !vis[y]) q.push(y), vis[y] = 1;
}
}
inline void input() {
read(n), read(m), read(k);
for (int i = 1; i <= m; ++i) {
read(u[i]), read(v[i]);
G[u[i]].insert(v[i]);
G[v[i]].insert(u[i]);
d[u[i]]++, d[v[i]]++;
}
}
int main() {
input();
for (int i = 1; i <= n; ++i)
if (d[i] < k) q.push(i), vis[i] = 1;
calc();
for (int i = 0; i < (int)res.size(); ++i)
printf("%d\n", res[res.size() - i - 1]);
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.*;
import java.util.*;
public class Mainn {
FastReader scn;
PrintWriter out;
String INPUT = "";
void solve() {
int n = scn.nextInt(), m = scn.nextInt(), k = scn.nextInt();
int[] from = new int[m], to = new int[m], w = new int[m];
for (int i = 0; i < m; i++) {
from[i] = scn.nextInt() - 1;
to[i] = scn.nextInt() - 1;
w[i] = i;
}
int[][][] g = packWU(n, from, to, w);
int[] deg = new int[n], q = new int[n];
int qp = 0, st = 0;
for (int i = 0; i < n; i++) {
deg[i] = g[i].length;
if (deg[i] < k) {
q[qp++] = i;
}
}
boolean[] step = new boolean[m];
int[] ans = new int[m];
for (int i = m - 1; i >= 0; i--) {
while (st < qp) {
for (int[] v : g[q[st]]) {
if (!step[v[1]]) {
step[v[1]] = true;
if (deg[v[0]] == k) {
q[qp++] = v[0];
}
deg[v[0]]--;
deg[q[st]]--;
}
}
st++;
}
ans[i] = n - qp;
if (!step[i]) {
step[i] = true;
if (deg[to[i]] == k) {
q[qp++] = to[i];
}
if (deg[from[i]] == k) {
q[qp++] = from[i];
}
deg[to[i]]--;
deg[from[i]]--;
}
}
for (int i = 0; i < m; i++) {
out.println(ans[i]);
}
}
int[][][] packWU(int n, int[] from, int[] to, int[] w) {
n++;
int[][][] g = new int[n][][];
int[] p = new int[n];
for (int f : from)
p[f]++;
for (int t : to)
p[t]++;
for (int i = 0; i < n; i++)
g[i] = new int[p[i]][2];
for (int i = 0; i < from.length; i++) {
--p[from[i]];
g[from[i]][p[from[i]]][0] = to[i];
g[from[i]][p[from[i]]][1] = w[i];
--p[to[i]];
g[to[i]][p[to[i]]][0] = from[i];
g[to[i]][p[to[i]]][1] = w[i];
}
return g;
}
void run() throws Exception {
long time = System.currentTimeMillis();
boolean oj = System.getProperty("ONLINE_JUDGE") != null;
out = new PrintWriter(System.out);
scn = new FastReader(oj);
solve();
out.flush();
if (!oj) {
System.out.println(Arrays.deepToString(new Object[] { System.currentTimeMillis() - time + " ms" }));
}
}
public static void main(String[] args) throws Exception {
new Mainn().run();
}
class FastReader {
InputStream is;
public FastReader(boolean onlineJudge) {
is = onlineJudge ? System.in : new ByteArrayInputStream(INPUT.getBytes());
}
byte[] inbuf = new byte[1024];
public int lenbuf = 0, ptrbuf = 0;
int readByte() {
if (lenbuf == -1)
throw new InputMismatchException();
if (ptrbuf >= lenbuf) {
ptrbuf = 0;
try {
lenbuf = is.read(inbuf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return -1;
}
return inbuf[ptrbuf++];
}
boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
int skip() {
int b;
while ((b = readByte()) != -1 && isSpaceChar(b))
;
return b;
}
double nextDouble() {
return Double.parseDouble(next());
}
char nextChar() {
return (char) skip();
}
String next() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
String nextLine() {
int b = skip();
StringBuilder sb = new StringBuilder();
while ((!isSpaceChar(b) || b == ' ')) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
char[] next(int n) {
char[] buf = new char[n];
int b = skip(), p = 0;
while (p < n && !(isSpaceChar(b))) {
buf[p++] = (char) b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
int nextInt() {
int num = 0, b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = num * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
long nextLong() {
long num = 0;
int b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = num * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
char[][] nextMatrix(int n, int m) {
char[][] map = new char[n][];
for (int i = 0; i < n; i++)
map[i] = next(m);
return map;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
int[][] next2DInt(int n, int m) {
int[][] arr = new int[n][];
for (int i = 0; i < n; i++) {
arr[i] = nextIntArray(m);
}
return arr;
}
long[][] next2DLong(int n, int m) {
long[][] arr = new long[n][];
for (int i = 0; i < n; i++) {
arr[i] = nextLongArray(m);
}
return arr;
}
int[] shuffle(int[] arr) {
Random r = new Random();
for (int i = 1, j; i < arr.length; i++) {
j = r.nextInt(i);
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
return arr;
}
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.util.*;
import java.io.*;
public class Main {
public static void main(String args[]) {new Main().run();}
FastReader in = new FastReader();
PrintWriter out = new PrintWriter(System.out);
void run(){
work();
out.flush();
}
long mod=1000000007;
long gcd(long a,long b) {
return b==0?a:gcd(b,a%b);
}
Set<Integer>[] graph;
void work() {
int n=in.nextInt();
int m=in.nextInt();
int k=in.nextInt();
int[] degree=new int[n];
int[][] edge=new int[m][2];
int[] ret=new int[m];
graph=(Set<Integer>[])new Set[n];
for(int i=0;i<n;i++)graph[i]=new HashSet<>();
for(int i=0;i<m;i++) {
int n1=in.nextInt()-1;
int n2=in.nextInt()-1;
edge[i]=new int[] {n1,n2};
graph[n1].add(n2);
graph[n2].add(n1);
degree[n1]++;
degree[n2]++;
}
int cnt=n;
LinkedList<Integer> queue=new LinkedList<>();
boolean[] vis=new boolean[n];
for(int i=0;i<n;i++) {
if(degree[i]==0)cnt--;
else if(degree[i]<k) {
queue.add(i);
vis[i]=true;
}
}
for(int i=m-1;i>=0;i--) {
while(queue.size()>0) {
int node=queue.poll();
cnt--;
degree[node]=0;
for(int nn:graph[node]) {
if(vis[nn])continue;
degree[nn]--;
graph[nn].remove(node);
if(degree[nn]<k) {
queue.add(nn);
vis[nn]=true;
}
}
graph[node]=new HashSet<>();
}
ret[i]=cnt;
int[] e=edge[i];
if(!graph[e[0]].contains(e[1]))continue;
degree[e[0]]--;
if(degree[e[0]]<k) {
queue.add(e[0]);
vis[e[0]]=true;
}
degree[e[1]]--;
if(degree[e[1]]<k) {
queue.add(e[1]);
vis[e[1]]=true;
}
graph[e[0]].remove(e[1]);
graph[e[1]].remove(e[0]);
}
for(int i=0;i<m;i++)out.println(ret[i]);
}
}
class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br=new BufferedReader(new InputStreamReader(System.in));
}
public String next()
{
if(st==null || !st.hasMoreElements())
{
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
public int nextInt()
{
return Integer.parseInt(next());
}
public long nextLong()
{
return Long.parseLong(next());
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | /**
* BaZ :D
*/
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main
{
static Reader scan;
static PrintWriter pw;
static HashSet<Integer> good;
static HashSet<Integer> adj[];
static int n,m,k,ans[];
public static void main(String[] args) {
new Thread(null,null,"BaZ",1<<25)
{
public void run()
{
try
{
solve();
}
catch(Exception e)
{
e.printStackTrace();
System.exit(1);
}
}
}.start();
}
static void solve() throws IOException
{
scan = new Reader();
pw = new PrintWriter(System.out,true);
StringBuilder sb = new StringBuilder();
n = ni();
m = ni();
k = ni();
good = new HashSet();
adj = new HashSet[n+1];
for(int i=1;i<=n;++i)
{
good.add(i);
adj[i] = new HashSet();
}
int x[] = new int[m];
int y[] = new int[m];
for(int i=0;i<m;++i) {
int u = ni();
int v = ni();
x[i] = u;
y[i] = v;
adj[u].add(v);
adj[v].add(u);
}
ans = new int[m];
ArrayList<Integer> bad = new ArrayList();
for(int i=1;i<=n;++i) {
if(adj[i].size()<k) {
bad.add(i);
}
}
for(int e:bad)
{
if(good.contains(e))
remove(e);
}
ans[m-1] = good.size();
for(int i=m-2;i>=0;--i) {
int u = x[i+1];
int v = y[i+1];
adj[u].remove(v);
adj[v].remove(u);
if(adj[u].size()<k && good.contains(u))
remove(u);
if(adj[v].size()<k && good.contains(v))
remove(v);
ans[i] = good.size();
}
for(int e:ans) {
sb.append(e);
sb.append("\n");
}
psb(sb);
pw.flush();
pw.close();
}
static void remove(int x) {
good.remove(x);
ArrayList<Integer> bad = new ArrayList();
for(int e:adj[x]) {
adj[e].remove(x);
if(adj[e].size()<k)
bad.add(e);
}
for(int e:bad)
remove(e);
adj[x].clear();
}
static int ni() throws IOException
{
return scan.nextInt();
}
static long nl() throws IOException
{
return scan.nextLong();
}
static double nd() throws IOException
{
return scan.nextDouble();
}
static void pl()
{
pw.println();
}
static void p(Object o)
{
pw.print(o+" ");
}
static void pl(Object o)
{
pw.println(o);
}
static void psb(StringBuilder sb)
{
pw.print(sb);
}
static void pa(String arrayName, Object arr[])
{
pl(arrayName+" : ");
for(Object o : arr)
p(o);
pl();
}
static void pa(String arrayName, int arr[])
{
pl(arrayName+" : ");
for(int o : arr)
p(o);
pl();
}
static void pa(String arrayName, long arr[])
{
pl(arrayName+" : ");
for(long o : arr)
p(o);
pl();
}
static void pa(String arrayName, double arr[])
{
pl(arrayName+" : ");
for(double o : arr)
p(o);
pl();
}
static void pa(String arrayName, char arr[])
{
pl(arrayName+" : ");
for(char o : arr)
p(o);
pl();
}
static void pa(String listName, List<Object> list)
{
pl(listName+" : ");
for(Object o : list)
p(o);
pl();
}
static void pa(String arrayName, Object[][] arr) {
pl(arrayName+" : ");
for(int i=0;i<arr.length;++i) {
for(Object o : arr[i])
p(o);
pl();
}
}
static void pa(String arrayName, int[][] arr) {
pl(arrayName+" : ");
for(int i=0;i<arr.length;++i) {
for(int o : arr[i])
p(o);
pl();
}
}
static void pa(String arrayName, long[][] arr) {
pl(arrayName+" : ");
for(int i=0;i<arr.length;++i) {
for(long o : arr[i])
p(o);
pl();
}
}
static void pa(String arrayName, char[][] arr) {
pl(arrayName+" : ");
for(int i=0;i<arr.length;++i) {
for(char o : arr[i])
p(o);
pl();
}
}
static void pa(String arrayName, double[][] arr) {
pl(arrayName+" : ");
for(int i=0;i<arr.length;++i) {
for(double o : arr[i])
p(o);
pl();
}
}
static class Reader {
final private int BUFFER_SIZE = 1 << 16;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Reader() {
din = new DataInputStream(System.in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public Reader(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {
byte[] buf = new byte[64];
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
public int nextInt() throws IOException {
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public long nextLong() throws IOException {
long ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (neg) return -ret;
return ret;
}
public double nextDouble() throws IOException {
double ret = 0, div = 1;
byte c = read();
while (c <= ' ') c = read();
boolean neg = (c == '-');
if (neg) c = read();
do {
ret = ret * 10 + c - '0';
} while ((c = read()) >= '0' && c <= '9');
if (c == '.') while ((c = read()) >= '0' && c <= '9') ret += (c - '0') / (div *= 10);
if (neg) return -ret;
return ret;
}
private void fillBuffer() throws IOException {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) buffer[0] = -1;
}
private byte read() throws IOException {
if (bufferPointer == bytesRead) fillBuffer();
return buffer[bufferPointer++];
}
public void close() throws IOException {
if (din == null) return;
din.close();
}
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, m, k, numOn, res[200000];
set<int> f[200000];
bool on[200000];
vector<pair<int, int> > v;
queue<int> toRemove;
void update() {
while (!toRemove.empty()) {
int r = toRemove.front();
toRemove.pop();
numOn--;
for (auto next : f[r]) {
f[next].erase(r);
if (on[next] && ((int)(f[next]).size()) < k) {
on[next] = 0;
toRemove.push(next);
}
}
f[r].clear();
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < (m); i++) {
int x, y;
cin >> x >> y;
x--, y--;
v.push_back(make_pair(x, y));
f[x].insert(y), f[y].insert(x);
}
for (int i = 0; i < (n); i++) on[i] = 1;
numOn = n;
for (int i = 0; i < (n); i++)
if (((int)(f[i]).size()) < k) {
on[i] = 0;
toRemove.push(i);
}
update();
res[m - 1] = numOn;
for (int i = (m)-1; i >= (1); i--) {
int x = v[i].first, y = v[i].second;
f[x].erase(y), f[y].erase(x);
if (on[x] && ((int)(f[x]).size()) < k) {
on[x] = 0;
toRemove.push(x);
}
if (on[y] && ((int)(f[y]).size()) < k) {
on[y] = 0;
toRemove.push(y);
}
update();
res[i - 1] = numOn;
}
for (int i = 0; i < (m); i++) cout << res[i] << "\n";
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Iterator;
import java.io.IOException;
import java.util.AbstractSequentialList;
import java.io.InputStreamReader;
import java.util.TreeSet;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.util.LinkedList;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Asgar Javadov
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskE solver = new TaskE();
solver.solve(1, in, out);
out.close();
}
static class TaskE {
int k;
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n = in.nextInt();
int m = in.nextInt();
k = in.nextInt();
LinkedList<Integer>[] adj = new LinkedList[n];
IntPair[] degree = new IntPair[n];
for (int i = 0; i < n; i++) {
degree[i] = IntPair.newPair(0, i);
adj[i] = new LinkedList<>();
}
int[] u = new int[m];
int[] v = new int[m];
for (int i = 0; i < m; ++i) {
u[i] = in.nextInt() - 1;
v[i] = in.nextInt() - 1;
adj[u[i]].add(i);
adj[v[i]].add(i);
degree[u[i]].first++;
degree[v[i]].first++;
}
TreeSet<IntPair> set = new TreeSet<>();
for (int i = 0; i < n; i++) {
set.add(degree[i]);
}
boolean[] alive = ArrayUtils.createArray(n, true);
while (!set.isEmpty() && set.first().first < k) {
IntPair pair = set.first();
for (Iterator<Integer> it = adj[pair.second].iterator(); it.hasNext(); ) {
int edge = it.next();
int e = v[edge] == pair.second ? u[edge] : v[edge];
set.remove(degree[e]);
degree[e].first--;
set.add(degree[e]);
it.remove();
}
set.remove(pair);
alive[pair.second] = false;
}
int[] result = new int[m];
for (int i = m - 1; i >= 0; --i) {
result[i] = set.size();
if (alive[u[i]] && alive[v[i]]) {
set.remove(degree[u[i]]);
degree[u[i]].first--;
set.add(degree[u[i]]);
set.remove(degree[v[i]]);
degree[v[i]].first--;
set.add(degree[v[i]]);
while (!set.isEmpty() && set.first().first < k) {
IntPair pair = set.first();
// for (int e : graph.getEdgesFrom(pair.second)) if (alive[e] && !(e == u[i] && pair.second == v[i]) && !(e == v[i] && pair.second == u[i])) {
for (Iterator<Integer> it = adj[pair.second].iterator(); it.hasNext(); ) {
int edge = it.next();
it.remove();
if (edge < i) {
int e = v[edge] == pair.second ? u[edge] : v[edge];
if (!alive[e]) continue;
set.remove(degree[e]);
degree[e].first--;
set.add(degree[e]);
}
}
set.remove(pair);
alive[pair.second] = false;
}
}
}
for (int e : result)
out.println(e);
}
}
static class InputReader extends BufferedReader {
StringTokenizer tokenizer;
public InputReader(InputStream inputStream) {
super(new InputStreamReader(inputStream), 32768);
}
public InputReader(String filename) {
super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(readLine());
} catch (IOException e) {
throw new RuntimeException();
}
}
return tokenizer.nextToken();
}
public Integer nextInt() {
return Integer.valueOf(next());
}
}
static class IntPair implements Comparable<IntPair> {
public int first;
public int second;
public IntPair(int first, int second) {
this.first = first;
this.second = second;
}
public int compareTo(IntPair o) {
if (first != o.first)
return Integer.compare(first, o.first);
return Integer.compare(second, o.second);
}
public static IntPair newPair(int first, int second) {
return new IntPair(first, second);
}
public String toString() {
return "" + first + " " + second;
// return String.format("{" + first + ", " + second + '}');
}
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof IntPair)) return false;
IntPair intPair = (IntPair) o;
return first == intPair.first &&
second == intPair.second;
}
public int hashCode() {
return (31 * first + second);
}
}
static class OutputWriter extends PrintWriter {
public OutputWriter(OutputStream outputStream) {
super(outputStream);
}
public OutputWriter(Writer writer) {
super(writer);
}
public OutputWriter(String filename) throws FileNotFoundException {
super(filename);
}
public void close() {
super.close();
}
}
static class ArrayUtils {
public static boolean[] createArray(int count, boolean value) {
boolean[] array = new boolean[count];
Arrays.fill(array, value);
return array;
}
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const long long N = 5e5;
const long long INF = 1e18;
const long long mod = 1e9 + 7;
set<long long> g[N], st;
long long i, j, n, m, k, ans[N], u[N], v[N];
void dfs(long long x) {
auto it = st.lower_bound(x);
if (*it != x || g[x].size() >= k) return;
st.erase(it);
for (auto to : g[x]) {
g[to].erase(x);
dfs(to);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (i = 0; i < m; ++i) {
cin >> u[i] >> v[i];
g[u[i]].insert(v[i]);
g[v[i]].insert(u[i]);
}
for (i = 1; i <= n; ++i) st.insert(i);
for (i = 1; i <= n; ++i) dfs(i);
for (i = m - 1; i >= 0; --i) {
long long x = u[i], y = v[i];
ans[i] = st.size();
g[x].erase(y);
g[y].erase(x);
dfs(x);
dfs(y);
}
for (i = 0; i < m; ++i) cout << ans[i] << "\n";
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.*;
import java.util.*;
import java.util.stream.IntStream;
public class E2 {
public static void main(String[] args) throws IOException {
E2 runner = new E2();
runner.run();
runner.close();
}
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
StringTokenizer st;
void close() throws IOException {
input.close();
output.flush();
output.close();
}
void read() {
try {
st = new StringTokenizer(input.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
int getInt() {
return Integer.parseInt(st.nextToken());
}
void run()throws IOException {
read();
int n = getInt();
int m = getInt();
int k = getInt();
int[] friends = new int[n+1];
int[] days1 = new int[m];
int[] days2 = new int[m];
Stack<Integer>[] links = new Stack[n+1];
IntStream.rangeClosed(1, n).forEach(i -> links[i] = new Stack<>());
IntStream.range(0, m).forEach(i -> {
read();
int s = getInt();
int f = getInt();
days1[i] = s;
days2[i] = f;
links[s].add(f);
links[f].add(s);
friends[s]++;
friends[f]++;
});
int count = n;
boolean[] going = new boolean[n+1];
IntStream.rangeClosed(1, n).forEach(i -> going[i] = true);
Set<Integer> toRemove = new LinkedHashSet<>();
IntStream.rangeClosed(1, n).forEach(i -> {
if (friends[i] < k)
toRemove.add(i);
});
int[] res = new int[m];
for (int d = m-1; d >= 0; d--) {
while (!toRemove.isEmpty()) {
int r = toRemove.iterator().next();
toRemove.remove(r);
count -= 1;
going[r] = false;
links[r].forEach(o -> {
if (going[o]) {
friends[o]--;
if (friends[o] < k)
toRemove.add(o);
}
});
}
res[d] = count;
int s = days1[d];
int f = days2[d];
links[s].pop();
links[f].pop();
if (going[s] & going[f]) {
friends[s]--;
friends[f]--;
if (friends[s] < k)
toRemove.add(s);
if (friends[f] < k)
toRemove.add(f);
}
}
for (int r : res) {
output.write(String.valueOf(r));
output.newLine();
}
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | //package sumo;
import java.io.*;
import java.util.*;
public class Tester {
static TreeSet<Integer> tr[];
static int k,n,m,cnt=0;
static Queue<Integer> q;
static TreeSet<Integer>glo;
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
FastReader s=new FastReader();
BufferedWriter log = new BufferedWriter(new OutputStreamWriter(System.out));
n=s.nextInt();
m=s.nextInt();
k=s.nextInt();
Edge e[]=new Edge[m+1];
tr=new TreeSet[n+1];
for(int j=1;j<=n;j++)
tr[j]=new TreeSet<Integer>();
glo=new TreeSet<Integer>();
for(int j=1;j<=n;j++)
glo.add(j);
int x,y;
for(int j=1;j<=m;j++)
{
x=s.nextInt();
y=s.nextInt();
e[j]=new Edge(x,y);
tr[x].add(y);
tr[y].add(x);
}
int ans=0;
for(int j=1;j<=n;j++)
{
if(tr[j].size()<k)
reduce(j);
}
/*
for(int j=1;j<=n;j++)
{
if(tr[j].size()>=k)
ans++;
}*/
//System.out.println(ans);
int fri[]=new int[m+1];
int ind;
fri[m]=glo.size();
ind=m-1;
for(int j=m;j>1;j--)
{
x=e[j].x;
y=e[j].y;
//cnt=0;
if(tr[x].contains(y) && tr[y].contains(x))
{
//System.out.println("hiii");
tr[x].remove(y);
tr[y].remove(x);
if(glo.contains(x) && tr[x].size()<k)
reduce(x);
if(glo.contains(y) && tr[y].size()<k)
reduce(y);
fri[ind--]=glo.size();
if(glo.size()==0)
break;
}
else
{
//System.out.println("hello");
fri[ind--]=glo.size();
}
// System.out.println(glo.toString());
}
for(int j=1;j<=m;j++)
log.write(fri[j]+"\n");
log.flush();
}
public static void reduce(int x)
{
//cnt++;
int get;glo.remove(x);
while(tr[x].size()>0)
{
get=tr[x].first();
tr[get].remove(x);
tr[x].remove(get);
if( glo.contains(get) && tr[get].size()<k)
reduce(get);
}
}
}
class Edge
{
int x;
int y;
public Edge(int x,int y)
{
this.x=x;
this.y=y;
}
}
class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | python2 |
import sys
range = xrange
n,m,k = [int(x) for x in sys.stdin.readline().split()]
inp = [int(x)-1 for x in sys.stdin.read().split()]
ii = 0
coupl = [[] for _ in range(n)]
time = [[] for _ in range(n)]
nfr = [0]*n
for i in range(m):
a,b = inp[ii],inp[ii+1]
ii += 2
coupl[a].append(b)
coupl[b].append(a)
time[a].append(i)
time[b].append(i)
nfr[a] += 1
nfr[b] += 1
notf = 0
rem = [i for i in range(n) if nfr[i]<k]
while rem:
node = rem.pop()
notf += 1
for nei in coupl[node]:
if nfr[nei]==k:
rem.append(nei)
nfr[nei]-=1
out = []
for j in reversed(range(m)):
out.append(n-notf)
a,b = inp[j*2],inp[j*2+1]
nfra = nfr[a]
nfrb = nfr[b]
if nfra>=k:
if nfrb==k:
rem.append(b)
nfr[b]-=1
if nfrb>=k:
if nfra==k:
rem.append(a)
nfr[a]-=1
while rem:
node = rem.pop()
notf += 1
for i in range(len(coupl[node])):
nei = coupl[node][i]
t = time[node][i]
if t<j:
if nfr[nei]==k:
rem.append(nei)
nfr[nei]-=1
print '\n'.join(str(x) for x in reversed(out)) |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.*;
import java.util.*;
public class Trips {
public static void main(String[] args) {
FastScanner scan=new FastScanner();
PrintWriter out=new PrintWriter(System.out);
int n=scan.nextInt(), m=scan.nextInt();
k=scan.nextInt();
deg=new int[n];
a=new ArrayList[n];
for(int i=0;i<n;i++) a[i]=new ArrayList<>();
int[] u=new int[m], v=new int[m];
for(int i=0;i<m;i++) {
u[i]=scan.nextInt()-1;
v[i]=scan.nextInt()-1;
a[u[i]].add(new edge(i,v[i]));
a[v[i]].add(new edge(i,u[i]));
deg[u[i]]++;
deg[v[i]]++;
}
left=n;
ind=m;
// System.out.println(Arrays.toString(deg));
bad=new boolean[n];
for(int i=0;i<n;i++) {
if(deg[i]<k&&!bad[i]) {
go(i);
// System.out.println(Arrays.toString(deg));
// System.out.println(left);
// System.out.println(Arrays.toString(bad));
}
}
int[] res=new int[m];
res[m-1]=left;
for(ind=m-1;ind>0;ind--) {
if(!bad[v[ind]]) deg[u[ind]]--;
if(!bad[u[ind]]) deg[v[ind]]--;
if(!bad[v[ind]]&°[v[ind]]<k) {
go(v[ind]);
}
if(!bad[u[ind]]&°[u[ind]]<k) {
go(u[ind]);
}
res[ind-1]=left;
// System.out.println(Arrays.toString(deg));
}
for(int i:res) out.println(i);
out.close();
}
static int left,ind;
static boolean[] bad;
static int[] deg;
static ArrayList<edge>[] a;
static int k;
public static void go(int at) {
bad[at]=true;
ArrayDeque<Integer> q=new ArrayDeque<>();
left--;
q.offer(at);
while(!q.isEmpty()) {
int c=q.poll();
for(edge nxt:a[c]) {
if(nxt.id>=ind) continue;
if(!bad[nxt.v]&&--deg[nxt.v]<k) {
q.offer(nxt.v);
bad[nxt.v]=true;
left--;
}
}
}
}
static class edge {
int id,v;
edge(int id, int v) {
this.id=id;
this.v=v;
}
}
/*
5 4 2
1 2
2 3
3 4
4 5
*/
static class FastScanner {
BufferedReader br;
StringTokenizer st;
public FastScanner() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
st = new StringTokenizer(br.readLine());
} catch (Exception e){e.printStackTrace();}
}
public String next() {
if (st.hasMoreTokens()) return st.nextToken();
try {st = new StringTokenizer(br.readLine());}
catch (Exception e) {e.printStackTrace();}
return st.nextToken();
}
public int nextInt() {return Integer.parseInt(next());}
public long nextLong() {return Long.parseLong(next());}
public double nextDouble() {return Double.parseDouble(next());}
public String nextLine() {
String line = "";
if(st.hasMoreTokens()) line = st.nextToken();
else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
while(st.hasMoreTokens()) line += " "+st.nextToken();
return line;
}
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Stack;
import java.util.TreeSet;
/**
* Created by himanshubhardwaj on 04/09/18.
*/
public class AllVertecesWithMinimimKRemainingdegree {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str[] = br.readLine().split(" ");
int n = Integer.parseInt(str[0]);
int m = Integer.parseInt(str[1]);
int k = Integer.parseInt(str[2]);
Graph g = new Graph(n, m);
for (int i = 0; i < m; i++) {
str = br.readLine().split(" ");
int s = Integer.parseInt(str[0]) - 1;
int d = Integer.parseInt(str[1]) - 1;
g.insert(s, d);
}
//g.printGraph();
g.computeResult(k);
//g.getKDegreeSets(2);
}
}
class Graph {
HashSet<Integer>[] adjList;
ArrayList<Edge> edgeList;
int n;
public Graph(int n, int m) {
adjList = new HashSet[n];
edgeList = new ArrayList<>(m);
this.n = n;
for (int i = 0; i < n; i++) {
adjList[i] = new HashSet<>();
}
}
void insert(int source, int destination) {
adjList[source].add(destination);
adjList[destination].add(source);
edgeList.add(new Edge(source, destination));
}
void computeResult(int k) {
HashSet<Integer> kDegreeSet = getKDegreeSets(k);
Stack<Integer> stack = new Stack<>();
for (int i = edgeList.size() - 1; i >= 0; i--) {
stack.push(kDegreeSet.size());
Edge edge = edgeList.get(i);
if (kDegreeSet.contains(edge.destination) && kDegreeSet.contains(edge.source)) {
removeEdge(kDegreeSet, edge.source, edge.destination, k);
}
}
PrintWriter pr = new PrintWriter(System.out);
while (!stack.isEmpty()) {
pr.append(String.valueOf(stack.pop()));
pr.append("\n");
}
pr.flush();
pr.close();
}
void removeEdge(HashSet<Integer> kDegreeSet, int source, int destination, int k) {
adjList[source].remove(destination);
adjList[destination].remove(source);
TreeSet<Integer> set = new TreeSet<>();
if (adjList[source].size() < k) {
set.add(source);
}
if (adjList[destination].size() < k) {
set.add(destination);
}
while (!set.isEmpty()) {
int n = set.pollFirst();
kDegreeSet.remove(n);
if (adjList[n] == null) {
continue;
}
for (int x : adjList[n]) {
if (adjList[x] != null) {
adjList[x].remove(n);
if (adjList[x].size() < k) {
set.add(x);
}
}
adjList[n] = null;
}
}
}
HashSet<Integer> getKDegreeSets(int k) {
TreeSet<Integer> set = new TreeSet<>();
for (int i = 0; i < n; i++) {
if (adjList[i].size() < k) {
set.add(i);
}
}
while (!set.isEmpty()) {
//System.out.println(set);
int n = set.pollFirst();
if (adjList[n] == null) {
continue;
}
for (int x : adjList[n]) {
if (adjList[x] != null) {
adjList[x].remove(n);
if (adjList[x].size() < k) {
set.add(x);
}
}
adjList[n] = null;
}
}
HashSet<Integer> returnNodes = new HashSet<>();
for (int i = 0; i < n; i++) {
if (adjList[i] != null) {
if (adjList[i].size() < k) {
//System.out.println(i + "\t" + adjList[i]);
//throw new RuntimeException("Something is wrong");
} else {
returnNodes.add(i);
}
}
}
//System.out.println(returnNodes);
return returnNodes;
}
public void printGraph() {
System.out.println("@printGraph");
for (int i = 0; i < n; i++) {
System.out.print(i + ": ");
for (int x : adjList[i]) {
System.out.print(x + ",");
}
System.out.println();
}
System.out.println();
}
}
class Edge {
int source;
int destination;
public Edge(int source, int destination) {
this.source = source;
this.destination = destination;
}
}
/*
9 11 2
1 2
1 3
1 4
3 4
3 5
4 5
5 8
5 6
5 7
7 6
8 9
* */ |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
char c = getchar();
bool f = false;
for (x = 0; !isdigit(c); c = getchar()) {
if (c == '-') {
f = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (f) {
x = -x;
}
}
template <typename T>
inline bool checkMax(T& a, const T& b) {
return a < b ? a = b, true : false;
}
template <typename T>
inline bool checkMin(T& a, const T& b) {
return a > b ? a = b, true : false;
}
const int N = 2e5 + 10;
int n, m, k, degree[N], ans[N], bl, avalib[N];
vector<pair<int, int> > G[N];
pair<int, int> f[N];
int main() {
read(n), read(m), read(k), bl = n;
for (register int i = 1; i <= m; ++i) {
int u, v;
read(u), read(v);
++degree[u], ++degree[v];
G[u].push_back(make_pair(v, i));
G[v].push_back(make_pair(u, i));
f[i] = pair<int, int>(u, v);
}
queue<int> Q;
for (register int i = 1; i <= n; ++i) {
if (degree[i] < k) {
--bl, Q.push(i);
}
}
for (register int i = m; i; --i) {
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (auto v : G[x]) {
if (!avalib[v.second]) {
if (--degree[v.first] == k - 1) {
--bl, Q.push(v.first);
}
avalib[v.second] = 1;
}
}
}
ans[i] = bl;
if (!avalib[i]) {
if (--degree[f[i].first] == k - 1) {
--bl, Q.push(f[i].first);
}
if (--degree[f[i].second] == k - 1) {
--bl, Q.push(f[i].second);
}
avalib[i] = 1;
}
}
for (register int i = 1; i <= m; ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<pair<int, int>> edges, g[N];
vector<int> ans;
set<pair<int, int>> s;
set<int> deleted;
int n, m, k, a, b, deg[N];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &a, &b);
edges.emplace_back(a, b);
deg[a]++;
deg[b]++;
g[a].emplace_back(b, i);
g[b].emplace_back(a, i);
}
for (int i = 1; i <= n; ++i) s.emplace(deg[i], i);
for (int ind = m - 1; ind >= 0; --ind) {
while (s.size() && s.begin()->first < k) {
int u = s.begin()->second;
s.erase(s.begin());
deleted.insert(u);
for (auto &i : g[u]) {
int v = i.first;
if (i.second > ind) continue;
if (!deleted.count(v)) {
s.erase({deg[v], v});
--deg[v];
s.insert({deg[v], v});
}
}
}
ans.emplace_back((int)s.size());
int x, y;
tie(x, y) = edges[ind];
if (!deleted.count(x) && !deleted.count(y)) {
s.erase({deg[x], x});
deg[x]--;
s.insert({deg[x], x});
s.erase({deg[y], y});
deg[y]--;
s.insert({deg[y], y});
}
}
reverse(ans.begin(), ans.end());
for (auto &i : ans) printf("%d\n", i);
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 3e5 + 10;
long long x[N], y[N], deg[N];
vector<long long> vp[N];
long long removed[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
vp[x[i]].push_back(y[i]);
vp[y[i]].push_back(x[i]);
deg[x[i]]++;
deg[y[i]]++;
}
set<pair<long long, long long> > s;
for (long long i = 1; i <= n; i++) {
s.insert({deg[i], i});
}
long long ans = n;
set<pair<long long, long long> > ae;
vector<long long> v;
for (long long i = m; i >= 1; i--) {
while (s.size() > 0) {
auto it = *s.begin();
s.erase(it);
if (it.first >= k) break;
removed[it.second] = 1;
for (auto it1 : vp[it.second]) {
if (ae.find({it1, it.second}) == ae.end()) {
ae.insert({it1, it.second});
ae.insert({it.second, it1});
s.erase({deg[it1], it1});
deg[it1]--;
s.insert({deg[it1], it1});
}
}
ans--;
}
if (ae.find({x[i], y[i]}) == ae.end()) {
ae.insert({x[i], y[i]});
ae.insert({y[i], x[i]});
s.erase({deg[x[i]], x[i]});
s.erase({deg[y[i]], y[i]});
deg[x[i]]--;
s.insert({deg[x[i]], x[i]});
deg[y[i]]--;
s.insert({deg[y[i]], y[i]});
}
v.push_back(ans);
}
reverse(v.begin(), v.end());
for (auto it : v) {
cout << it << "\n";
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, k;
int res;
vector<set<int>> g;
vector<int> used;
vector<int> selected;
void bfs(int start) {
vector<int> seen = {start};
queue<int> q;
used[start] = 1;
q.push(start);
while (!q.empty()) {
int v = q.front();
q.pop();
assert(selected[v]);
assert((int)g[v].size() < k);
selected[v] = 0;
res--;
for (auto t : g[v]) {
g[t].erase(v);
if (selected[t] && (int)g[t].size() < k && !used[t]) {
seen.push_back(t);
used[t] = 1;
q.push(t);
}
}
}
for (auto t : seen) {
used[t] = 0;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int m;
cin >> n >> m >> k;
used.resize(n);
g.resize(n);
vector<pair<int, int>> q;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].insert(v);
g[v].insert(u);
q.push_back({u, v});
}
reverse(q.begin(), q.end());
selected.assign(n, 1);
res = n;
for (int i = 0; i < n; i++) {
if ((int)g[i].size() < k && selected[i]) {
bfs(i);
}
}
vector<int> ans;
for (auto [u, v] : q) {
ans.push_back(res);
g[u].erase(v);
g[v].erase(u);
if ((int)g[u].size() < k && selected[u]) {
bfs(u);
}
if ((int)g[v].size() < k && selected[v]) {
bfs(v);
}
}
reverse(ans.begin(), ans.end());
for (auto t : ans) {
cout << t << '\n';
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskE solver = new TaskE();
solver.solve(1, in, out);
out.close();
}
static class TaskE {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.nextInt();
int m = in.nextInt();
int k = in.nextInt();
int[] deg = new int[n];
List<Integer>[] g = new List[n];
for (int i = 0; i < n; i++) {
g[i] = new ArrayList<>();
}
int[] x = new int[m];
int[] y = new int[m];
for (int i = 0; i < m; i++) {
x[i] = in.nextInt() - 1;
y[i] = in.nextInt() - 1;
g[x[i]].add(y[i]);
g[y[i]].add(x[i]);
++deg[x[i]];
++deg[y[i]];
}
int[] q = new int[n];
int qh = 0;
int qt = 0;
boolean[] vis = new boolean[n];
int cnt = n;
for (int i = 0; i < n; i++) {
if (deg[i] < k) {
--cnt;
q[qt++] = i;
vis[i] = true;
}
}
int[] res = new int[m];
Set<Long> edges = new HashSet<>();
for (int i = m - 1; i >= 0; i--) {
while (qh < qt) {
int u = q[qh++];
for (int v : g[u]) {
if (vis[v]) continue;
long edge = ((long) Math.min(u, v) << 32) + Math.max(u, v);
if (edges.contains(edge)) continue;
--deg[v];
if (deg[v] < k) {
--cnt;
q[qt++] = v;
vis[v] = true;
}
}
}
res[i] = cnt;
long edge = ((long) Math.min(x[i], y[i]) << 32) + Math.max(x[i], y[i]);
edges.add(edge);
if (!vis[x[i]] && !vis[y[i]]) {
--deg[x[i]];
if (deg[x[i]] < k) {
q[qt++] = x[i];
vis[x[i]] = true;
--cnt;
}
--deg[y[i]];
if (deg[y[i]] < k) {
q[qt++] = y[i];
vis[y[i]] = true;
--cnt;
}
}
}
for (int v : res) {
out.println(v);
}
}
}
static class InputReader {
final InputStream is;
final byte[] buf = new byte[1024];
int pos;
int size;
public InputReader(InputStream is) {
this.is = is;
}
public int nextInt() {
int c = read();
while (isWhitespace(c))
c = read();
int sign = 1;
if (c == '-') {
sign = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = read();
} while (!isWhitespace(c));
return res * sign;
}
int read() {
if (size == -1)
throw new InputMismatchException();
if (pos >= size) {
pos = 0;
try {
size = is.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (size <= 0)
return -1;
}
return buf[pos++] & 255;
}
static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int n, m, k, deg[N], ans[N];
pair<int, int> edges[N];
set<int> adj[N];
set<pair<int, int> > st;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
edges[i] = {x, y};
adj[x].insert(y);
adj[y].insert(x);
}
for (int i = 1; i <= n; i++) {
st.insert({(int)adj[i].size(), i});
}
for (int i = m; i >= 1; i--) {
while (!st.empty() && (*st.begin()).first < k) {
int node = (*st.begin()).second;
st.erase(st.begin());
for (auto ch : adj[node]) {
st.erase(st.find({(int)adj[ch].size(), ch}));
adj[ch].erase(node);
st.insert({(int)adj[ch].size(), ch});
}
adj[node].clear();
}
ans[i] = (int)st.size();
if (adj[edges[i].first].find(edges[i].second) !=
adj[edges[i].first].end()) {
int v = edges[i].first, u = edges[i].second;
pair<int, int> pr = {(int)adj[v].size(), v},
pr2 = {(int)adj[u].size(), u};
st.erase(pr);
st.erase(pr2);
adj[v].erase(u), adj[u].erase(v);
pr = {(int)adj[v].size(), v}, pr2 = pr2 = {(int)adj[u].size(), u};
st.insert(pr);
st.insert(pr2);
}
}
for (int i = 1; i <= m; i++) cout << ans[i] << '\n';
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 10;
pair<int, int> edge[maxn];
map<pair<int, int>, int> mp;
vector<int> g[maxn];
int vis[maxn];
queue<int> q;
int du[maxn];
int ans[maxn];
int main() {
std::ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
edge[i].first = u;
edge[i].second = v;
du[u]++;
du[v]++;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (du[i] < k) {
vis[i] = 1;
q.push(i);
}
}
while (!q.empty()) {
int u = q.front();
du[u]--;
q.pop();
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
mp[make_pair(u, v)] = 1;
mp[make_pair(v, u)] = 1;
du[v]--;
if (vis[v] == 0 && du[v] < k) {
q.push(v);
vis[v] = 1;
}
}
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) ans[m]++;
}
for (int i = m - 1; i >= 1; i--) {
ans[i] = ans[i + 1];
int x = edge[i + 1].first;
int y = edge[i + 1].second;
if (mp[make_pair(x, y)] == 1 || mp[make_pair(x, y)] == 1) {
continue;
}
mp[make_pair(x, y)] = 1;
mp[make_pair(x, y)] = 1;
du[x]--;
du[y]--;
if (vis[x] == 0 && du[x] < k) {
q.push(x);
vis[x] = 1;
ans[i]--;
}
if (vis[y] == 0 && du[y] < k) {
q.push(y);
vis[y] = 1;
ans[i]--;
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int t = 0; t < g[u].size(); t++) {
int v = g[u][t];
if (mp[make_pair(u, v)] == 1 || mp[make_pair(v, u)] == 1) {
continue;
}
mp[make_pair(u, v)] = 1;
mp[make_pair(v, u)] = 1;
du[v]--;
du[u]--;
if (vis[v] == 0 && du[v] < k) {
q.push(v);
vis[v] = 1;
ans[i]--;
}
}
}
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << endl;
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<vector<pair<int, int>>> g(n);
vector<int> from(m), to(m);
for (int i = 0; i < m; i++) {
cin >> from[i] >> to[i];
from[i]--;
to[i]--;
g[from[i]].emplace_back(to[i], i);
g[to[i]].emplace_back(from[i], i);
}
vector<int> res(m), alive(m, 1), que, deg(n);
for (int i = 0; i < n; i++) {
deg[i] = (int)g[i].size();
if (deg[i] < k) que.push_back(i);
}
int ind = 0;
for (int i = m - 1; i >= 0; i--) {
while (ind < (int)que.size()) {
int u = que[ind];
for (auto p : g[u]) {
if (!alive[p.second]) continue;
alive[p.second] = 0;
deg[u]--;
if (deg[p.first] == k) que.push_back(p.first);
deg[p.first]--;
}
ind++;
}
res[i] = n - que.size();
if (alive[i]) {
alive[i] = 0;
if (deg[from[i]] == k) que.push_back(from[i]);
if (deg[to[i]] == k) que.push_back(to[i]);
deg[from[i]]--;
deg[to[i]]--;
}
}
for (int i : res) cout << i << '\n';
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = int(200000) + 5;
int t, n, m, q, k, cnt, sum, x, y, l, r;
int a[N], b[N], ans[N];
pair<int, int> edge[N];
vector<pair<int, int> > v[N];
set<pair<int, int> > s;
set<pair<int, int> >::iterator it;
void update(int I) {
while (!s.empty() && (s.begin()->first) < k) {
it = s.begin();
x = it->second;
for (int i = 0; i < v[x].size(); i++) {
y = v[x][i].first;
if (v[x][i].second >= I) continue;
if (b[y]) {
s.erase({a[y], y});
a[y]--;
s.insert({a[y], y});
}
}
b[x] = 0;
s.erase(it);
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
edge[i].first = x;
edge[i].second = y;
a[x]++;
a[y]++;
v[x].push_back({y, i});
v[y].push_back({x, i});
}
for (int i = 1; i <= n; i++) {
s.insert({a[i], i});
b[i] = 1;
}
update(1e6);
for (int i = m; i >= 1; i--) {
ans[i] = s.size();
l = edge[i].first;
r = edge[i].second;
if (b[l] && b[r]) {
s.erase({a[l], l});
a[l]--;
s.insert({a[l], l});
s.erase({a[r], r});
a[r]--;
s.insert({a[r], r});
update(i);
}
}
for (int i = 1; i <= m; i++) cout << ans[i] << '\n';
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
using LL = long long;
constexpr int N = 2e5 + 5;
int ans[N];
int degree[N];
int is_good[N];
vector<pair<int, int>> E[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int>> e(m);
for (int i = 0; i < m; i++) {
auto& [x, y] = e[i];
cin >> x >> y;
x--;
y--;
degree[x]++;
degree[y]++;
E[x].push_back({y, i});
E[y].push_back({x, i});
}
set<pair<int, int>> good;
for (int i = 0; i < n; i++) good.insert({degree[i], i});
fill_n(is_good, n, 1);
auto keep_good = [&](int t) -> void {
while (!good.empty() && good.begin()->first < k) {
int x = good.begin()->second;
good.erase(good.begin());
for (const auto& [y, i] : E[x]) {
if (is_good[y] && i < t) {
good.erase({degree[y], y});
degree[y]--;
good.insert({degree[y], y});
}
}
is_good[x] = 0;
}
};
keep_good(m);
for (int i = m - 1; i >= 0; i--) {
ans[i] = good.size();
const auto& [x, y] = e[i];
if (is_good[x] && is_good[y]) {
good.erase({degree[x], x});
degree[x]--;
good.insert({degree[x], x});
good.erase({degree[y], y});
degree[y]--;
good.insert({degree[y], y});
keep_good(i);
}
}
for (int i = 0; i < m; i++) cout << ans[i] << "\n";
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, m, k, x[200009], y[200009];
set<int> alive;
vector<int> kaaj;
set<int> graph[200009];
int degree[200009], ans[200009];
void doit(int z) {
if (alive.find(z) == alive.end()) return;
alive.erase(z);
if (graph[z].empty()) return;
auto it = graph[z].begin();
while (it != graph[z].end()) {
int v = *it;
degree[v]--;
graph[v].erase(z);
if (degree[v] < k && alive.find(v) != alive.end()) {
kaaj.push_back(v);
}
it++;
}
graph[z].clear();
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x[i], &y[i]);
graph[x[i]].insert(y[i]);
graph[y[i]].insert(x[i]);
degree[x[i]]++;
degree[y[i]]++;
}
for (int i = 1; i <= n; i++) alive.insert(i);
for (int i = 1; i <= n; i++) {
if (degree[i] < k) {
kaaj.push_back(i);
}
}
while (!kaaj.empty()) {
int z = kaaj.back();
kaaj.pop_back();
doit(z);
}
for (int i = m; i >= 1; i--) {
ans[i] = alive.size();
if (alive.find(x[i]) == alive.end() || alive.find(y[i]) == alive.end())
continue;
degree[x[i]]--;
degree[y[i]]--;
graph[x[i]].erase(y[i]);
graph[y[i]].erase(x[i]);
if (degree[x[i]] < k && alive.find(x[i]) != alive.end()) {
kaaj.push_back(x[i]);
}
while (!kaaj.empty()) {
int z = kaaj.back();
kaaj.pop_back();
doit(z);
}
if (degree[y[i]] < k && alive.find(y[i]) != alive.end()) {
kaaj.push_back(y[i]);
}
while (!kaaj.empty()) {
int z = kaaj.back();
kaaj.pop_back();
doit(z);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.util.*;
import java.io.*;
import java.text.*;
//Solution Credits: Taranpreet Singh
public class Main{
//SOLUTION BEGIN
void solve(int TC) throws Exception{
int n = ni(), m = ni(), k = ni();
TreeSet<Long> set = new TreeSet<>();
HashSet<Integer>[] g = new HashSet[n];
for(int i = 0; i< n; i++)g[i] = new HashSet<>();
int[][] edge = new int[m][2];
for(int i = 0; i< m; i++){
edge[i] = new int[]{ni()-1, ni()-1};
g[edge[i][0]].add(edge[i][1]);
g[edge[i][1]].add(edge[i][0]);
}
for(int i = 0; i< n; i++)set.add(g[i].size()*(long)n+i);
// while(!set.isEmpty() && set.first()/n<k){
// long x = set.first();
// int v= (int)(x/n);
// for(int w:g[v]){
// set.remove(g[w].size()*(long)n+w);
// g[w].remove(v);
// set.remove(g[w].size()*(long)n+w);
// }
// g[v].clear();
// }
int[] ans = new int[m];
for(int i = m-1; i>= 0; i--){
while(!set.isEmpty() && set.first()/n<k){
long x = set.pollFirst();
int v = (int)(x%n);
for(int w:g[v]){
set.remove(g[w].size()*(long)n+w);
g[w].remove(v);
set.add(g[w].size()*(long)n+w);
}
g[v].clear();
}
ans[i] = set.size();
if(g[edge[i][0]].contains(edge[i][1])){
set.remove(g[edge[i][0]].size()*(long)n+edge[i][0]);
g[edge[i][0]].remove(edge[i][1]);
set.add(g[edge[i][0]].size()*(long)n+edge[i][0]);
}
if(g[edge[i][1]].contains(edge[i][0])){
set.remove(g[edge[i][1]].size()*(long)n+edge[i][1]);
g[edge[i][1]].remove(edge[i][0]);
set.add(g[edge[i][1]].size()*(long)n+edge[i][1]);
}
}
for(int i:ans)pn(i);
}
//SOLUTION ENDS
long mod = (int)1e9+7, IINF = (long)1e19;
final int MAX = (int)1e5+1, INF = (int)1e9, root = 3;
DecimalFormat df = new DecimalFormat("0.00000000");
double PI = 3.141592653589793238462643383279502884197169399375105820974944, eps = 1e-8;
static boolean multipleTC = false, memory = true;
FastReader in;PrintWriter out;
void run() throws Exception{
in = new FastReader();
out = new PrintWriter(System.out);
int T = (multipleTC)?ni():1;
// long ct = System.currentTimeMillis();
//Solution Credits: Taranpreet Singh
for(int i = 1; i<= T; i++)solve(i);
// pn(System.currentTimeMillis()-ct);
out.flush();
out.close();
}
public static void main(String[] args) throws Exception{
if(memory)new Thread(null, new Runnable() {public void run(){try{new Main().run();}catch(Exception e){e.printStackTrace();}}}, "1", 1 << 28).start();
else new Main().run();
}
long gcd(long a, long b){return (b==0)?a:gcd(b,a%b);}
int gcd(int a, int b){return (b==0)?a:gcd(b,a%b);}
int bit(long n){return (n==0)?0:(1+bit(n&(n-1)));}
void p(Object o){out.print(o);}
void pn(Object o){out.println(o);}
void pni(Object o){out.println(o);out.flush();}
String n(){return in.next();}
String nln(){return in.nextLine();}
int ni(){return Integer.parseInt(in.next());}
long nl(){return Long.parseLong(in.next());}
double nd(){return Double.parseDouble(in.next());}
class FastReader{
BufferedReader br;
StringTokenizer st;
public FastReader(){
br = new BufferedReader(new InputStreamReader(System.in));
}
public FastReader(String s) throws Exception{
br = new BufferedReader(new FileReader(s));
}
String next(){
while (st == null || !st.hasMoreElements()){
try{
st = new StringTokenizer(br.readLine());
}catch (IOException e){
e.printStackTrace();
}
}
return st.nextToken();
}
String nextLine(){
String str = "";
try{
str = br.readLine();
}catch (IOException e){
e.printStackTrace();
}
return str;
}
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
import static java.lang.Math.*;
/* spar5h */
//hm.get((long)0) != hm.get(0)
public class cf5 implements Runnable{
static class pair {
int i, j;
pair(int i, int j) {
this.i = i; this.j = j;
}
}
public void run() {
InputReader s = new InputReader(System.in);
PrintWriter w = new PrintWriter(System.out);
int n = s.nextInt(), m = s.nextInt(), k = s.nextInt();
HashSet<Integer>[] adj = new HashSet[n + 1];
for(int i = 1; i <= n; i++)
adj[i] = new HashSet<Integer>();
ArrayList<pair> edge = new ArrayList<pair>();
for(int i = 0; i < m; i++) {
int u = s.nextInt(), v = s.nextInt();
adj[u].add(v); adj[v].add(u);
edge.add(new pair(u, v));
}
int[] dead = new int[n + 1];
for(int i = 1; i <= n; i++) {
if(dead[i] == 1 || adj[i].size() >= k)
continue;
dead[i] = 1;
Queue<Integer> q = new LinkedList<Integer>(); q.add(i);
while(!q.isEmpty()) {
int x = q.poll();
for(int y : adj[x]) {
adj[y].remove(x);
if(dead[y] == 0 && adj[y].size() < k) {
dead[y] = 1; q.add(y);
}
}
adj[x].clear();
}
}
int[] res = new int[m]; int count = 0;
for(int i = 1; i <= n; i++)
if(dead[i] == 0)
count++;
for(int i = m - 1; i >= 0; i--) {
res[i] = count;
int u = edge.get(i).i, v = edge.get(i).j;
if(dead[u] == 1 || dead[v] == 1)
continue;
Queue<Integer> q = new LinkedList<Integer>();
adj[u].remove(v);
if(adj[u].size() < k) {
dead[u] = 1; q.add(u); count--;
}
adj[v].remove(u);
if(adj[v].size() < k) {
dead[v] = 1; q.add(v); count--;
}
while(!q.isEmpty()) {
int x = q.poll();
for(int y : adj[x]) {
adj[y].remove(x);
if(dead[y] == 0 && adj[y].size() < k) {
dead[y] = 1; q.add(y); count--;
}
}
adj[x].clear();
}
}
for(int i = 0; i < m; i++)
w.print(res[i] + " ");
w.println();
w.close();
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream)
{
this.stream = stream;
}
public int read()
{
if (numChars==-1)
throw new InputMismatchException();
if (curChar >= numChars)
{
curChar = 0;
try
{
numChars = stream.read(buf);
}
catch (IOException e)
{
throw new InputMismatchException();
}
if(numChars <= 0)
return -1;
}
return buf[curChar++];
}
public String nextLine()
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
public int nextInt()
{
int c = read();
while(isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
int res = 0;
do
{
if(c<'0'||c>'9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
long res = 0;
do
{
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
while (!isSpaceChar(c));
return res * sgn;
}
public double nextDouble()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.')
{
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.')
{
c = read();
double m = 1;
while (!isSpaceChar(c))
{
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public String readString()
{
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do
{
res.appendCodePoint(c);
c = read();
}
while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c)
{
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next()
{
return readString();
}
public interface SpaceCharFilter
{
public boolean isSpaceChar(int ch);
}
}
public static void main(String args[]) throws Exception
{
new Thread(null, new cf5(),"cf5",1<<26).start();
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
set<int> adj[200009];
set<int>::iterator it;
int vis[200009];
pair<int, int> edg[200009];
vector<int> bad;
int ses[200009];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &edg[i].first, &edg[i].second);
adj[edg[i].first].insert(edg[i].second);
adj[edg[i].second].insert(edg[i].first);
}
int ans = n;
for (int i = 1; i <= n; i++) {
if (adj[i].size() < k) {
vis[i] = 1;
ans--;
bad.push_back(i);
}
}
for (int i = m; i >= 1; i--) {
while (bad.size() > 0) {
int v = bad.back();
bad.pop_back();
for (it = adj[v].begin(); it != adj[v].end(); it++) {
int u = *it;
adj[u].erase(v);
if (vis[u] == 0 && adj[u].size() < k) {
bad.push_back(u);
vis[u] = 1;
ans--;
}
}
adj[v].clear();
}
ses[i] = ans;
int u = edg[i].first;
int v = edg[i].second;
if (vis[u] == 1 || vis[v] == 1) continue;
adj[u].erase(v);
adj[v].erase(u);
if (adj[u].size() < k) {
bad.push_back(u);
ans--;
vis[u] = 1;
}
if (adj[v].size() < k) {
bad.push_back(v);
ans--;
vis[v] = 1;
}
}
for (int i = 1; i <= m; i++) {
printf("%d\n", ses[i]);
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
struct Edge {
int x, y;
} E[200010];
struct edge {
int nxt, t, s;
} e[200010 << 1];
int head[200010], edge_cnt;
void add_edge(int x, int y, int z) {
e[edge_cnt] = (edge){head[x], y, z};
head[x] = edge_cnt++;
}
bool ban[200010];
int Deg[200010], Q[200010], Ans[200010];
int main() {
memset(head, -1, sizeof(head));
int n, m, K, i, j;
scanf("%d%d%d", &n, &m, &K);
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add_edge(x, y, i);
add_edge(y, x, i);
E[i] = (Edge){x, y};
Deg[x]++, Deg[y]++;
}
int L = 1, R = 0;
for (i = 1; i <= n; i++) {
if (Deg[i] < K) {
Q[++R] = i;
ban[i] = 1;
}
}
for (i = m; i >= 1; i--) {
while (L <= R) {
int x = Q[L++];
for (j = head[x]; ~j; j = e[j].nxt) {
int y = e[j].t;
if (ban[y] || e[j].s > i) {
continue;
}
Deg[y]--;
if (Deg[y] < K) {
Q[++R] = y;
ban[y] = 1;
}
}
}
Ans[i] = n - R;
int a = E[i].x, b = E[i].y;
if (ban[a] || ban[b]) {
continue;
}
Deg[a]--, Deg[b]--;
if (Deg[a] < K) {
Q[++R] = a;
ban[a] = 1;
}
if (Deg[b] < K) {
Q[++R] = b;
ban[b] = 1;
}
}
for (i = 1; i <= m; i++) {
printf("%d\n", Ans[i]);
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int intcmp(const void *v1, const void *v2) { return *(int *)v1 - *(int *)v2; }
int n, m, k;
vector<pair<int, int>> v1v2index[200010];
int ea[200010], eb[200010];
int d[200010];
int curidx;
bool deleted[200010];
int delcnt[200010];
int delnow;
void dfs(int v) {
if (deleted[v] || d[v] >= k) {
return;
}
deleted[v] = true;
++delnow;
for (auto [u, idx] : v1v2index[v]) {
if (idx >= curidx) {
continue;
}
--d[u];
dfs(u);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
v1v2index[a].push_back(make_pair(b, i));
v1v2index[b].push_back(make_pair(a, i));
ea[i] = a;
eb[i] = b;
d[a]++;
d[b]++;
}
curidx = m;
for (int i = 1; i < n + 1; i++) {
dfs(i);
}
for (curidx = m - 1; curidx >= 0; curidx--) {
delcnt[curidx] = delnow;
if (deleted[ea[curidx]] || deleted[eb[curidx]]) {
continue;
}
d[ea[curidx]]--;
d[eb[curidx]]--;
dfs(ea[curidx]);
dfs(eb[curidx]);
}
for (int i = 0; i < m; ++i) {
printf("%d\n", n - delcnt[i]);
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
const int N = 2e5 + 5;
using namespace std;
int n, m, k;
int res[N];
int x[N], y[N];
int bac[N];
set<int> a[N];
set<pair<int, int> > S;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
a[x[i]].insert(y[i]);
a[y[i]].insert(x[i]);
bac[x[i]]++;
bac[y[i]]++;
}
for (int i = 1; i <= n; i++)
if (bac[i] > 0) S.insert(make_pair(bac[i], i));
for (int i = m; i >= 1; i--) {
while (S.size() && S.begin()->first < k) {
int cc = S.begin()->first;
int u = S.begin()->second;
for (int v : a[u]) {
S.erase(make_pair(bac[v], v));
bac[v]--;
if (bac[v] > 0) S.insert(make_pair(bac[v], v));
a[v].erase(u);
}
a[u].clear();
bac[u] = 0;
S.erase(make_pair(cc, u));
}
res[i] = S.size();
if (a[y[i]].find(x[i]) != a[y[i]].end()) {
S.erase(make_pair(bac[x[i]], x[i]));
bac[x[i]]--;
if (bac[x[i]] > 0) S.insert(make_pair(bac[x[i]], x[i]));
S.erase(make_pair(bac[y[i]], y[i]));
bac[y[i]]--;
if (bac[y[i]] > 0) S.insert(make_pair(bac[y[i]], y[i]));
a[x[i]].erase(y[i]);
a[y[i]].erase(x[i]);
}
}
for (int i = 1; i <= m; i++) cout << res[i] << '\n';
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<int> from(m), to(m);
vector<vector<pair<int, int> > > adj(n);
for (int i = (int)(0); i < (int)(m); ++i) {
cin >> from[i] >> to[i];
from[i]--, to[i]--;
adj[from[i]].emplace_back(to[i], i);
adj[to[i]].emplace_back(from[i], i);
}
vector<int> alive(m, 1);
vector<int> deg(n);
set<pair<int, int> > g;
for (int i = (int)(0); i < (int)(n); ++i) {
deg[i] = adj[i].size();
if (deg[i]) g.emplace(deg[i], i);
}
function<void()> update = [&]() {
while (g.size() && g.begin()->first < k) {
int u = g.begin()->second;
g.erase(g.begin());
for (auto &p : adj[u]) {
if (alive[p.second]) {
alive[p.second] = 0;
int v = p.first;
g.erase({deg[v], v});
g.emplace(--deg[v], v);
}
}
}
};
vector<int> ans(m);
for (int i = (int)(m - 1); i >= (int)(0); --i) {
update();
ans[i] = g.size();
if (alive[i]) {
int u = from[i], v = to[i];
g.erase({deg[u], u});
g.emplace(--deg[u], u);
g.erase({deg[v], v});
g.emplace(--deg[v], v);
alive[i] = 0;
}
}
for (int i = (int)(0); i < (int)(m); ++i) {
cout << ans[i] << "\n";
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.Set;
import java.util.InputMismatchException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.io.Writer;
import java.io.OutputStreamWriter;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskE solver = new TaskE();
solver.solve(1, in, out);
out.close();
}
static class TaskE {
Set[] graph;
int[] deg;
Set<Integer> s;
int k;
int n;
public void solve(int testNumber, InputReader in, OutputWriter out) {
n = in.nextInt();
int m = in.nextInt();
k = in.nextInt();
graph = new Set[n];
for (int i = 0; i < n; i++) {
graph[i] = new HashSet();
}
deg = new int[n];
List<edge> edges = new ArrayList<>();
for (int i = 0; i < m; i++) {
int u = in.nextInt() - 1;
int v = in.nextInt() - 1;
edges.add(new edge(u, v));
graph[u].add(v);
graph[v].add(u);
deg[u]++;
deg[v]++;
}
s = new HashSet<>();
List<vertex> vertices = new ArrayList<>();
for (int i = 0; i < n; i++) {
s.add(i);
vertices.add(new vertex(i, deg[i]));
}
vertices.sort((v1, v2) -> v1.d - v2.d);
int i = 0;
for (i = 0; i < n; i++) {
if (vertices.get(i).d < k) {
int u = vertices.get(i).u;
if (s.contains(u))
dfs(u, -1, -1);
} else {
break;
}
}
//out.println(s.size());
List<Integer> ans = new ArrayList<>();
ans.add(s.size());
for (int j = m - 1; j > 0; j--) {
edge ce = edges.get(j);
graph[ce.u].remove(ce.v);
graph[ce.v].remove(ce.u);
if (s.contains(ce.u) && s.contains(ce.v)) {
dfs(ce.u, ce.v, ce.u);
if (s.contains(ce.v))
dfs(ce.v, ce.u, ce.v);
}
ans.add(s.size());
}
for (int j = ans.size() - 1; j >= 0; j--) {
out.println(ans.get(j));
}
}
void dfs(int u, int ov, int ou) {
deg[u]--;
if (deg[u] >= k) {
return;
}
s.remove(u);
for (int v : (Set<Integer>) graph[u]) {
if (s.contains(v)) {
dfs(v, ov, ou);
}
}
}
class edge {
int u;
int v;
public edge(int u, int v) {
this.u = u;
this.v = v;
}
}
class vertex {
int u;
int d;
public vertex(int u, int d) {
this.u = u;
this.d = d;
}
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void println(int i) {
writer.println(i);
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
set<int> S, G[N];
int A[N], B[N], C[N], n, m, k;
void U(int u) {
if (G[u].size() < k && S.erase(u))
for (auto v : G[u]) G[v].erase(u), U(v);
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", A + i, B + i);
G[A[i]].insert(B[i]);
G[B[i]].insert(A[i]);
}
for (int i = 1; i <= n; S.insert(i++))
;
for (int i = 1; i <= n; ++i) U(i);
for (int i = m; i >= 1; --i) {
C[i] = S.size();
G[A[i]].erase(B[i]);
G[B[i]].erase(A[i]);
U(A[i]);
U(B[i]);
}
for (int i = 1; i <= m; ++i) printf("%d\n", C[i]);
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 1;
int n, m, k, ans;
int du[MAX], X[MAX], Y[MAX], Ans[MAX];
vector<int> ve[MAX];
bool use[MAX];
void work(int x) {
queue<int> qu;
qu.push(x), use[x] = 1, --ans;
while (!qu.empty()) {
int tt = qu.front();
qu.pop();
for (int i = 0; i < ve[tt].size(); ++i) {
int y = ve[tt][i];
if (use[y]) continue;
--du[y];
if (du[y] < k) --ans, use[y] = 1, qu.push(y);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
ans = n;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &X[i], &Y[i]);
++du[X[i]], ++du[Y[i]], ve[X[i]].push_back(Y[i]), ve[Y[i]].push_back(X[i]);
}
for (int i = 1; i <= n; ++i)
if (du[i] < k && !use[i]) work(i);
Ans[m] = ans;
for (int i = m; i >= 1; --i) {
if (!use[Y[i]]) --du[X[i]];
if (!use[X[i]]) --du[Y[i]];
ve[X[i]].pop_back(), ve[Y[i]].pop_back();
if (du[X[i]] < k && !use[X[i]]) work(X[i]);
if (du[Y[i]] < k && !use[Y[i]]) work(Y[i]);
Ans[i - 1] = ans;
}
for (int i = 1; i <= m; ++i) printf("%d\n", Ans[i]);
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long mod = 1000000007;
const double e = 2.718281828459;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long gcd1(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
long long pow_mod(long long a, long long b, long long c) {
long long ans = 1;
a = a % c;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % c;
b = b / 2;
a = (a * a) % c;
}
return ans;
}
int pow_int(int a, int b) {
int ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = ans * a;
b = b / 2;
a = a * a;
}
return ans;
}
long long pow_llong(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = ans * a;
b = b / 2;
a = a * a;
}
return ans;
}
int Scan() {
int res = 0, flag = 0;
char ch;
if ((ch = getchar()) == '-') {
flag = 1;
} else if (ch >= '0' && ch <= '9') {
res = ch - '0';
}
while ((ch = getchar()) >= '0' && ch <= '9') {
res = res * 10 + (ch - '0');
}
return flag ? -res : res;
}
void Out(int a) {
if (a < 0) {
putchar('-');
a = -a;
}
if (a >= 10) {
Out(a / 10);
}
putchar(a % 10 + '0');
}
long long jc_mod(long long a, long long b, long long mod) {
long long ans = 1;
b = max(b, a - b);
for (long long i = a; i > b; i--) {
ans *= i;
ans %= mod;
}
return ans;
}
double lg(double a) { return (log(a) / log(10.0)); }
namespace fastIO {
bool IOerror = 0;
inline char nc() {
static char buf[100000], *p1 = buf + 100000, *pend = buf + 100000;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, 100000, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void read(int &x) {
bool sign = 0;
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (sign) x = -x;
}
inline void read(long long &x) {
bool sign = 0;
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (sign) x = -x;
}
inline void read(double &x) {
bool sign = 0;
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (ch == '.') {
double tmp = 1;
ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc())
tmp /= 10.0, x += tmp * (ch - '0');
}
if (sign) x = -x;
}
inline void read(char *s) {
char ch = nc();
for (; blank(ch); ch = nc())
;
if (IOerror) return;
for (; !blank(ch) && !IOerror; ch = nc()) *s++ = ch;
*s = 0;
}
inline void read(char &c) {
for (c = nc(); blank(c); c = nc())
;
if (IOerror) {
c = -1;
return;
}
}
inline void read1(int &x) {
char ch;
int bo = 0;
x = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') bo = 1;
for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - '0', ch = getchar())
;
if (bo) x = -x;
}
inline void read1(long long &x) {
char ch;
int bo = 0;
x = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') bo = 1;
for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - '0', ch = getchar())
;
if (bo) x = -x;
}
inline void read1(double &x) {
char ch;
int bo = 0;
x = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') bo = 1;
for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - '0', ch = getchar())
;
if (ch == '.') {
double tmp = 1;
for (ch = getchar(); ch >= '0' && ch <= '9';
tmp /= 10.0, x += tmp * (ch - '0'), ch = getchar())
;
}
if (bo) x = -x;
}
inline void read1(char *s) {
char ch = getchar();
for (; blank(ch); ch = getchar())
;
for (; !blank(ch); ch = getchar()) *s++ = ch;
*s = 0;
}
inline void read1(char &c) {
for (c = getchar(); blank(c); c = getchar())
;
}
inline void read2(int &x) { scanf("%d", &x); }
inline void read2(long long &x) { scanf("%lld", &x); }
inline void read2(double &x) { scanf("%lf", &x); }
inline void read2(char *s) { scanf("%s", s); }
inline void read2(char &c) { scanf(" %c", &c); }
inline void readln2(char *s) { gets(s); }
struct Ostream_fwrite {
char *buf, *p1, *pend;
Ostream_fwrite() {
buf = new char[100000];
p1 = buf;
pend = buf + 100000;
}
void out(char ch) {
if (p1 == pend) {
fwrite(buf, 1, 100000, stdout);
p1 = buf;
}
*p1++ = ch;
}
void print(int x) {
static char s[15], *s1;
s1 = s;
if (!x) *s1++ = '0';
if (x < 0) out('-'), x = -x;
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
}
void println(int x) {
static char s[15], *s1;
s1 = s;
if (!x) *s1++ = '0';
if (x < 0) out('-'), x = -x;
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
out('\n');
}
void print(long long x) {
static char s[25], *s1;
s1 = s;
if (!x) *s1++ = '0';
if (x < 0) out('-'), x = -x;
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
}
void println(long long x) {
static char s[25], *s1;
s1 = s;
if (!x) *s1++ = '0';
if (x < 0) out('-'), x = -x;
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
out('\n');
}
void print(double x, int y) {
static long long mul[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000LL,
100000000000LL,
1000000000000LL,
10000000000000LL,
100000000000000LL,
1000000000000000LL,
10000000000000000LL,
100000000000000000LL};
if (x < -1e-12) out('-'), x = -x;
x *= mul[y];
long long x1 = (long long)floor(x);
if (x - floor(x) >= 0.5) ++x1;
long long x2 = x1 / mul[y], x3 = x1 - x2 * mul[y];
print(x2);
if (y > 0) {
out('.');
for (size_t i = 1; i < y && x3 * mul[i] < mul[y]; out('0'), ++i)
;
print(x3);
}
}
void println(double x, int y) {
print(x, y);
out('\n');
}
void print(char *s) {
while (*s) out(*s++);
}
void println(char *s) {
while (*s) out(*s++);
out('\n');
}
void flush() {
if (p1 != buf) {
fwrite(buf, 1, p1 - buf, stdout);
p1 = buf;
}
}
~Ostream_fwrite() { flush(); }
} Ostream;
inline void print(int x) { Ostream.print(x); }
inline void println(int x) { Ostream.println(x); }
inline void print(char x) { Ostream.out(x); }
inline void println(char x) {
Ostream.out(x);
Ostream.out('\n');
}
inline void print(long long x) { Ostream.print(x); }
inline void println(long long x) { Ostream.println(x); }
inline void print(double x, int y) { Ostream.print(x, y); }
inline void println(double x, int y) { Ostream.println(x, y); }
inline void print(char *s) { Ostream.print(s); }
inline void println(char *s) { Ostream.println(s); }
inline void println() { Ostream.out('\n'); }
inline void flush() { Ostream.flush(); }
char Out[100000], *o = Out;
inline void print1(int x) {
static char buf[15];
char *p1 = buf;
if (!x) *p1++ = '0';
if (x < 0) *o++ = '-', x = -x;
while (x) *p1++ = x % 10 + '0', x /= 10;
while (p1-- != buf) *o++ = *p1;
}
inline void println1(int x) {
print1(x);
*o++ = '\n';
}
inline void print1(long long x) {
static char buf[25];
char *p1 = buf;
if (!x) *p1++ = '0';
if (x < 0) *o++ = '-', x = -x;
while (x) *p1++ = x % 10 + '0', x /= 10;
while (p1-- != buf) *o++ = *p1;
}
inline void println1(long long x) {
print1(x);
*o++ = '\n';
}
inline void print1(char c) { *o++ = c; }
inline void println1(char c) {
*o++ = c;
*o++ = '\n';
}
inline void print1(char *s) {
while (*s) *o++ = *s++;
}
inline void println1(char *s) {
print1(s);
*o++ = '\n';
}
inline void println1() { *o++ = '\n'; }
inline void flush1() {
if (o != Out) {
if (*(o - 1) == '\n') *--o = 0;
puts(Out);
}
}
struct puts_write {
~puts_write() { flush1(); }
} _puts;
inline void print2(int x) { printf("%d", x); }
inline void println2(int x) { printf("%d\n", x); }
inline void print2(char x) { printf("%c", x); }
inline void println2(char x) { printf("%c\n", x); }
inline void print2(long long x) { printf("%lld", x); }
inline void println2(long long x) {
print2(x);
printf("\n");
}
inline void println2() { printf("\n"); }
}; // namespace fastIO
using namespace fastIO;
void lisan(int *x, int n) {
int data[100010];
for (int i = 1; i <= n; i++) data[i] = x[i];
sort(data + 1, data + 1 + n);
int o = unique(data + 1, data + 1 + n) - data - 1;
for (int i = 1; i <= n; i++)
x[i] = lower_bound(data + 1, data + 1 + o, x[i]) - data;
}
long long calc(int M) { return 1; }
int sanfen(int L, int R) {
int M, RM;
while (L + 1 < R) {
M = (L + R) / 2;
RM = (M + R) / 2;
if (calc(M) < calc(RM))
R = RM;
else
L = M;
}
return L;
}
int CaculateWeekDay(int y, int m, int d) {
if (m == 1 || m == 2) {
m += 12;
y--;
}
int iWeek = (d + 2 * m + 3 * (m + 1) / 5 + y + y / 4 - y / 100 + y / 400) % 7;
return iWeek;
}
long long inv[2000022];
void init_inverse() {
inv[1] = 1;
for (int i = 2; i < 2000022; i++)
inv[i] = (mod - (mod / i) * inv[mod % i] % mod) % mod;
}
int n, m, k;
set<int> second[200010];
set<pair<int, int> > now;
int siz[200010];
void del(int x) {
for (set<int>::iterator it = second[x].begin(); it != second[x].end();) {
now.erase(make_pair(siz[*it], *it));
siz[*it]--;
now.insert(make_pair(siz[*it], *it));
second[*it].erase(x);
second[x].erase(*it++);
}
now.erase(make_pair(siz[x], x));
siz[x] = 0;
}
void update() {
while (now.size() && now.begin()->first < k) {
del(now.begin()->second);
}
}
int ai[200010];
int ans[200010];
int bi[200010];
int main() {
scanf("%d%d%d", &n, &m, &k);
int a, b;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &ai[i], &bi[i]);
second[ai[i]].insert(bi[i]);
second[bi[i]].insert(ai[i]);
siz[ai[i]]++;
siz[bi[i]]++;
}
for (int i = 1; i <= n; i++) now.insert(make_pair(siz[i], i));
update();
for (int i = m; i; i--) {
ans[i] = now.size();
if (second[ai[i]].find(bi[i]) != second[ai[i]].end()) {
now.erase(make_pair(siz[ai[i]], ai[i]));
second[ai[i]].erase(bi[i]);
siz[ai[i]]--;
if (siz[ai[i]]) now.insert(make_pair(siz[ai[i]], ai[i]));
}
if (second[bi[i]].find(ai[i]) != second[bi[i]].end()) {
now.erase(make_pair(siz[bi[i]], bi[i]));
second[bi[i]].erase(ai[i]);
siz[bi[i]]--;
if (siz[bi[i]]) now.insert(make_pair(siz[bi[i]], bi[i]));
}
update();
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int x[200010], y[200010];
set<int> s[200010];
queue<int> q, p;
bool inq[200010];
bool w[200010];
int ans[200010];
int n, m, k, sum;
void reset() {
while (!q.empty()) q.pop();
while (!p.empty()) inq[p.front()] = false, p.pop();
}
void BFS() {
while (!q.empty()) {
int now = q.front();
w[now] = true;
p.push(now);
sum--;
q.pop();
for (set<int>::iterator i = s[now].begin(); i != s[now].end(); i++) {
s[*i].erase(now);
if (s[*i].size() < k && !inq[*i] && !w[*i]) inq[*i] = true, q.push(*i);
}
}
}
int main() {
cin >> n >> m >> k;
sum = n;
for (int i = 1; i <= m; i++)
cin >> x[i] >> y[i], s[x[i]].insert(y[i]), s[y[i]].insert(x[i]);
for (int i = 1; i <= n; i++)
if (s[i].size() < k) inq[i] = true, q.push(i);
BFS();
for (int i = m; i > 0; i--) {
ans[i] = sum;
reset();
s[x[i]].erase(y[i]);
s[y[i]].erase(x[i]);
if (s[x[i]].size() < k && !w[x[i]]) inq[x[i]] = true, q.push(x[i]);
if (s[y[i]].size() < k && !w[y[i]]) inq[y[i]] = true, q.push(y[i]);
BFS();
}
for (int i = 1; i <= m; i++) cout << ans[i] << endl;
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const long long linf = 1LL << 62;
const int iinf = 1000000009;
const double dinf = 1e17;
const int Mod = 1e9 + 9;
const int maxn = 1000005;
set<pair<int, int> > s, sp;
int n, m, k, u, v;
int mp[maxn], rt;
pair<int, int> sd[maxn], ds[maxn];
vector<int> vp[200005];
void up(int x) {
for (int i = 1; i <= vp[x].size(); i++) {
if (s.count(make_pair(vp[x][i - 1], x))) {
sp.erase(make_pair(mp[vp[x][i - 1]], vp[x][i - 1]));
mp[vp[x][i - 1]]--;
sp.insert(make_pair(mp[vp[x][i - 1]], vp[x][i - 1]));
s.erase(make_pair(vp[x][i - 1], x));
s.erase(make_pair(x, vp[x][i - 1]));
}
}
}
void del() {
set<pair<int, int> >::iterator it;
while (1) {
rt = 0;
for (it = sp.begin(); it != sp.end(); it++) {
if (((*it).first) >= k) break;
ds[rt++] = (*it);
}
if (!rt) break;
for (int i = 0; i <= rt - 1; i++) sp.erase(ds[i]), up(ds[i].second);
}
}
void del(int i) {
if (s.count(sd[i])) {
s.erase(sd[i]);
u = sd[i].first;
v = sd[i].second;
s.erase(make_pair(v, u));
sp.erase(make_pair(mp[u], u));
sp.insert(make_pair(--mp[u], u));
sp.erase(make_pair(mp[v], v));
sp.insert(make_pair(--mp[v], v));
del();
}
}
int ans[maxn];
void solve() {
s.clear();
ios::sync_with_stdio(false);
memset(mp, 0, sizeof(mp));
sp.clear();
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) vp[i].clear();
for (int i = 1; i <= m; i++) {
cin >> u >> v;
mp[u]++;
mp[v]++;
s.insert(make_pair(u, v));
s.insert(make_pair(v, u));
sd[i] = make_pair(u, v);
vp[v].push_back(u);
vp[u].push_back(v);
}
for (int i = 1; i <= n; i++) sp.insert(make_pair(mp[i], i));
for (int i = m; i >= 1; i--) {
del();
ans[i] = sp.size();
del(i);
}
for (int i = 1; i <= m; i++) cout << ans[i] << endl;
;
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int OO = 0x3f3f3f3f;
const double eps = (1e-10);
stringstream out;
int n, m, k, u, v, deg[200005];
bool isGood[200005];
vector<int> ans(200005);
set<pair<int, int> > good;
vector<pair<int, int> > edges(200005);
vector<vector<pair<int, int> > > adj(200005);
int main() {
ios::sync_with_stdio(false);
cout.precision(10);
cin >> n >> m >> k;
for (int i = 0; i < (int)(m); ++i) {
cin >> u >> v;
--u, --v;
edges[i].first = u, edges[i].second = v;
adj[u].push_back(make_pair(v, i)), adj[v].push_back(make_pair(u, i));
++deg[u], ++deg[v];
}
for (int i = 0; i < (int)(n); ++i)
good.insert(make_pair(deg[i], i)), isGood[i] = true;
while (!good.empty() && good.begin()->first < k) {
u = good.begin()->second;
for (auto p : adj[u]) {
v = p.first;
if (isGood[v]) {
good.erase(make_pair(deg[v], v));
--deg[v];
good.insert(make_pair(deg[v], v));
}
}
isGood[u] = false;
good.erase(make_pair(deg[u], u));
}
for (int i = (m - 1); i >= (int)(0); --i) {
ans[i] = ((int)((good).size()));
u = edges[i].first, v = edges[i].second;
if (isGood[u] && isGood[v]) {
good.erase(make_pair(deg[u], u));
--deg[u];
good.insert(make_pair(deg[u], u));
good.erase(make_pair(deg[v], v));
--deg[v];
good.insert(make_pair(deg[v], v));
while (!good.empty() && good.begin()->first < k) {
u = good.begin()->second;
for (auto p : adj[u]) {
if (p.second >= i) continue;
v = p.first;
if (isGood[v]) {
good.erase(make_pair(deg[v], v));
--deg[v];
good.insert(make_pair(deg[v], v));
}
}
isGood[u] = false;
good.erase(make_pair(deg[u], u));
}
}
}
for (int i = 0; i < (int)(m); ++i) out << ans[i] << '\n';
cout << out.str();
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.util.*;
import java.io.*;
public class E18 {
public static void main(String[] args) {
MyScanner sc = new MyScanner();
PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
int n = sc.nextInt(); int m = sc.nextInt(); int k = sc.nextInt();
HashSet<Integer> [] adj = new HashSet[n + 1];
for (int i = 1; i <= n; i++) adj[i] = new HashSet<>();
int [][] edge = new int[m][2];
for (int i = 0; i < m; i++) {
int u = sc.nextInt(); int v = sc.nextInt();
edge[i][0] = u; edge[i][1] = v;
adj[u].add(v);
adj[v].add(u);
}
PriorityQueue<Pair> pq = new PriorityQueue<>(Comparator.comparingInt(x -> x.deg));
boolean [] processed = new boolean[n + 1];
int [] in = new int[n + 1];
int [] deg = new int[n + 1];
Arrays.fill(in, -1);
for (int i = 1; i <= n; i++) {
pq.add(new Pair(i, adj[i].size()));
deg[i] = adj[i].size();
}
int vis = 0;
while (!pq.isEmpty() && vis < n) {
Pair next = pq.poll();
if (processed[next.node]) continue;
++vis;
processed[next.node] = true;
if (next.deg >= k) {
in[next.node] = 1;
continue;
}
in[next.node] = 0;
for (Integer i: adj[next.node]) {
if (!processed[i]) {
deg[i]--;
pq.add(new Pair(i, deg[i]));
}
}
}
int [] ret = new int[m];
for (int i = 1; i <= n; i++) ret[m - 1] += in[i];
for (int i = m - 1; i > 0; i--) {
int u = edge[i][0]; int v = edge[i][1];
if (in[v] == 1 && in[u] == 1) deg[u]--;
if (in[v] == 1 && in[u] == 1) deg[v]--;
pq = new PriorityQueue<>(Comparator.comparingInt(x ->x.deg));
if (in[u] == 0 || in[v] == 0) {
ret[i - 1] = ret[i];
adj[u].remove(v);
adj[v].remove(u);
continue;
}
if (deg[u] < k) pq.add(new Pair(u, k - 1));
if (deg[v] < k) pq.add(new Pair(v, k - 1));
int off = 0;
while (!pq.isEmpty()) {
Pair next = pq.poll();
if (in[next.node] == 0 || next.deg >= k) continue;
in[next.node] = 0;
off++;
for (Integer x : adj[next.node]) {
if (in[x] == 1 && !((next.node == u && x == v) || (next.node == v && x == u))) {
deg[x]--;
pq.add(new Pair(x, deg[x]));
}
}
}
adj[u].remove(v);
adj[v].remove(u);
ret[i - 1] = ret[i] - off;
}
for (int i = 0; i < m; i++) out.println(ret[i]);
out.close();
}
static class Pair {
int node; int deg;
Pair(int node, int deg) {
this.node = node; this.deg = deg;
}
}
//-----------MyScanner class for faster input----------
public static class MyScanner {
BufferedReader br;
StringTokenizer st;
public MyScanner() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, m, cnt, k, tot, tp;
int head[200005];
int sta[200005];
int dgr[200005];
int ans[200005];
bool usd[200005];
struct node {
int fr;
int to;
int nxt;
int mrk;
} edge[400005];
void init() {
cnt = 0;
memset(head, -1, sizeof(head));
}
void addedge(int f, int t) {
cnt++;
edge[cnt].fr = f;
edge[cnt].to = t;
edge[cnt].nxt = head[f];
head[f] = cnt;
}
queue<int> que;
int main() {
init();
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
dgr[v]++;
dgr[u]++;
}
for (int i = 1; i <= n; i++) {
if (dgr[i] < k) {
que.push(i);
}
}
tot = n;
tp = m;
while (!que.empty()) {
int u = que.front();
que.pop();
if (usd[u]) continue;
usd[u] = true;
tot--;
for (int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].to;
dgr[v]--;
if (dgr[v] < k) {
que.push(v);
}
}
}
for (int i = cnt - 1; i >= 1; i -= 2) {
ans[tp--] = tot;
int u = edge[i].fr;
int v = edge[i].to;
if (usd[u] || usd[v]) continue;
dgr[u]--, dgr[v]--;
edge[i].mrk = edge[i + 1].mrk = 1;
if (dgr[u] < k) que.push(u);
if (dgr[v] < k) que.push(v);
while (!que.empty()) {
int s = que.front();
que.pop();
if (usd[s]) continue;
usd[s] = true;
tot--;
for (int i = head[s]; i != -1; i = edge[i].nxt) {
if (edge[i].mrk) continue;
int v = edge[i].to;
dgr[v]--;
if (dgr[v] < k) {
que.push(v);
}
}
}
}
for (int i = 1; i <= m; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-16;
int N, M, K;
int edges[200010][2], degree[200010];
set<int> graph[200010];
set<tuple<int, int>> nodes;
int ans[200010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(8) << fixed;
cin >> N >> M >> K;
for (int m = 0; m < M; m++) cin >> edges[m][0] >> edges[m][1];
for (int m = 0; m < M; m++) {
graph[edges[m][0]].insert(edges[m][1]);
graph[edges[m][1]].insert(edges[m][0]);
degree[edges[m][0]]++;
degree[edges[m][1]]++;
}
for (int n = 1; n <= N; n++) {
nodes.insert({degree[n], n});
}
for (int day = M - 1; day >= 0; day--) {
while (nodes.size() && get<0>(*nodes.begin()) < K) {
int cur = get<1>(*nodes.begin());
nodes.erase(nodes.begin());
for (const int &nxt : graph[cur]) {
if (nodes.count({degree[nxt], nxt})) {
nodes.erase({degree[nxt], nxt});
nodes.insert({--degree[nxt], nxt});
}
}
}
if (nodes.empty()) break;
ans[day] = nodes.size();
if (nodes.count({degree[edges[day][0]], edges[day][0]}) &&
nodes.count({degree[edges[day][1]], edges[day][1]})) {
for (int e = 0; e < 2; e++) {
nodes.erase({degree[edges[day][e]], edges[day][e]});
degree[edges[day][e]]--;
nodes.insert({degree[edges[day][e]], edges[day][e]});
graph[edges[day][e]].erase(edges[day][1 - e]);
}
}
}
for (int ai = 0; ai < M; ai++) {
cout << ans[ai] << '\n';
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | import java.io.*;
import java.math.*;
import java.util.*;
import static java.util.Arrays.fill;
import static java.lang.Math.*;
import static java.util.Arrays.sort;
import static java.util.Collections.sort;
public class Trips {
static int mod = 1000000007;
static InputReader in = new InputReader(System.in);
static PrintWriter out = new PrintWriter(System.out);
static int n,m,k;
static HashSet<Integer>[] adjlist;
static boolean[] isact;
static int active=0;
static int[] edge_a;
static int[] edge_b;
static int[] ans;
static int[] deg;
static void disable(int i)
{
if(!isact[i])
return;
if(deg[i]<k)
{
isact[i]=false;
for(int u : adjlist[i])
{
deg[u]--;
disable(u);
}
active--;
}
}
public static void main(String[] args) {
n=in.nextInt();
m=in.nextInt();
k=in.nextInt();
adjlist=new HashSet[n+1];
isact=new boolean[n+1];
Arrays.fill(isact, true);
edge_a=new int[m+1];
edge_b=new int[m+1];
ans=new int[m+1];
deg=new int[n+1];
for(int i=1;i<=n;i++)
{
adjlist[i]=new HashSet<>();
}
for(int i=1;i<=m;i++)
{
int a=in.nextInt();
int b=in.nextInt();
edge_a[i]=a;
edge_b[i]=b;
deg[a]++;
deg[b]++;
adjlist[a].add(b);
adjlist[b].add(a);
}
active=n;
for(int i=1;i<=n;i++)
{
if(deg[i]<k)
{
disable(i);
}
}
ans[m]=active;
for(int i=m;i>=2;i--)
{
int a=edge_a[i];
int b=edge_b[i];
if(isact[b])
deg[a]--;
if(isact[a])
deg[b]--;
adjlist[a].remove(b);
adjlist[b].remove(a);
disable(a);
disable(b);
ans[i-1]=active;
}
for(int i=1;i<=m;i++)
{
out.println(ans[i]);
}
out.close();
}
static class InputReader {
private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
public InputReader(InputStream st) {
this.stream = st;
}
public int read() {
if (snumChars == -1)
throw new InputMismatchException();
if (curChar >= snumChars) {
curChar = 0;
try {
snumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (snumChars <= 0)
return -1;
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String readString() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public String nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
private static void tr(Object... o) {
if (!(System.getProperty("ONLINE_JUDGE") != null))
System.out.println(Arrays.deepToString(o));
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | /* Author: Ronak Agarwal, reader part not written by me*/
import java.io.* ; import java.util.* ;
import static java.lang.Math.min ; import static java.lang.Math.max ;
import static java.lang.Math.abs ; import static java.lang.Math.log ;
import static java.lang.Math.pow ; import static java.lang.Math.sqrt ;
/* Thread is created here to increase the stack size of the java code so that recursive dfs can be performed */
public class Codeshefcode{
public static void main(String[] args) throws IOException{
new Thread(null,new Runnable(){ public void run(){ exec_Code() ;} },"Solver",1l<<27).start() ;
}
static void exec_Code(){
try{
Solver Machine = new Solver() ;
Machine.Solve() ; Machine.Finish() ;}
catch(Exception e){ e.printStackTrace() ; print_and_exit() ;}
catch(Error e){ e.printStackTrace() ; print_and_exit() ; }
}
static void print_and_exit(){ System.out.flush() ; System.exit(-1) ;}
}
/* Implementation of the Reader class */
class Reader {
private InputStream mIs;
private byte[] buf = new byte[1024];
private int curChar,numChars;
public Reader() { this(System.in); }
public Reader(InputStream is) { mIs = is;}
public int read() {
if (numChars == -1) throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}
if (numChars <= 0) return -1;
}
return buf[curChar++];
}
public String nextLine(){
int c = read();
while (isSpaceChar(c)) c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString() ;
}
public String s(){
int c = read();
while (isSpaceChar(c)) c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
}while (!isSpaceChar(c));
return res.toString();
}
public long l(){
int c = read();
while (isSpaceChar(c)) c = read();
int sgn = 1;
if (c == '-') { sgn = -1 ; c = read() ; }
long res = 0;
do{
if (c < '0' || c > '9') throw new InputMismatchException();
res *= 10 ; res += c - '0' ; c = read();
}while(!isSpaceChar(c));
return res * sgn;
}
public int i(){
int c = read() ;
while (isSpaceChar(c)) c = read();
int sgn = 1;
if (c == '-') { sgn = -1 ; c = read() ; }
int res = 0;
do{
if (c < '0' || c > '9') throw new InputMismatchException();
res *= 10 ; res += c - '0' ; c = read() ;
}while(!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
}
/* All the useful functions,constants,renamings are here*/
class Template{
/* Constants Section */
final int INT_MIN = Integer.MIN_VALUE ; final int INT_MAX = Integer.MAX_VALUE ;
final long LONG_MIN = Long.MIN_VALUE ; final long LONG_MAX = Long.MAX_VALUE ;
static long MOD = 1000000007 ;
static Reader ip = new Reader() ;
static PrintWriter op = new PrintWriter(System.out) ;
/* Methods for writing */
static void p(Object o){ op.print(o) ; }
static void pln(Object o){ op.println(o) ;}
static void Finish(){ op.flush(); op.close(); }
/* Implementation of operations modulo MOD */
static long inv(long a){ return powM(a,MOD-2) ; }
static long m(long a,long b){ return (a*b)%MOD ; }
static long d(long a,long b){ return (a*inv(b))%MOD ; }
static long powM(long a,long b){
if(b<0) return powM(inv(a),-b) ;
long ans=1 ;
for( ; b!=0 ; a=(a*a)%MOD , b/=2) if((b&1)==1) ans = (ans*a)%MOD ;
return ans ;
}
/* Renaming of some generic utility classes */
final static class mylist extends ArrayList<Integer>{}
final static class myset extends TreeSet<pair>{}
final static class mystack extends Stack<Integer>{}
final static class mymap extends TreeMap<Integer,Integer>{}
}
/* Implementation of the pair class, useful for every other problem */
class pair implements Comparable<pair>{
int x ; int y ;
pair(int _x,int _y){ x=_x ; y=_y ;}
public int compareTo(pair p){
return (this.x<p.x ? -1 : (this.x>p.x ? 1 : (this.y<p.y ? -1 : (this.y>p.y ? 1 : 0)))) ;
}
}
/* Main code starts here */
class Solver extends Template{
int n,m,k;
myset s;
int d[];
mylist N[];
void correctSet(){
while(!s.isEmpty()){
if(s.first().x>=k) break;
int u = s.pollFirst().y;
for(int v : N[u]) if(s.contains(new pair(d[v],v))){
s.remove(new pair(d[v],v));
d[v]--;
s.add(new pair(d[v],v));
}
}
}
public void Solve() throws IOException{
n = ip.i();
m = ip.i();
k = ip.i();
pair E[] = new pair[m];
N = new mylist[n+1];
d = new int[n+1];
for(int i=1 ; i<=n ; i++) N[i] = new mylist();
for(int i=0 ; i<m ; i++){
int u = ip.i(); int v = ip.i();
E[i] = new pair(u,v);
N[u].add(v); N[v].add(u);
d[u]++; d[v]++;
}
s = new myset();
for(int i=1 ; i<=n ; i++) s.add(new pair(d[i],i));
correctSet();
mylist res = new mylist();
for(int i=(m-1) ; i>=0 ; i--){
res.add(s.size());
int u = E[i].x; int v = E[i].y;
N[u].remove(N[u].size()-1);
N[v].remove(N[v].size()-1);
boolean uins = s.contains(new pair(d[u],u));
boolean vins = s.contains(new pair(d[v],v));
if(!uins || !vins) continue;
s.remove(new pair(d[u],u));
s.remove(new pair(d[v],v));
d[u]--; d[v]--;
s.add(new pair(d[u],u));
s.add(new pair(d[v],v));
correctSet();
}
Collections.reverse(res);
for(int elem : res) pln(elem);
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <class u>
pair<u, u> ordered_pair(const u& a, const u& b) {
return a < b ? make_pair(a, b) : make_pair(b, a);
}
int n, m, k;
set<int> gr[201010];
vector<pair<int, int>> edge_list;
set<pair<int, int>> removed_edges;
struct cmp_deg {
bool operator()(int u, int v) {
return make_pair(((int)gr[u].size()), u) <
make_pair(((int)gr[v].size()), v);
}
};
set<int, cmp_deg> node_set;
void remove_edge(int u, int v) {
node_set.erase(u);
node_set.erase(v);
gr[u].erase(v);
gr[v].erase(u);
node_set.insert(u);
node_set.insert(v);
removed_edges.insert(ordered_pair(u, v));
}
void remove_node(int u) {
while (((int)gr[u].size())) remove_edge(u, *gr[u].begin());
node_set.erase(u);
}
void adjust() {
while (((int)node_set.size()) and ((int)gr[*node_set.begin()].size()) < k) {
remove_node(*node_set.begin());
}
}
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = -1; ++i < m;) {
int u, v;
cin >> u >> v;
gr[u].insert(v);
gr[v].insert(u);
edge_list.push_back(ordered_pair(u, v));
}
for (int i = 0; i++ < n;) node_set.insert(i);
vector<int> ans(m);
for (int i = m; i--;) {
adjust();
ans[i] = ((int)node_set.size());
if (!removed_edges.count(edge_list[i])) {
remove_edge(edge_list[i].first, edge_list[i].second);
}
}
for (auto i : ans) cout << i << '\n';
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
unordered_set<int> e[N];
int n, m, k, ex[N], ey[N], i, ans, ot[N];
bool bb[N];
void del(int x) {
bb[x] = 0;
--ans;
for (int y : e[x]) e[y].erase(x);
for (int y : e[x])
if (bb[y] && e[y].size() < k) del(y);
e[x].clear();
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (i = 1; i <= m; ++i)
cin >> ex[i] >> ey[i], e[ex[i]].insert(ey[i]), e[ey[i]].insert(ex[i]);
memset(bb + 1, 1, n);
ans = n;
for (i = 1; i <= n; ++i)
if (bb[i] && e[i].size() < k) del(i);
for (i = m; i; --i) {
ot[i] = ans;
if (bb[ex[i]] && bb[ey[i]]) {
e[ex[i]].erase(ey[i]);
e[ey[i]].erase(ex[i]);
if (bb[ex[i]] && e[ex[i]].size() < k) del(ex[i]);
if (bb[ey[i]] && e[ey[i]].size() < k) del(ey[i]);
}
}
for (i = 1; i <= m; ++i) cout << ot[i] << '\n';
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T parse(const string &s) {
T x;
stringstream ss(s);
ss >> x;
return x;
}
const double EPS = 1e-12;
const int INF = 1000 * 1000 * 1000;
const long long LINF = INF * 1ll * INF;
const double DINF = 1e200;
const double PI = 3.1415926535897932384626433832795l;
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long gcdex(long long a, long long b, long long &x, long long &y) {
if (!a) {
x = 0, y = 1;
return b;
}
long long k = b / a;
long long g = gcdex(b - k * a, a, y, x);
x -= k * y;
return g;
}
long long inv(long long a, long long m) {
assert(m > 1);
long long x, y, g;
g = gcdex(a, m, x, y);
return (x % (m / g) + m / g) % m / g;
}
long long crt(long long a1, long long m1, long long a2, long long m2) {
long long a = (a2 - a1 % m2 + m2) % m2;
long long x, y, g;
g = gcdex(m1, m2, x, y);
if (a % g) return -1;
long long m = m1 / g * m2;
assert(x + m2 >= 0);
x = a / g * (x + m2) % m2;
long long r = (a1 + x * m1) % m;
assert(r % m1 == a1 && r % m2 == a2);
return r;
}
long long powmod(long long a, long long p, long long m) {
assert(p >= 0);
long long r = 1;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
bool isprime(long long a) {
if (a <= 1) return false;
for (long long i = 2; i * i <= a; ++i) {
if (a % i == 0) return false;
}
return true;
}
long long sqrtup(long long a) {
if (!a) return 0;
long long x = max(0ll, (long long)sqrt((double)a));
while (x * x >= a) --x;
while ((x + 1) * (x + 1) < a) ++x;
return x + 1;
}
long long isqrt(long long a) {
if (a <= 0) {
assert(!a);
return 0;
}
long long x = (long long)sqrt((double)a);
while (sqr(x + 1) <= a) ++x;
while (x * x > a) --x;
return x;
}
long long sgn(long long x) { return x < 0 ? -1 : x > 0 ? 1 : 0; }
template <class T>
ostream &operator<<(ostream &s, const vector<T> &v);
template <class A, class B>
ostream &operator<<(ostream &s, const pair<A, B> &p);
template <class K, class V>
ostream &operator<<(ostream &s, const map<K, V> &m);
template <class T>
ostream &operator<<(ostream &s, const set<T> &m);
template <class T, size_t N>
ostream &operator<<(ostream &s, const array<T, N> &a);
template <class... T>
ostream &operator<<(ostream &s, const tuple<T...> &t);
template <class T>
ostream &operator<<(ostream &s, const vector<T> &v) {
s << '[';
for (int i = 0; i < (((int)(v).size())); ++i) {
if (i) s << ',';
s << v[i];
}
s << ']';
return s;
}
template <class A, class B>
ostream &operator<<(ostream &s, const pair<A, B> &p) {
s << "(" << p.first << "," << p.second << ")";
return s;
}
template <class K, class V>
ostream &operator<<(ostream &s, const map<K, V> &m) {
s << "{";
bool f = false;
for (const auto &it : m) {
if (f) s << ",";
f = true;
s << it.first << ": " << it.second;
}
s << "}";
return s;
}
template <class T>
ostream &operator<<(ostream &s, const set<T> &m) {
s << "{";
bool f = false;
for (const auto &it : m) {
if (f) s << ",";
f = true;
s << it;
}
s << "}";
return s;
}
template <class T>
ostream &operator<<(ostream &s, const multiset<T> &m) {
s << "{";
bool f = false;
for (const auto &it : m) {
if (f) s << ",";
f = true;
s << it;
}
s << "}";
return s;
}
template <class T, class V, class C>
ostream &operator<<(ostream &s, const priority_queue<T, V, C> &q) {
auto a = q;
s << "{";
bool f = false;
while (!a.empty()) {
if (f) s << ",";
f = true;
s << a.top();
a.pop();
}
return s << "}";
}
template <class T, size_t N>
ostream &operator<<(ostream &s, const array<T, N> &a) {
s << '[';
for (int i = 0; i < (((int)(a).size())); ++i) {
if (i) s << ',';
s << a[i];
}
s << ']';
return s;
}
template <class T>
ostream &operator<<(ostream &s, const deque<T> &a) {
s << '[';
for (int i = 0; i < (((int)(a).size())); ++i) {
if (i) s << ',';
s << a[i];
}
s << ']';
return s;
}
template <size_t n, class... T>
struct put1 {
static ostream &put(ostream &s, const tuple<T...> &t) {
s << get<sizeof...(T) - n>(t);
if (n > 1) s << ',';
return put1<n - 1, T...>::put(s, t);
}
};
template <class... T>
struct put1<0, T...> {
static ostream &put(ostream &s, const tuple<T...> &t) { return s; }
};
template <class... T>
ostream &operator<<(ostream &s, const tuple<T...> &t) {
s << "(";
put1<sizeof...(T), T...>::put(s, t);
s << ")";
return s;
}
ostream &put3(ostream &s, const char *, bool) { return s; }
template <class U, class... T>
ostream &put3(ostream &s, const char *f, bool fs, U &&u, T &&...t) {
while (*f == ' ') ++f;
if (!fs) s << ", ";
auto nf = f;
int d = 0;
while (*nf && (*nf != ',' || d)) {
if (*nf == '(')
++d;
else if (*nf == ')')
--d;
++nf;
}
auto nf2 = nf;
while (nf2 > f && *(nf2 - 1) == ' ') --nf;
fs = *f == '"';
if (!fs) {
s.write(f, nf2 - f);
s << "=";
};
s << u;
if (fs) s << ' ';
if (*nf) ++nf;
return put3(s, nf, fs, forward<T>(t)...);
}
int main(int argc, char **argv) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
srand(time(0));
int n, m, k;
cin >> n >> m >> k;
vector<vector<pair<int, int>>> G(n);
vector<int> C(n);
vector<pair<pair<int, int>, pair<int, int>>> E;
for (int i = 0; i < (m); ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
E.push_back(make_pair(make_pair(a, b), make_pair(((int)(G[a]).size()),
((int)(G[b]).size()))));
G[a].push_back(make_pair(b, 1));
G[b].push_back(make_pair(a, 1));
++C[a];
++C[b];
}
vector<short> W(n);
vector<int> Q;
int res = n;
auto doit = [&] {
while (((int)(Q).size())) {
--res;
int v = Q.back();
Q.pop_back();
for (pair<int, int> p : G[v]) {
if (p.second && !W[p.first] && --C[p.first] < k) {
W[p.first] = 1;
Q.push_back(p.first);
}
}
}
};
for (int i = 0; i < (n); ++i) {
if (C[i] < k) {
W[i] = 1;
Q.push_back(i);
}
}
doit();
vector<int> R;
reverse((E).begin(), (E).end());
for (auto e : E) {
R.push_back(res);
if (W[e.first.first] || W[e.first.second]) continue;
G[e.first.first][e.second.first].second = 0;
G[e.first.second][e.second.second].second = 0;
if (--C[e.first.first] < k) {
W[e.first.first] = 1;
Q.push_back(e.first.first);
}
if (--C[e.first.second] < k) {
W[e.first.second] = 1;
Q.push_back(e.first.second);
}
doit();
}
reverse((R).begin(), (R).end());
for (int x : R) cout << x << '\n';
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 200;
int n, m, k, id[N], vis[N], ans[N];
vector<pair<int, int> > g[N];
struct node {
int x, y;
} e[N];
set<pair<int, int> > s;
void change(int x) {
if (vis[x]) return;
auto it = s.lower_bound(make_pair(id[x], x));
pair<int, int> t = *it;
s.erase(it);
t.first--;
id[t.second]--;
s.insert(t);
}
void update(int now) {
while (!s.empty() && (*s.begin()).first < k) {
pair<int, int> t = *s.begin();
vis[t.second] = 1;
s.erase(s.begin());
for (auto pp : g[t.second]) {
if (pp.second > now) break;
int v = pp.first;
if (vis[v]) continue;
auto it = s.lower_bound(make_pair(id[v], v));
t = *it;
s.erase(it);
id[v]--;
t.first--;
s.insert(t);
}
}
}
bool cmp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> e[i].x >> e[i].y;
g[e[i].x].push_back(make_pair(e[i].y, i));
g[e[i].y].push_back(make_pair(e[i].x, i));
id[e[i].x]++;
id[e[i].y]++;
}
for (int i = 1; i <= n; i++) sort(g[i].begin(), g[i].end(), cmp);
for (int i = 1; i <= n; i++) s.insert(make_pair(id[i], i));
for (int i = m; i >= 1; i--) {
update(i);
ans[i] = s.size();
if (vis[e[i].x] || vis[e[i].y]) continue;
int l = id[e[i].x], r = id[e[i].y];
change(e[i].x);
change(e[i].y);
}
for (int i = 1; i <= m; i++) cout << ans[i] << endl;
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
int n, m, k, ans;
std::set<int> g[200005];
std::vector<std::pair<int, int> > qr;
bool deleted[200005];
void check(int v) {
if (deleted[v] || g[v].size() >= k) return;
deleted[v] = true;
ans--;
for (auto &i : g[v]) g[i].erase(v);
for (auto &i : g[v]) check(i);
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> m >> k;
ans = n;
for (int i = 0; i < (m); ++i) {
int a, b;
std::cin >> a >> b;
a--;
b--;
qr.push_back({a, b});
g[a].insert(b);
g[b].insert(a);
}
for (int i = 0; i < (n); ++i) check(i);
std::reverse(qr.begin(), qr.end());
std::vector<int> ret;
ret.push_back(ans);
for (int i = 0; i < (m - 1); ++i) {
g[qr[i].first].erase(qr[i].second);
g[qr[i].second].erase(qr[i].first);
check(qr[i].first);
check(qr[i].second);
ret.push_back(ans);
}
for (int i = 0; i < (m); ++i) std::cout << ret[m - i - 1] << "\n";
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int N = 2e5 + 5;
int n, m, k;
vector<pair<int, int>> edge;
set<int> adj[N];
bool gone[N];
vector<int> res;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
edge.emplace_back(x, y);
adj[x].emplace(y);
adj[y].emplace(x);
}
set<pair<int, int>> deg;
for (int i = 1; i <= n; i++) {
deg.emplace((int)adj[i].size(), i);
}
for (int i = m - 1; i >= 0; i--) {
while (!deg.empty() && ((deg.begin())->first < k)) {
auto cur = *deg.begin();
deg.erase(deg.begin());
int del = cur.second;
gone[del] = true;
for (auto j : adj[del]) {
if (gone[j]) continue;
deg.erase(make_pair((int)adj[j].size(), j));
adj[j].erase(del);
deg.emplace((int)adj[j].size(), j);
}
}
res.emplace_back((int)deg.size());
auto now = edge[i];
int a = now.first, b = now.second;
if (!gone[a]) {
deg.erase(make_pair((int)adj[a].size(), a));
adj[a].erase(b);
deg.emplace((int)adj[a].size(), a);
}
if (!gone[b]) {
deg.erase(make_pair((int)adj[b].size(), b));
adj[b].erase(a);
deg.emplace((int)adj[b].size(), b);
}
}
reverse(res.begin(), res.end());
for (auto i : res) {
cout << i << '\n';
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
long long binpow(long long a, long long n, long long mod) {
long long ans = 1;
while (n) {
if (n & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
n >>= 1;
}
return ans;
}
long long binpow(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans *= a;
a *= a;
n >>= 1;
}
return ans;
}
vector<long long> pr;
void PrDoX(long long x) {
if (pr.size() > 0) return;
vector<long long> p(x + 1);
for (long long i = 2; i <= x; i++) {
if (p[i] == 0) {
pr.push_back(i);
for (long long j = i + i; j <= x; j += i) p[j] = 1;
}
}
}
vector<long long> fact(long long x) {
PrDoX(sqrt(1e10));
vector<long long> ans;
long long i = 0, c = sqrt(x), n = pr.size();
while (x > 1 and pr[i] <= c and i < n) {
if (x % pr[i] == 0) {
x /= pr[i];
ans.push_back(pr[i]);
c = sqrt(x);
} else
i++;
}
if (x != 1) ans.push_back(x);
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
vector<long long> p(n + 1);
vector<pair<long long, long long> > v;
vector<vector<long long> > g(n + 1);
long long ans = 0;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
p[a]++;
p[b]++;
v.push_back({a, b});
ans += (p[a] == k) + (p[b] == k);
}
queue<long long> q;
for (long long i = 1; i <= n; i++)
if (p[i] > 0 and p[i] < k) q.push(i);
vector<bool> fl(n + 1);
while (!q.empty()) {
long long a = q.front();
q.pop();
if (fl[a] == 1) continue;
fl[a] = 1;
vector<long long> v = g[a];
long long n = v.size();
for (long long i = 0; i < n; i++) {
long long b = v[i];
if (fl[b] == 1) continue;
p[b]--;
if (p[b] == k - 1) ans--, q.push(b);
}
}
vector<long long> an;
an.push_back(ans);
for (long long i = 1; i <= n; i++) sort(g[i].begin(), g[i].end());
for (long long i = m - 1; i > 0; i--) {
long long a = v[i].first, b = v[i].second;
if (fl[a] or fl[b] == 1) {
an.push_back(ans);
continue;
}
p[a]--;
p[b]--;
g[a].erase(lower_bound(g[a].begin(), g[a].end(), b));
g[b].erase(lower_bound(g[b].begin(), g[b].end(), a));
queue<long long> q;
bool F = 0;
if (p[a] == k - 1) q.push(a), ans--;
if (p[b] == k - 1) q.push(b), ans--;
while (!q.empty()) {
long long a0 = q.front();
q.pop();
if (fl[a0] == 1) continue;
fl[a0] = 1;
vector<long long> v = g[a0];
long long n = v.size();
for (long long i = 0; i < n; i++) {
long long b0 = v[i];
if ((a0 == a and b0 == b) or (a0 == b and b0 == a)) continue;
if (fl[b0] == 1) continue;
p[b0]--;
if (p[b0] == k - 1) ans--, q.push(b0);
}
}
an.push_back(ans);
}
for (long long i = m - 1; i >= 0; i--) cout << an[i] << "\n";
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | java | //package baobab;
import java.io.*;
import java.util.*;
public class E {
public static void main(String[] args) {
Solver solver = new Solver();
}
static class Solver {
IO io;
public Solver() {
this.io = new IO();
try {
solve();
} catch (RuntimeException e) {
if (!e.getMessage().equals("Clean exit")) {
throw e;
}
} finally {
io.close();
}
}
/****************************** START READING HERE ********************************/
void solve() {
List<Integer> ans = new ArrayList<>();
int n = io.nextInt();
int m = io.nextInt();
int k = io.nextInt();
int[] c = new int[n+1];
Set<Integer>[] g = new HashSet[n+1];
for (int i=1; i<=n; i++) g[i] = new HashSet<>();
List<Integer> friends = new ArrayList<>(2*m);
for (int i=0; i<m; i++) {
int x = io.nextInt();
int y = io.nextInt();
c[x]++;
c[y]++;
friends.add(x);
friends.add(y);
g[x].add(y);
g[y].add(x);
}
boolean[] removed = new boolean[n+1];
Deque<Integer> q = new ArrayDeque<>();
for (int i=1; i<=n; i++) {
if (c[i] < k) {
q.addLast(i);
}
}
int count = n;
while (!q.isEmpty()) {
Integer i = q.pollFirst();
if (removed[i]) continue;
removed[i] = true;
c[i] = 0;
count--;
for (int neighbor : g[i]) {
c[neighbor]--;
if (c[neighbor] < k && !removed[neighbor]) q.addLast(neighbor);
}
}
for (int i=friends.size()-1; i>=1;) {
ans.add(count);
int a = friends.get(i--);
int b = friends.get(i--);
if (removed[a] || removed[b]) continue;
c[a]--;
c[b]--;
g[a].remove(b);
g[b].remove(a);
if (c[a] < k) q.addLast(a);
if (c[b] < k) q.addLast(b);
while (!q.isEmpty()) {
Integer curr = q.pollFirst();
if (removed[curr]) continue;
removed[curr] = true;
c[curr] = 0;
count--;
for (int neighbor : g[curr]) {
c[neighbor]--;
if (c[neighbor] < k && !removed[neighbor]) q.addLast(neighbor);
}
}
}
for (int i=ans.size()-1; i>=0; i--) {
io.println(ans.get(i));
}
}
/************************** UTILITY CODE BELOW THIS LINE **************************/
long MOD = (long)1e9 + 7;
boolean closeToZero(double v) {
// Check if double is close to zero, considering precision issues.
return Math.abs(v) <= 0.0000000000001;
}
class DrawGrid {
void draw(boolean[][] d) {
System.out.print(" ");
for (int x=0; x<d[0].length; x++) {
System.out.print(" " + x + " ");
}
System.out.println("");
for (int y=0; y<d.length; y++) {
System.out.print(y + " ");
for (int x=0; x<d[0].length; x++) {
System.out.print((d[y][x] ? "[x]" : "[ ]"));
}
System.out.println("");
}
}
void draw(int[][] d) {
int max = 1;
for (int y=0; y<d.length; y++) {
for (int x=0; x<d[0].length; x++) {
max = Math.max(max, ("" + d[y][x]).length());
}
}
System.out.print(" ");
String format = "%" + (max+2) + "s";
for (int x=0; x<d[0].length; x++) {
System.out.print(String.format(format, x) + " ");
}
format = "%" + (max) + "s";
System.out.println("");
for (int y=0; y<d.length; y++) {
System.out.print(y + " ");
for (int x=0; x<d[0].length; x++) {
System.out.print(" [" + String.format(format, (d[y][x])) + "]");
}
System.out.println("");
}
}
}
class IDval implements Comparable<IDval> {
int id;
long val;
public IDval(int id, long val) {
this.val = val;
this.id = id;
}
@Override
public int compareTo(IDval o) {
if (this.val < o.val) return -1;
if (this.val > o.val) return 1;
return this.id - o.id;
}
}
private class ElementCounter {
private HashMap<Long, Integer> elements;
public ElementCounter() {
elements = new HashMap<>();
}
public void add(long element) {
int count = 1;
Integer prev = elements.get(element);
if (prev != null) count += prev;
elements.put(element, count);
}
public void remove(long element) {
int count = elements.remove(element);
count--;
if (count > 0) elements.put(element, count);
}
public int get(long element) {
Integer val = elements.get(element);
if (val == null) return 0;
return val;
}
public int size() {
return elements.size();
}
}
class StringCounter {
HashMap<String, Integer> elements;
public StringCounter() {
elements = new HashMap<>();
}
public void add(String identifier) {
int count = 1;
Integer prev = elements.get(identifier);
if (prev != null) count += prev;
elements.put(identifier, count);
}
public void remove(String identifier) {
int count = elements.remove(identifier);
count--;
if (count > 0) elements.put(identifier, count);
}
public long get(String identifier) {
Integer val = elements.get(identifier);
if (val == null) return 0;
return val;
}
public int size() {
return elements.size();
}
}
class DisjointSet {
/** Union Find / Disjoint Set data structure. */
int[] size;
int[] parent;
int componentCount;
public DisjointSet(int n) {
componentCount = n;
size = new int[n];
parent = new int[n];
for (int i=0; i<n; i++) parent[i] = i;
for (int i=0; i<n; i++) size[i] = 1;
}
public void join(int a, int b) {
/* Find roots */
int rootA = parent[a];
int rootB = parent[b];
while (rootA != parent[rootA]) rootA = parent[rootA];
while (rootB != parent[rootB]) rootB = parent[rootB];
if (rootA == rootB) {
/* Already in the same set */
return;
}
/* Merge smaller set into larger set. */
if (size[rootA] > size[rootB]) {
size[rootA] += size[rootB];
parent[rootB] = rootA;
} else {
size[rootB] += size[rootA];
parent[rootA] = rootB;
}
componentCount--;
}
}
class Trie {
int N;
int Z;
int nextFreeId;
int[][] pointers;
boolean[] end;
/** maxLenSum = maximum possible sum of length of words */
public Trie(int maxLenSum, int alphabetSize) {
this.N = maxLenSum;
this.Z = alphabetSize;
this.nextFreeId = 1;
pointers = new int[N+1][alphabetSize];
end = new boolean[N+1];
}
public void addWord(String word) {
int curr = 0;
for (int j=0; j<word.length(); j++) {
int c = word.charAt(j) - 'a';
int next = pointers[curr][c];
if (next == 0) {
next = nextFreeId++;
pointers[curr][c] = next;
}
curr = next;
}
end[curr] = true;
}
public boolean hasWord(String word) {
int curr = 0;
for (int j=0; j<word.length(); j++) {
int c = word.charAt(j) - 'a';
int next = pointers[curr][c];
if (next == 0) return false;
curr = next;
}
return end[curr];
}
}
private static class Prob {
/** For heavy calculations on probabilities, this class
* provides more accuracy & efficiency than doubles.
* Math explained: https://en.wikipedia.org/wiki/Log_probability
* Quick start:
* - Instantiate probabilities, eg. Prob a = new Prob(0.75)
* - add(), multiply() return new objects, can perform on nulls & NaNs.
* - get() returns probability as a readable double */
/** Logarithmized probability. Note: 0% represented by logP NaN. */
private double logP;
/** Construct instance with real probability. */
public Prob(double real) {
if (real > 0) this.logP = Math.log(real);
else this.logP = Double.NaN;
}
/** Construct instance with already logarithmized value. */
static boolean dontLogAgain = true;
public Prob(double logP, boolean anyBooleanHereToChooseThisConstructor) {
this.logP = logP;
}
/** Returns real probability as a double. */
public double get() {
return Math.exp(logP);
}
@Override
public String toString() {
return ""+get();
}
/***************** STATIC METHODS BELOW ********************/
/** Note: returns NaN only when a && b are both NaN/null. */
public static Prob add(Prob a, Prob b) {
if (nullOrNaN(a) && nullOrNaN(b)) return new Prob(Double.NaN, dontLogAgain);
if (nullOrNaN(a)) return copy(b);
if (nullOrNaN(b)) return copy(a);
double x = Math.max(a.logP, b.logP);
double y = Math.min(a.logP, b.logP);
double sum = x + Math.log(1 + Math.exp(y - x));
return new Prob(sum, dontLogAgain);
}
/** Note: multiplying by null or NaN produces NaN (repping 0% real prob). */
public static Prob multiply(Prob a, Prob b) {
if (nullOrNaN(a) || nullOrNaN(b)) return new Prob(Double.NaN, dontLogAgain);
return new Prob(a.logP + b.logP, dontLogAgain);
}
/** Returns true if p is null or NaN. */
private static boolean nullOrNaN(Prob p) {
return (p == null || Double.isNaN(p.logP));
}
/** Returns a new instance with the same value as original. */
private static Prob copy(Prob original) {
return new Prob(original.logP, dontLogAgain);
}
}
class Binary implements Comparable<Binary> {
/**
* Use example: Binary b = new Binary(Long.toBinaryString(53249834L));
*
* When manipulating small binary strings, instantiate new Binary(string)
* When just reading large binary strings, instantiate new Binary(string,true)
* get(int i) returns a character '1' or '0', not an int.
*/
private boolean[] d;
private int first; // Starting from left, the first (most remarkable) '1'
public int length;
public Binary(String binaryString) {
this(binaryString, false);
}
public Binary(String binaryString, boolean initWithMinArraySize) {
length = binaryString.length();
int size = Math.max(2*length, 1);
first = length/4;
if (initWithMinArraySize) {
first = 0;
size = Math.max(length, 1);
}
d = new boolean[size];
for (int i=0; i<length; i++) {
if (binaryString.charAt(i) == '1') d[i+first] = true;
}
}
public void addFirst(char c) {
if (first-1 < 0) doubleArraySize();
first--;
d[first] = (c == '1' ? true : false);
length++;
}
public void addLast(char c) {
if (first+length >= d.length) doubleArraySize();
d[first+length] = (c == '1' ? true : false);
length++;
}
private void doubleArraySize() {
boolean[] bigArray = new boolean[(d.length+1) * 2];
int newFirst = bigArray.length / 4;
for (int i=0; i<length; i++) {
bigArray[i + newFirst] = d[i + first];
}
first = newFirst;
d = bigArray;
}
public boolean flip(int i) {
boolean value = (this.d[first+i] ? false : true);
this.d[first+i] = value;
return value;
}
public void set(int i, char c) {
boolean value = (c == '1' ? true : false);
this.d[first+i] = value;
}
public char get(int i) {
return (this.d[first+i] ? '1' : '0');
}
@Override
public int compareTo(Binary o) {
if (this.length != o.length) return this.length - o.length;
int len = this.length;
for (int i=0; i<len; i++) {
int diff = this.get(i) - o.get(i);
if (diff != 0) return diff;
}
return 0;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
for (int i=0; i<length; i++) {
sb.append(d[i+first] ? '1' : '0');
}
return sb.toString();
}
}
/************************** Range queries **************************/
class FenwickMin {
long n;
long[] original;
long[] bottomUp;
long[] topDown;
public FenwickMin(int n) {
this.n = n;
original = new long[n+2];
bottomUp = new long[n+2];
topDown = new long[n+2];
}
public void set(int modifiedNode, long value) {
long replaced = original[modifiedNode];
original[modifiedNode] = value;
// Update left tree
int i = modifiedNode;
long v = value;
while (i <= n) {
if (v > bottomUp[i]) {
if (replaced == bottomUp[i]) {
v = Math.min(v, original[i]);
for (int r=1 ;; r++) {
int x = (i&-i)>>>r;
if (x == 0) break;
int child = i-x;
v = Math.min(v, bottomUp[child]);
}
} else break;
}
if (v == bottomUp[i]) break;
bottomUp[i] = v;
i += (i&-i);
}
// Update right tree
i = modifiedNode;
v = value;
while (i > 0) {
if (v > topDown[i]) {
if (replaced == topDown[i]) {
v = Math.min(v, original[i]);
for (int r=1 ;; r++) {
int x = (i&-i)>>>r;
if (x == 0) break;
int child = i+x;
if (child > n+1) break;
v = Math.min(v, topDown[child]);
}
} else break;
}
if (v == topDown[i]) break;
topDown[i] = v;
i -= (i&-i);
}
}
public long getMin(int a, int b) {
long min = original[a];
int prev = a;
int curr = prev + (prev&-prev); // parent right hand side
while (curr <= b) {
min = Math.min(min, topDown[prev]); // value from the other tree
prev = curr;
curr = prev + (prev&-prev);;
}
min = Math.min(min, original[prev]);
prev = b;
curr = prev - (prev&-prev); // parent left hand side
while (curr >= a) {
min = Math.min(min,bottomUp[prev]); // value from the other tree
prev = curr;
curr = prev - (prev&-prev);
}
return min;
}
}
class FenwickSum {
public long[] d;
public FenwickSum(int n) {
d=new long[n+1];
}
/** a[0] must be unused. */
public FenwickSum(long[] a) {
d=new long[a.length];
for (int i=1; i<a.length; i++) {
modify(i, a[i]);
}
}
/** Do not modify i=0. */
void modify(int i, long v) {
while (i<d.length) {
d[i] += v;
// Move to next uplink on the RIGHT side of i
i += (i&-i);
}
}
/** Returns sum from a to b, *BOTH* inclusive. */
long getSum(int a, int b) {
return getSum(b) - getSum(a-1);
}
private long getSum(int i) {
long sum = 0;
while (i>0) {
sum += d[i];
// Move to next uplink on the LEFT side of i
i -= (i&-i);
}
return sum;
}
}
class SegmentTree {
/* Provides log(n) operations for:
* - Range query (sum, min or max)
* - Range update ("+8 to all values between indexes 4 and 94")
*/
int N;
long[] lazy;
long[] sum;
long[] min;
long[] max;
boolean supportSum;
boolean supportMin;
boolean supportMax;
public SegmentTree(int n) {
this(n, true, true, true);
}
public SegmentTree(int n, boolean supportSum, boolean supportMin, boolean supportMax) {
for (N=2; N<n;) N*=2;
this.lazy = new long[2*N];
this.supportSum = supportSum;
this.supportMin = supportMin;
this.supportMax = supportMax;
if (this.supportSum) this.sum = new long[2*N];
if (this.supportMin) this.min = new long[2*N];
if (this.supportMax) this.max = new long[2*N];
}
void modifyRange(long x, int a, int b) {
modifyRec(a, b, 1, 0, N-1, x);
}
void setRange() {
//TODO
}
long getSum(int a, int b) {
return querySum(a, b, 1, 0, N-1);
}
long getMin(int a, int b) {
return queryMin(a, b, 1, 0, N-1);
}
long getMax(int a, int b) {
return queryMax(a, b, 1, 0, N-1);
}
private long querySum(int wantedLeft, int wantedRight, int i, int actualLeft, int actualRight) {
if (wantedLeft > actualRight || wantedRight < actualLeft) {
return 0;
}
if (wantedLeft == actualLeft && wantedRight == actualRight) {
int count = wantedRight - wantedLeft + 1;
return sum[i] + count * lazy[i];
}
if (lazy[i] != 0) propagate(i, actualLeft, actualRight);
int d = (actualRight - actualLeft + 1) / 2;
long left = querySum(wantedLeft, min(actualLeft+d-1, wantedRight), 2*i, actualLeft, actualLeft+d-1);
long right = querySum(max(actualLeft+d, wantedLeft), wantedRight, 2*i+1, actualLeft+d, actualRight);
return left + right;
}
private long queryMin(int wantedLeft, int wantedRight, int i, int actualLeft, int actualRight) {
if (wantedLeft > actualRight || wantedRight < actualLeft) {
return 0;
}
if (wantedLeft == actualLeft && wantedRight == actualRight) {
return min[i] + lazy[i];
}
if (lazy[i] != 0) propagate(i, actualLeft, actualRight);
int d = (actualRight - actualLeft + 1) / 2;
long left = queryMin(wantedLeft, min(actualLeft+d-1, wantedRight), 2*i, actualLeft, actualLeft+d-1);
long right = queryMin(max(actualLeft+d, wantedLeft), wantedRight, 2*i+1, actualLeft+d, actualRight);
return min(left, right);
}
private long queryMax(int wantedLeft, int wantedRight, int i, int actualLeft, int actualRight) {
if (wantedLeft > actualRight || wantedRight < actualLeft) {
return 0;
}
if (wantedLeft == actualLeft && wantedRight == actualRight) {
return max[i] + lazy[i];
}
if (lazy[i] != 0) propagate(i, actualLeft, actualRight);
int d = (actualRight - actualLeft + 1) / 2;
long left = queryMax(wantedLeft, min(actualLeft+d-1, wantedRight), 2*i, actualLeft, actualLeft+d-1);
long right = queryMax(max(actualLeft+d, wantedLeft), wantedRight, 2*i+1, actualLeft+d, actualRight);
return max(left, right);
}
private void modifyRec(int wantedLeft, int wantedRight, int i, int actualLeft, int actualRight, long value) {
if (wantedLeft > actualRight || wantedRight < actualLeft) {
return;
}
if (wantedLeft == actualLeft && wantedRight == actualRight) {
lazy[i] += value;
return;
}
if (lazy[i] != 0) propagate(i, actualLeft, actualRight);
int d = (actualRight - actualLeft + 1) / 2;
modifyRec(wantedLeft, min(actualLeft+d-1, wantedRight), 2*i, actualLeft, actualLeft+d-1, value);
modifyRec(max(actualLeft+d, wantedLeft), wantedRight, 2*i+1, actualLeft+d, actualRight, value);
if (supportSum) sum[i] += value * (min(actualRight, wantedRight) - max(actualLeft, wantedLeft) + 1);
if (supportMin) min[i] = min(min[2*i] + lazy[2*i], min[2*i+1] + lazy[2*i+1]);
if (supportMax) max[i] = max(max[2*i] + lazy[2*i], max[2*i+1] + lazy[2*i+1]);
}
private void propagate(int i, int actualLeft, int actualRight) {
lazy[2*i] += lazy[i];
lazy[2*i+1] += lazy[i];
if (supportSum) sum[i] += lazy[i] * (actualRight - actualLeft + 1);
if (supportMin) min[i] += lazy[i];
if (supportMax) max[i] += lazy[i];
lazy[i] = 0;
}
}
/***************************** Graphs *****************************/
List<Integer>[] toGraph(IO io, int n) {
List<Integer>[] g = new ArrayList[n+1];
for (int i=1; i<=n; i++) g[i] = new ArrayList<>();
for (int i=1; i<=n-1; i++) {
int a = io.nextInt();
int b = io.nextInt();
g[a].add(b);
g[b].add(a);
}
return g;
}
class Graph {
HashMap<Long, List<Long>> edges;
public Graph() {
edges = new HashMap<>();
}
List<Long> getSetNeighbors(Long node) {
List<Long> neighbors = edges.get(node);
if (neighbors == null) {
neighbors = new ArrayList<>();
edges.put(node, neighbors);
}
return neighbors;
}
void addBiEdge(Long a, Long b) {
addEdge(a, b);
addEdge(b, a);
}
void addEdge(Long from, Long to) {
getSetNeighbors(to); // make sure all have initialized lists
List<Long> neighbors = getSetNeighbors(from);
neighbors.add(to);
}
// topoSort variables
int UNTOUCHED = 0;
int FINISHED = 2;
int INPROGRESS = 1;
HashMap<Long, Integer> vis;
List<Long> topoAns;
List<Long> failDueToCycle = new ArrayList<Long>() {{ add(-1L); }};
List<Long> topoSort() {
topoAns = new ArrayList<>();
vis = new HashMap<>();
for (Long a : edges.keySet()) {
if (!topoDFS(a)) return failDueToCycle;
}
Collections.reverse(topoAns);
return topoAns;
}
boolean topoDFS(long curr) {
Integer status = vis.get(curr);
if (status == null) status = UNTOUCHED;
if (status == FINISHED) return true;
if (status == INPROGRESS) {
return false;
}
vis.put(curr, INPROGRESS);
for (long next : edges.get(curr)) {
if (!topoDFS(next)) return false;
}
vis.put(curr, FINISHED);
topoAns.add(curr);
return true;
}
}
public class StronglyConnectedComponents {
/** Kosaraju's algorithm */
ArrayList<Integer>[] forw;
ArrayList<Integer>[] bacw;
/** Use: getCount(2, new int[] {1,2}, new int[] {2,1}) */
public int getCount(int n, int[] mista, int[] minne) {
forw = new ArrayList[n+1];
bacw = new ArrayList[n+1];
for (int i=1; i<=n; i++) {
forw[i] = new ArrayList<Integer>();
bacw[i] = new ArrayList<Integer>();
}
for (int i=0; i<mista.length; i++) {
int a = mista[i];
int b = minne[i];
forw[a].add(b);
bacw[b].add(a);
}
int count = 0;
List<Integer> list = new ArrayList<Integer>();
boolean[] visited = new boolean[n+1];
for (int i=1; i<=n; i++) {
dfsForward(i, visited, list);
}
visited = new boolean[n+1];
for (int i=n-1; i>=0; i--) {
int node = list.get(i);
if (visited[node]) continue;
count++;
dfsBackward(node, visited);
}
return count;
}
public void dfsForward(int i, boolean[] visited, List<Integer> list) {
if (visited[i]) return;
visited[i] = true;
for (int neighbor : forw[i]) {
dfsForward(neighbor, visited, list);
}
list.add(i);
}
public void dfsBackward(int i, boolean[] visited) {
if (visited[i]) return;
visited[i] = true;
for (int neighbor : bacw[i]) {
dfsBackward(neighbor, visited);
}
}
}
class LCAFinder {
/* O(n log n) Initialize: new LCAFinder(graph)
* O(log n) Queries: find(a,b) returns lowest common ancestor for nodes a and b */
int[] nodes;
int[] depths;
int[] entries;
int pointer;
FenwickMin fenwick;
public LCAFinder(List<Integer>[] graph) {
this.nodes = new int[(int)10e6];
this.depths = new int[(int)10e6];
this.entries = new int[graph.length];
this.pointer = 1;
boolean[] visited = new boolean[graph.length+1];
dfs(1, 0, graph, visited);
fenwick = new FenwickMin(pointer-1);
for (int i=1; i<pointer; i++) {
fenwick.set(i, depths[i] * 1000000L + i);
}
}
private void dfs(int node, int depth, List<Integer>[] graph, boolean[] visited) {
visited[node] = true;
entries[node] = pointer;
nodes[pointer] = node;
depths[pointer] = depth;
pointer++;
for (int neighbor : graph[node]) {
if (visited[neighbor]) continue;
dfs(neighbor, depth+1, graph, visited);
nodes[pointer] = node;
depths[pointer] = depth;
pointer++;
}
}
public int find(int a, int b) {
int left = entries[a];
int right = entries[b];
if (left > right) {
int temp = left;
left = right;
right = temp;
}
long mixedBag = fenwick.getMin(left, right);
int index = (int) (mixedBag % 1000000L);
return nodes[index];
}
}
/**************************** Geometry ****************************/
class Point {
int y;
int x;
public Point(int y, int x) {
this.y = y;
this.x = x;
}
}
boolean segmentsIntersect(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
// Returns true if segment 1-2 intersects segment 3-4
if (x1 == x2 && x3 == x4) {
// Both segments are vertical
if (x1 != x3) return false;
if (min(y1,y2) < min(y3,y4)) {
return max(y1,y2) >= min(y3,y4);
} else {
return max(y3,y4) >= min(y1,y2);
}
}
if (x1 == x2) {
// Only segment 1-2 is vertical. Does segment 3-4 cross it? y = a*x + b
double a34 = (y4-y3)/(x4-x3);
double b34 = y3 - a34*x3;
double y = a34 * x1 + b34;
return y >= min(y1,y2) && y <= max(y1,y2) && x1 >= min(x3,x4) && x1 <= max(x3,x4);
}
if (x3 == x4) {
// Only segment 3-4 is vertical. Does segment 1-2 cross it? y = a*x + b
double a12 = (y2-y1)/(x2-x1);
double b12 = y1 - a12*x1;
double y = a12 * x3 + b12;
return y >= min(y3,y4) && y <= max(y3,y4) && x3 >= min(x1,x2) && x3 <= max(x1,x2);
}
double a12 = (y2-y1)/(x2-x1);
double b12 = y1 - a12*x1;
double a34 = (y4-y3)/(x4-x3);
double b34 = y3 - a34*x3;
if (closeToZero(a12 - a34)) {
// Parallel lines
return closeToZero(b12 - b34);
}
// Non parallel non vertical lines intersect at x. Is x part of both segments?
double x = -(b12-b34)/(a12-a34);
return x >= min(x1,x2) && x <= max(x1,x2) && x >= min(x3,x4) && x <= max(x3,x4);
}
boolean pointInsideRectangle(Point p, List<Point> r) {
Point a = r.get(0);
Point b = r.get(1);
Point c = r.get(2);
Point d = r.get(3);
double apd = areaOfTriangle(a, p, d);
double dpc = areaOfTriangle(d, p, c);
double cpb = areaOfTriangle(c, p, b);
double pba = areaOfTriangle(p, b, a);
double sumOfAreas = apd + dpc + cpb + pba;
if (closeToZero(sumOfAreas - areaOfRectangle(r))) {
if (closeToZero(apd) || closeToZero(dpc) || closeToZero(cpb) || closeToZero(pba)) {
return false;
}
return true;
}
return false;
}
double areaOfTriangle(Point a, Point b, Point c) {
return 0.5 * Math.abs((a.x-c.x)*(b.y-a.y)-(a.x-b.x)*(c.y-a.y));
}
double areaOfRectangle(List<Point> r) {
double side1xDiff = r.get(0).x - r.get(1).x;
double side1yDiff = r.get(0).y - r.get(1).y;
double side2xDiff = r.get(1).x - r.get(2).x;
double side2yDiff = r.get(1).y - r.get(2).y;
double side1 = Math.sqrt(side1xDiff * side1xDiff + side1yDiff * side1yDiff);
double side2 = Math.sqrt(side2xDiff * side2xDiff + side2yDiff * side2yDiff);
return side1 * side2;
}
boolean pointsOnSameLine(double x1, double y1, double x2, double y2, double x3, double y3) {
double areaTimes2 = x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2);
return (closeToZero(areaTimes2));
}
class PointToLineSegmentDistanceCalculator {
// Just call this
double minDistFromPointToLineSegment(double point_x, double point_y, double x1, double y1, double x2, double y2) {
return Math.sqrt(distToSegmentSquared(point_x, point_y, x1, y1, x2, y2));
}
private double distToSegmentSquared(double point_x, double point_y, double x1, double y1, double x2, double y2) {
double l2 = dist2(x1,y1,x2,y2);
if (l2 == 0) return dist2(point_x, point_y, x1, y1);
double t = ((point_x - x1) * (x2 - x1) + (point_y - y1) * (y2 - y1)) / l2;
if (t < 0) return dist2(point_x, point_y, x1, y1);
if (t > 1) return dist2(point_x, point_y, x2, y2);
double com_x = x1 + t * (x2 - x1);
double com_y = y1 + t * (y2 - y1);
return dist2(point_x, point_y, com_x, com_y);
}
private double dist2(double x1, double y1, double x2, double y2) {
return Math.pow((x1 - x2), 2) + Math.pow((y1 - y2), 2);
}
}
/****************************** Math ******************************/
long pow(long base, int exp) {
if (exp == 0) return 1L;
long x = pow(base, exp/2);
long ans = x * x;
if (exp % 2 != 0) ans *= base;
return ans;
}
long gcd(long... v) {
/** Chained calls to Euclidean algorithm. */
if (v.length == 1) return v[0];
long ans = gcd(v[1], v[0]);
for (int i=2; i<v.length; i++) {
ans = gcd(ans, v[i]);
}
return ans;
}
long gcd(long a, long b) {
/** Euclidean algorithm. */
if (b == 0) return a;
return gcd(b, a%b);
}
int[] generatePrimesUpTo(int last) {
/* Sieve of Eratosthenes. Practically O(n). Values of 0 indicate primes. */
int[] div = new int[last+1];
for (int x=2; x<=last; x++) {
if (div[x] > 0) continue;
for (int u=2*x; u<=last; u+=x) {
div[u] = x;
}
}
return div;
}
long lcm(long a, long b) {
/** Least common multiple */
return a * b / gcd(a,b);
}
class BaseConverter {
/* Palauttaa luvun esityksen kannassa base */
public String convert(Long number, int base) {
return Long.toString(number, base);
}
/* Palauttaa luvun esityksen kannassa baseTo, kun annetaan luku Stringinä kannassa baseFrom */
public String convert(String number, int baseFrom, int baseTo) {
return Long.toString(Long.parseLong(number, baseFrom), baseTo);
}
/* Tulkitsee kannassa base esitetyn luvun longiksi (kannassa 10) */
public long longify(String number, int baseFrom) {
return Long.parseLong(number, baseFrom);
}
}
class BinomialCoefficients {
/** Total number of K sized unique combinations from pool of size N (unordered)
N! / ( K! (N - K)! ) */
/** For simple queries where output fits in long. */
public long biCo(long n, long k) {
long r = 1;
if (k > n) return 0;
for (long d = 1; d <= k; d++) {
r *= n--;
r /= d;
}
return r;
}
/** For multiple queries with same n, different k. */
public long[] precalcBinomialCoefficientsK(int n, int maxK) {
long v[] = new long[maxK+1];
v[0] = 1; // nC0 == 1
for (int i=1; i<=n; i++) {
for (int j=Math.min(i,maxK); j>0; j--) {
v[j] = v[j] + v[j-1]; // Pascal's triangle
}
}
return v;
}
/** When output needs % MOD. */
public long[] precalcBinomialCoefficientsK(int n, int k, long M) {
long v[] = new long[k+1];
v[0] = 1; // nC0 == 1
for (int i=1; i<=n; i++) {
for (int j=Math.min(i,k); j>0; j--) {
v[j] = v[j] + v[j-1]; // Pascal's triangle
v[j] %= M;
}
}
return v;
}
}
/**************************** Strings ****************************/
class Zalgo {
public int pisinEsiintyma(String haku, String kohde) {
char[] s = new char[haku.length() + 1 + kohde.length()];
for (int i=0; i<haku.length(); i++) {
s[i] = haku.charAt(i);
}
int j = haku.length();
s[j++] = '#';
for (int i=0; i<kohde.length(); i++) {
s[j++] = kohde.charAt(i);
}
int[] z = toZarray(s);
int max = 0;
for (int i=haku.length(); i<z.length; i++) {
max = Math.max(max, z[i]);
}
return max;
}
public int[] toZarray(char[] s) {
int n = s.length;
int[] z = new int[n];
int a = 0, b = 0;
for (int i = 1; i < n; i++) {
if (i > b) {
for (int j = i; j < n && s[j - i] == s[j]; j++) z[i]++;
}
else {
z[i] = z[i - a];
if (i + z[i - a] > b) {
for (int j = b + 1; j < n && s[j - i] == s[j]; j++) z[i]++;
a = i;
b = i + z[i] - 1;
}
}
}
return z;
}
public List<Integer> getStartIndexesWhereWordIsFound(String haku, String kohde) {
// this is alternative use case
char[] s = new char[haku.length() + 1 + kohde.length()];
for (int i=0; i<haku.length(); i++) {
s[i] = haku.charAt(i);
}
int j = haku.length();
s[j++] = '#';
for (int i=0; i<kohde.length(); i++) {
s[j++] = kohde.charAt(i);
}
int[] z = toZarray(s);
List<Integer> indexes = new ArrayList<>();
for (int i=haku.length(); i<z.length; i++) {
if (z[i] < haku.length()) continue;
indexes.add(i);
}
return indexes;
}
}
class StringHasher {
class HashedString {
long[] hashes;
long[] modifiers;
public HashedString(long[] hashes, long[] modifiers) {
this.hashes = hashes;
this.modifiers = modifiers;
}
}
long P;
long M;
public StringHasher() {
initializePandM();
}
HashedString hashString(String s) {
int n = s.length();
long[] hashes = new long[n];
long[] modifiers = new long[n];
hashes[0] = s.charAt(0);
modifiers[0] = 1;
for (int i=1; i<n; i++) {
hashes[i] = (hashes[i-1] * P + s.charAt(i)) % M;
modifiers[i] = (modifiers[i-1] * P) % M;
}
return new HashedString(hashes, modifiers);
}
/**
* Indices are inclusive.
*/
long getHash(HashedString hashedString, int startIndex, int endIndex) {
long[] hashes = hashedString.hashes;
long[] modifiers = hashedString.modifiers;
long result = hashes[endIndex];
if (startIndex > 0) result -= (hashes[startIndex-1] * modifiers[endIndex-startIndex+1]) % M;
if (result < 0) result += M;
return result;
}
// Less interesting methods below
/**
* Efficient for 2 input parameter strings in particular.
*/
HashedString[] hashString(String first, String second) {
HashedString[] array = new HashedString[2];
int n = first.length();
long[] modifiers = new long[n];
modifiers[0] = 1;
long[] firstHashes = new long[n];
firstHashes[0] = first.charAt(0);
array[0] = new HashedString(firstHashes, modifiers);
long[] secondHashes = new long[n];
secondHashes[0] = second.charAt(0);
array[1] = new HashedString(secondHashes, modifiers);
for (int i=1; i<n; i++) {
modifiers[i] = (modifiers[i-1] * P) % M;
firstHashes[i] = (firstHashes[i-1] * P + first.charAt(i)) % M;
secondHashes[i] = (secondHashes[i-1] * P + second.charAt(i)) % M;
}
return array;
}
/**
* Efficient for 3+ strings
* More efficient than multiple hashString calls IF strings are same length.
*/
HashedString[] hashString(String... strings) {
HashedString[] array = new HashedString[strings.length];
int n = strings[0].length();
long[] modifiers = new long[n];
modifiers[0] = 1;
for (int j=0; j<strings.length; j++) {
// if all strings are not same length, defer work to another method
if (strings[j].length() != n) {
for (int i=0; i<n; i++) {
array[i] = hashString(strings[i]);
}
return array;
}
// otherwise initialize stuff
long[] hashes = new long[n];
hashes[0] = strings[j].charAt(0);
array[j] = new HashedString(hashes, modifiers);
}
for (int i=1; i<n; i++) {
modifiers[i] = (modifiers[i-1] * P) % M;
for (int j=0; j<strings.length; j++) {
String s = strings[j];
long[] hashes = array[j].hashes;
hashes[i] = (hashes[i-1] * P + s.charAt(i)) % M;
}
}
return array;
}
void initializePandM() {
ArrayList<Long> modOptions = new ArrayList<>(20);
modOptions.add(353873237L);
modOptions.add(353875897L);
modOptions.add(353878703L);
modOptions.add(353882671L);
modOptions.add(353885303L);
modOptions.add(353888377L);
modOptions.add(353893457L);
P = modOptions.get(new Random().nextInt(modOptions.size()));
modOptions.clear();
modOptions.add(452940277L);
modOptions.add(452947687L);
modOptions.add(464478431L);
modOptions.add(468098221L);
modOptions.add(470374601L);
modOptions.add(472879717L);
modOptions.add(472881973L);
M = modOptions.get(new Random().nextInt(modOptions.size()));
}
}
/*************************** Technical ***************************/
private class IO extends PrintWriter {
private InputStreamReader r;
private static final int BUFSIZE = 1 << 15;
private char[] buf;
private int bufc;
private int bufi;
private StringBuilder sb;
public IO() {
super(new BufferedOutputStream(System.out));
r = new InputStreamReader(System.in);
buf = new char[BUFSIZE];
bufc = 0;
bufi = 0;
sb = new StringBuilder();
}
/** Print, flush, return nextInt. */
private int queryInt(String s) {
io.println(s);
io.flush();
return nextInt();
}
/** Print, flush, return nextLong. */
private long queryLong(String s) {
io.println(s);
io.flush();
return nextLong();
}
/** Print, flush, return next word. */
private String queryNext(String s) {
io.println(s);
io.flush();
return next();
}
private void fillBuf() throws IOException {
bufi = 0;
bufc = 0;
while(bufc == 0) {
bufc = r.read(buf, 0, BUFSIZE);
if(bufc == -1) {
bufc = 0;
return;
}
}
}
private boolean pumpBuf() throws IOException {
if(bufi == bufc) {
fillBuf();
}
return bufc != 0;
}
private boolean isDelimiter(char c) {
return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
}
private void eatDelimiters() throws IOException {
while(true) {
if(bufi == bufc) {
fillBuf();
if(bufc == 0) throw new RuntimeException("IO: Out of input.");
}
if(!isDelimiter(buf[bufi])) break;
++bufi;
}
}
public String next() {
try {
sb.setLength(0);
eatDelimiters();
int start = bufi;
while(true) {
if(bufi == bufc) {
sb.append(buf, start, bufi - start);
fillBuf();
start = 0;
if(bufc == 0) break;
}
if(isDelimiter(buf[bufi])) break;
++bufi;
}
sb.append(buf, start, bufi - start);
return sb.toString();
} catch(IOException e) {
throw new RuntimeException("IO.next: Caught IOException.");
}
}
public int nextInt() {
try {
int ret = 0;
eatDelimiters();
boolean positive = true;
if(buf[bufi] == '-') {
++bufi;
if(!pumpBuf()) throw new RuntimeException("IO.nextInt: Invalid int.");
positive = false;
}
boolean first = true;
while(true) {
if(!pumpBuf()) break;
if(isDelimiter(buf[bufi])) {
if(first) throw new RuntimeException("IO.nextInt: Invalid int.");
break;
}
first = false;
if(buf[bufi] >= '0' && buf[bufi] <= '9') {
if(ret < -214748364) throw new RuntimeException("IO.nextInt: Invalid int.");
ret *= 10;
ret -= (int)(buf[bufi] - '0');
if(ret > 0) throw new RuntimeException("IO.nextInt: Invalid int.");
} else {
throw new RuntimeException("IO.nextInt: Invalid int.");
}
++bufi;
}
if(positive) {
if(ret == -2147483648) throw new RuntimeException("IO.nextInt: Invalid int.");
ret = -ret;
}
return ret;
} catch(IOException e) {
throw new RuntimeException("IO.nextInt: Caught IOException.");
}
}
public long nextLong() {
try {
long ret = 0;
eatDelimiters();
boolean positive = true;
if(buf[bufi] == '-') {
++bufi;
if(!pumpBuf()) throw new RuntimeException("IO.nextLong: Invalid long.");
positive = false;
}
boolean first = true;
while(true) {
if(!pumpBuf()) break;
if(isDelimiter(buf[bufi])) {
if(first) throw new RuntimeException("IO.nextLong: Invalid long.");
break;
}
first = false;
if(buf[bufi] >= '0' && buf[bufi] <= '9') {
if(ret < -922337203685477580L) throw new RuntimeException("IO.nextLong: Invalid long.");
ret *= 10;
ret -= (long)(buf[bufi] - '0');
if(ret > 0) throw new RuntimeException("IO.nextLong: Invalid long.");
} else {
throw new RuntimeException("IO.nextLong: Invalid long.");
}
++bufi;
}
if(positive) {
if(ret == -9223372036854775808L) throw new RuntimeException("IO.nextLong: Invalid long.");
ret = -ret;
}
return ret;
} catch(IOException e) {
throw new RuntimeException("IO.nextLong: Caught IOException.");
}
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
void print(Object output) {
io.println(output);
}
void done(Object output) {
print(output);
done();
}
void done() {
io.close();
throw new RuntimeException("Clean exit");
}
long min(long... v) {
long ans = v[0];
for (int i=1; i<v.length; i++) {
ans = Math.min(ans, v[i]);
}
return ans;
}
double min(double... v) {
double ans = v[0];
for (int i=1; i<v.length; i++) {
ans = Math.min(ans, v[i]);
}
return ans;
}
int min(int... v) {
int ans = v[0];
for (int i=1; i<v.length; i++) {
ans = Math.min(ans, v[i]);
}
return ans;
}
long max(long... v) {
long ans = v[0];
for (int i=1; i<v.length; i++) {
ans = Math.max(ans, v[i]);
}
return ans;
}
double max(double... v) {
double ans = v[0];
for (int i=1; i<v.length; i++) {
ans = Math.max(ans, v[i]);
}
return ans;
}
int max(int... v) {
int ans = v[0];
for (int i=1; i<v.length; i++) {
ans = Math.max(ans, v[i]);
}
return ans;
}
}
} |
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
pair<int, int> edge[200000 + 324];
vector<int> adj[200000 + 324];
set<int> degree[200000 + 324];
set<int> friends;
int ans[200000 + 324];
int k;
void rem(int x) {
set<int> elem_to_remove;
for (auto bc : degree[x]) {
elem_to_remove.insert(bc);
degree[bc].erase(x);
}
degree[x].erase(degree[x].begin(), degree[x].end());
friends.erase(x);
for (auto bc : elem_to_remove) {
if (degree[bc].size() < k) {
rem(bc);
}
}
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> edge[i].first >> edge[i].second;
degree[edge[i].first].insert(edge[i].second);
degree[edge[i].second].insert(edge[i].first);
}
for (int i = 1; i <= n; i++) {
if (degree[i].size() >= k) {
friends.insert(i);
} else {
friends.insert(i);
rem(i);
}
}
for (int i = m - 1; i >= 0; i--) {
ans[i] = friends.size();
degree[edge[i].first].erase(edge[i].second);
degree[edge[i].second].erase(edge[i].first);
if (degree[edge[i].first].size() < k) {
rem(edge[i].first);
}
if (degree[edge[i].second].size() < k) {
rem(edge[i].second);
}
}
for (int i = 0; i < m; i++) cout << ans[i] << " ";
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int maxN = 1e6 + 10;
priority_queue<int> P;
priority_queue<int, vector<int>, greater<int> > mP;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int mod = 1000 * 1000 * 1000 + 7;
long long ksm(int a, int b) {
if (b == 0) return 1LL;
long long ret = 1, pp = a;
while (b) {
if (b % 2 == 1) {
ret *= pp;
ret %= mod;
}
b /= 2;
pp = pp * pp % mod;
}
return ret;
}
int bit[maxN];
int lowbit(int x) { return x & (-x); }
void update(int i, int v) {
while (i < maxN) {
bit[i] += v;
i += lowbit(i);
}
}
int getsum(int i) {
int x = 0;
while (i > 0) {
x += bit[i];
i -= lowbit(i);
}
return x;
}
void change(int a, int b, int k) {
update(a, k);
update(b + 1, -k);
}
int father[maxN];
void init(int n) {
for (int i = 1; i <= n; i++) father[i] = i;
return;
}
int find(int v) {
if (father[v] == v)
return v;
else
return father[v] = find(father[v]);
}
void merge(int v, int u) {
int t1 = find(v);
int t2 = find(u);
father[t2] = t1;
return;
}
long long hashing(string s) {
long long ans[2] = {1, 1};
int p[2] = {402653189, 1610612741};
for (int j = 0; j < 2; j++) {
for (int i = 0; i < s.size(); i++) {
ans[j] = ((ans[j] * 257) + s[i] - 'a') % p[j];
}
}
return ans[0] * 2e10 + ans[1];
}
int e[maxN][2];
set<int> edge[maxN];
int cnt;
int n, m, k;
void del(queue<int>& q) {
while (!q.empty()) {
int i = q.front();
q.pop();
for (auto v : edge[i]) {
if (edge[v].size() == k) {
q.push(v);
cnt--;
}
edge[v].erase(i);
}
edge[i].clear();
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> m >> k;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
e[i][0] = x;
e[i][1] = y;
edge[x].insert(y);
edge[y].insert(x);
}
cnt = n;
queue<int> q;
for (int i = 1; i <= n; i++) {
if (edge[i].size() < k) {
q.push(i);
cnt--;
}
}
del(q);
vector<int> ans;
for (int i = m; i >= 1; i--) {
ans.push_back(cnt);
int x = e[i][0], y = e[i][1];
queue<int> q;
if (edge[x].find(y) != edge[x].end() && edge[x].size() == k) {
q.push(x);
edge[x].erase(y);
cnt--;
}
edge[x].erase(y);
if (edge[y].find(x) != edge[y].end() && edge[y].size() == k) {
q.push(y);
edge[y].erase(x);
cnt--;
}
edge[y].erase(x);
del(q);
}
reverse(ans.begin(), ans.end());
for (auto c : ans) cout << c << endl;
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, m, k;
set<pair<int, int>> S;
vector<int> A;
vector<pair<int, int>> R;
vector<vector<int>> G;
set<pair<int, int>> B;
int main() {
cin >> n >> m >> k;
R.assign(m, {0, 0});
A.assign(n, 0);
G.assign(n, vector<int>(0, 0));
for (auto &i : R) {
cin >> i.first >> i.second;
i.first--;
i.second--;
G[i.first].push_back(i.second);
G[i.second].push_back(i.first);
A[i.first]++;
A[i.second]++;
}
for (int i = 0; i < n; i++) {
S.insert({A[i], i});
}
while (S.size() && (*S.begin()).first < k) {
int x = (*S.begin()).second;
S.erase(S.begin());
for (int y : G[x]) {
if (A[y] == -1) continue;
S.erase(S.find({A[y], y}));
A[y]--;
S.insert({A[y], y});
}
A[x] = -1;
}
vector<int> Ans(m, 0);
for (int i = m - 1; i >= 0; i--) {
Ans[i] = S.size();
int x, y;
x = R[i].first;
y = R[i].second;
B.insert({x, y});
B.insert({y, x});
if (A[x] != -1 && A[y] != -1) {
S.erase(S.find({A[x], x}));
A[x]--;
S.insert({A[x], x});
S.erase(S.find({A[y], y}));
A[y]--;
S.insert({A[y], y});
}
while (!S.empty() && (*S.begin()).first < k) {
int X = (*S.begin()).second;
S.erase(S.begin());
for (int Y : G[X]) {
if (A[Y] == -1 || B.count({X, Y})) continue;
S.erase(S.find({A[Y], Y}));
A[Y]--;
S.insert({A[Y], Y});
}
A[X] = -1;
}
}
for (int i : Ans) {
cout << i << "\n";
}
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | 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;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, m, k, x[200001], y[200001], ans[200001];
set<int> d[200001], s;
queue<int> q;
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++)
scanf("%d%d", &x[i], &y[i]), d[x[i]].insert(y[i]), d[y[i]].insert(x[i]);
for (int i = 1; i <= n; i++)
if (d[i].size() < k) q.push(i);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (auto nxt : d[cur]) {
d[nxt].erase(cur);
if (d[nxt].size() < k) q.push(nxt);
}
d[cur].clear();
}
for (int i = 1; i <= n; i++)
if (d[i].size() >= k) s.insert(i);
for (int i = m; i >= 1; i--) {
ans[i] = s.size();
if (d[x[i]].count(y[i])) {
d[x[i]].erase(y[i]);
d[y[i]].erase(x[i]);
if (d[x[i]].size() < k) q.push(x[i]);
if (d[y[i]].size() < k) q.push(y[i]);
}
while (!q.empty()) {
int cur = q.front();
q.pop();
for (auto nxt : d[cur]) {
d[nxt].erase(cur);
if (d[nxt].size() < k) q.push(nxt);
}
d[cur].clear(), s.erase(cur);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
void decreaseKey(set<pair<int, int> > &pairs, map<int, set<int> > &data,
int decKey, int remVert) {
pair<int, int> removePair;
removePair.first = data[decKey].size();
removePair.second = decKey;
pairs.erase(removePair);
data[decKey].erase(remVert);
pair<int, int> newPair;
newPair.first = data[decKey].size();
newPair.second = decKey;
if (newPair.first != 0) {
pairs.insert(newPair);
}
}
void deleteUnusedPairs(set<pair<int, int> > &pairs, map<int, set<int> > &data,
pair<int, int> &cheker) {
vector<int> rem;
rem.clear();
vector<pair<int, int> > delet;
delet.clear();
for (set<pair<int, int> >::iterator iter = pairs.begin();
iter != pairs.lower_bound(cheker); iter++) {
pair<int, int> curr = *iter;
rem.push_back(curr.second);
delet.push_back(*iter);
}
for (int i = 0; i < delet.size(); i++) {
pairs.erase(delet[i]);
}
for (int j = 0; j < rem.size(); j++) {
for (set<int>::iterator iter = data[rem[j]].begin();
iter != data[rem[j]].end(); iter++) {
decreaseKey(pairs, data, *iter, rem[j]);
}
data.erase(rem[j]);
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
map<int, set<int> > data;
set<pair<int, int> > pairs;
vector<int> pairsArr;
vector<int> result;
int x, y;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
data[x].insert(y);
data[y].insert(x);
pairsArr.push_back(x);
pairsArr.push_back(y);
}
for (int i = 1; i <= n; i++) {
if (data.count(i) > 0) {
pair<int, int> p;
p.first = data[i].size();
p.second = i;
pairs.insert(p);
}
}
for (int i = 1; i <= m; i++) {
pair<int, int> cheker;
cheker.first = k;
cheker.second = -20;
while (pairs.size() != 0 && (*(pairs.begin())).first < k) {
deleteUnusedPairs(pairs, data, cheker);
}
result.push_back(pairs.size());
int currX = pairsArr.back();
pairsArr.pop_back();
int currY = pairsArr.back();
pairsArr.pop_back();
decreaseKey(pairs, data, currX, currY);
decreaseKey(pairs, data, currY, currX);
}
for (int i = result.size() - 1; i >= 0; i--) {
printf("%d\n", result[i]);
}
return 0;
}
|
1037_E. Trips | There are n persons who initially don't know each other. On each morning, two of them, who were not friends before, become friends.
We want to plan a trip for every evening of m days. On each trip, you have to select a group of people that will go on the trip. For every person, one of the following should hold:
* Either this person does not go on the trip,
* Or at least k of his friends also go on the trip.
Note that the friendship is not transitive. That is, if a and b are friends and b and c are friends, it does not necessarily imply that a and c are friends.
For each day, find the maximum number of people that can go on the trip on that day.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ k < n) — the number of people, the number of days and the number of friends each person on the trip should have in the group.
The i-th (1 ≤ i ≤ m) of the next m lines contains two integers x and y (1≤ x, y≤ n, x≠ y), meaning that persons x and y become friends on the morning of day i. It is guaranteed that x and y were not friends before.
Output
Print exactly m lines, where the i-th of them (1≤ i≤ m) contains the maximum number of people that can go on the trip on the evening of the day i.
Examples
Input
4 4 2
2 3
1 2
1 3
1 4
Output
0
0
3
3
Input
5 8 2
2 1
4 2
5 4
5 2
4 3
5 1
4 1
3 2
Output
0
0
0
3
3
4
4
5
Input
5 7 2
1 5
3 2
2 5
3 4
1 2
5 3
1 3
Output
0
0
0
0
3
4
4
Note
In the first example,
* 1,2,3 can go on day 3 and 4.
In the second example,
* 2,4,5 can go on day 4 and 5.
* 1,2,4,5 can go on day 6 and 7.
* 1,2,3,4,5 can go on day 8.
In the third example,
* 1,2,5 can go on day 5.
* 1,2,3,5 can go on day 6 and 7. | {
"input": [
"4 4 2\n2 3\n1 2\n1 3\n1 4\n",
"5 8 2\n2 1\n4 2\n5 4\n5 2\n4 3\n5 1\n4 1\n3 2\n",
"5 7 2\n1 5\n3 2\n2 5\n3 4\n1 2\n5 3\n1 3\n"
],
"output": [
"0\n0\n3\n3\n",
"0\n0\n0\n3\n3\n4\n4\n5\n",
"0\n0\n0\n0\n3\n4\n4\n"
]
} | {
"input": [
"16 20 2\n10 3\n5 3\n10 5\n12 7\n7 6\n9 12\n9 6\n1 10\n11 16\n11 1\n16 2\n10 2\n14 4\n15 14\n4 13\n13 15\n1 8\n7 15\n1 7\n8 15\n",
"2 1 1\n2 1\n"
],
"output": [
"0\n0\n3\n3\n3\n3\n7\n7\n7\n7\n7\n11\n11\n11\n11\n15\n15\n15\n15\n16\n",
"2\n"
]
} | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
int n, m, k;
vector<pair<int, int> > veze;
vector<pair<int, int> > graf[MAXN];
void load() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
veze.push_back(pair<int, int>(a, b));
graf[a].push_back(pair<int, int>(b, i));
graf[b].push_back(pair<int, int>(a, i));
}
}
int deg[MAXN];
set<pair<int, int> > S;
void printSet() {
for (auto it = S.begin(); it != S.end(); it++) {
printf("%d : %d\n", it->second, it->first);
}
printf("\n");
}
void solve() {
for (int i = 0; i < m; i++) {
deg[veze[i].first]++;
deg[veze[i].second]++;
}
for (int i = 0; i < n; i++) S.insert(pair<int, int>(deg[i], i));
while (!S.empty() && S.begin()->first < k) {
int v = S.begin()->second;
S.erase(pair<int, int>(deg[v], v));
for (pair<int, int> p : graf[v]) {
int u = p.first;
if (S.find(pair<int, int>(deg[u], u)) == S.end()) continue;
S.erase(pair<int, int>(deg[u], u));
deg[u]--;
S.insert(pair<int, int>(deg[u], u));
}
}
vector<int> sol;
for (int i = m - 1; i >= 0; i--) {
sol.push_back(S.size());
int a = veze[i].first;
int b = veze[i].second;
if (S.find(pair<int, int>(deg[a], a)) != S.end() &&
S.find(pair<int, int>(deg[b], b)) != S.end()) {
S.erase(pair<int, int>(deg[a], a));
S.erase(pair<int, int>(deg[b], b));
deg[a]--;
deg[b]--;
S.insert(pair<int, int>(deg[a], a));
S.insert(pair<int, int>(deg[b], b));
while (!S.empty() && S.begin()->first < k) {
int v = S.begin()->second;
S.erase(pair<int, int>(deg[v], v));
for (pair<int, int> p : graf[v]) {
if (p.second >= i) continue;
int u = p.first;
if (S.find(pair<int, int>(deg[u], u)) == S.end()) continue;
S.erase(pair<int, int>(deg[u], u));
deg[u]--;
S.insert(pair<int, int>(deg[u], u));
}
}
}
}
for (int i = m - 1; i >= 0; i--) printf("%d\n", sol[i]);
}
int main() {
load();
solve();
return 0;
}
|
Subsets and Splits