problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k | fixed_code stringlengths 12 526k | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M | fixed_submission_id int64 2 1.54M | user_id stringlengths 10 10 | language stringclasses 8
values |
|---|---|---|---|---|---|---|---|
p03043 | #include <bits/stdc++.h>
using namespace std;
#define C continue;
#define R return;
#define D double
#define ll long long
#define ld long double
#define ull unsigned long long
#define pb push_back
#define vi vector<int>
#define vc vector<char>
#define vs vector<string>
#define vb vector<bool>
#define vd vector<D>
#d... | #include <bits/stdc++.h>
using namespace std;
#define C continue;
#define R return;
#define D double
#define ll long long
#define ld long double
#define ull unsigned long long
#define pb push_back
#define vi vector<int>
#define vc vector<char>
#define vs vector<string>
#define vb vector<bool>
#define vd vector<D>
#d... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 862,517 | 862,518 | u389438219 | cpp |
p03043 | #include <assert.h>
#include <bits/stdc++.h>
#include <time.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// s... | #include <assert.h>
#include <bits/stdc++.h>
#include <time.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// s... | [
"literal.number.change",
"io.output.change"
] | 862,519 | 862,520 | u375267383 | cpp |
p03043 | #include <assert.h>
#include <bits/stdc++.h>
#include <time.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// s... | #include <assert.h>
#include <bits/stdc++.h>
#include <time.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// s... | [
"literal.number.change",
"io.output.change"
] | 862,521 | 862,520 | u375267383 | cpp |
p03043 | #include <assert.h>
#include <bits/stdc++.h>
#include <time.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// s... | #include <assert.h>
#include <bits/stdc++.h>
#include <time.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// s... | [
"literal.number.change",
"io.output.change",
"expression.operation.binary.remove"
] | 862,522 | 862,520 | u375267383 | cpp |
p03043 | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define ... | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)m; i < (int)n; ++i)
#define ... | [
"io.output.change"
] | 862,523 | 862,524 | u906208439 | cpp |
p03043 | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "un... | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "un... | [
"assignment.add"
] | 862,527 | 862,528 | u468700753 | cpp |
p03043 | #include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (k <= 1) {
cout << 100 << endl;
return (0);
}
double a = 0;
if (n >= k) {
a = n - k + 1;
}
int b = a;
double c = n;
int d = 2;
while (1) {
int x =... | #include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
if (k <= 1) {
cout << 1 << endl;
return (0);
}
double a = 0;
if (n >= k) {
a = n - k + 1;
}
int b = a;
double c = n;
int d = 2;
while (1) {
int x = (... | [
"literal.number.change",
"io.output.change"
] | 862,529 | 862,530 | u504696228 | cpp |
p03043 | #include <bits/stdc++.h>
using namespace std;
int main() {
double N, K;
cin >> N >> K;
double p = 0.0;
for (int x = 1; x <= N; ++x) {
for (int a = 0; a < 1000000; ++a) {
if (x * pow(2, a) > K) {
p += pow(0.5, a) / N;
break;
}
}
}
cout << setprecision(10) << p << endl;... | #include <bits/stdc++.h>
using namespace std;
int main() {
double N, K;
cin >> N >> K;
double p = 0.0;
for (int x = 1; x <= N; ++x) {
for (int a = 0; a < 1000000; ++a) {
if (x * pow(2, a) >= K) {
p += pow(0.5, a) / N;
break;
}
}
}
cout << setprecision(10) << p << endl... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 862,531 | 862,532 | u095136435 | cpp |
p03043 | #include <bits/stdc++.h>
using namespace std;
int main() {
double N, K;
cin >> N >> K;
double p = 0.0;
for (int x = 1; x <= N; ++x) {
for (int a = 0; a < 1000000; ++a) {
if (x * pow(2, a) > K) {
p += pow(0.5, a) / N;
break;
}
}
}
cout << setprecision(12) << p << endl;... | #include <bits/stdc++.h>
using namespace std;
int main() {
double N, K;
cin >> N >> K;
double p = 0.0;
for (int x = 1; x <= N; ++x) {
for (int a = 0; a < 1000000; ++a) {
if (x * pow(2, a) >= K) {
p += pow(0.5, a) / N;
break;
}
}
}
cout << setprecision(10) << p << endl... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.number.change",
"io.output.change"
] | 862,533 | 862,532 | u095136435 | cpp |
p03043 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int num = 1;
double pro = 0;
for (int i = 1; i <= n; ++i) {
double part_pro = 1.0 / n;
int num = 1;
for (; (num * i) <= k; num = (num << 1)) {
part_pro *= 0.5;
}
pro += part_pro;
}
cout << set... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int num = 1;
double pro = 0;
for (int i = 1; i <= n; ++i) {
double part_pro = 1.0 / n;
int num = 1;
for (; (num * i) < k; num = (num << 1)) {
part_pro *= 0.5;
}
pro += part_pro;
}
cout << setp... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 862,547 | 862,548 | u627431737 | cpp |
p03043 | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <functional>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
#include <iomanip>
#define pv(val) cerr << #val << '=' << (val) << endl
#define pvn(n... | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <functional>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
#include <iomanip>
#define pv(val) cerr << #val << '=' << (val) << endl
#define pvn(n... | [
"type_conversion.add"
] | 862,549 | 862,550 | u967620300 | cpp |
p03043 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define M... | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define M... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 862,596 | 862,597 | u236433947 | cpp |
p03043 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define M... | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define M... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 862,598 | 862,597 | u236433947 | cpp |
p03043 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using std::swap;
double t = 0.0;
int N, K;
double che(int x) {
int n = 1;
while (1) {
x *= 2;
if (x >= K)
break;
++n;
}
return n;
}
int main() {
double p;
... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using std::swap;
double t = 0.0;
double N, K;
double che(int x) {
double n = 1;
while (1) {
x *= 2;
if (x >= K)
break;
++n;
}
return n;
}
int main() {
doubl... | [
"variable_declaration.type.primitive.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 862,599 | 862,600 | u196471026 | cpp |
p03043 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
typedef long long ll;
typedef pair<int, ll> pll;
vector<pll> g[N];
int n;
ll d[N];
int a[N];
int main() {
int n, k;
cin >> n >> k;
double ans = 0.0;
for (int i = 1; i <= n; i++) {
double pro = 1.0;
int cur = i;
while (cur <= ... | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
typedef long long ll;
typedef pair<int, ll> pll;
vector<pll> g[N];
int n;
ll d[N];
int a[N];
int main() {
int n, k;
cin >> n >> k;
double ans = 0.0;
for (int i = 1; i <= n; i++) {
double pro = 1.0;
int cur = i;
while (cur < k... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 862,622 | 862,623 | u208440216 | cpp |
p03043 | #include <cmath>
#include <iomanip>
#include <iostream>
using namespace std;
int main() {
int n, k;
double win_p = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int e = 0;
while (i * pow(2.0, e) <= k) {
e++;
}
win_p += (1.0 / n) * pow((1.0 / 2), e);
}
cout << std::setprecision(12) <... | #include <cmath>
#include <iomanip>
#include <iostream>
using namespace std;
int main() {
int n, k;
long double win_p = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int e = 0;
while (i * pow(2.0, e) < k) {
e++;
}
win_p += (1.0 / n) * pow((1.0 / 2), e);
}
cout << std::setprecision(1... | [
"variable_declaration.type.widen.change",
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 862,633 | 862,634 | u312025627 | cpp |
p03043 | #include <cmath>
#include <iomanip>
#include <iostream>
using namespace std;
int main() {
int n, k;
double win_p = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int e = 0;
while (i * pow(2.0, e) <= k) {
e++;
}
win_p += (1.0 / n) * pow((1.0 / 2), e);
}
cout << std::setprecision(12) <... | #include <cmath>
#include <iomanip>
#include <iostream>
using namespace std;
int main() {
int n, k;
double win_p = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int e = 0;
while (i * pow(2.0, e) < k) {
e++;
}
win_p += (1.0 / n) * pow((1.0 / 2), e);
}
cout << std::setprecision(12) <<... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 862,633 | 862,635 | u312025627 | cpp |
p03043 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pll pair<ll, ll>
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define M 1101
#define MOD 1000000007
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define all(v) v.begin(), v.end()
#define... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pll pair<ll, ll>
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define M 1101
#define MOD 1000000007
#define fi first
#define se second
#define vi vector<int>
#define vl vector<ll>
#define all(v) v.begin(), v.end()
#define... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 862,641 | 862,642 | u456070059 | cpp |
p03043 | #include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <s... | #include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <s... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 862,647 | 862,648 | u298980954 | cpp |
p03043 | /*
ID: Aman Raj
LANG: C++
TASK: milk3
*/
#include <iostream>
#include <stdio.h>
//#include<iostream>
#include <algorithm>
#include <vector>
using namespace std;
#include <math.h>
typedef long long ll;
#include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
... | /*
ID: Aman Raj
LANG: C++
TASK: milk3
*/
#include <iostream>
#include <stdio.h>
//#include<iostream>
#include <algorithm>
#include <vector>
using namespace std;
#include <math.h>
typedef long long ll;
#include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
... | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 862,659 | 862,660 | u756289568 | cpp |
p03043 | /*
ID: Aman Raj
LANG: C++
TASK: milk3
*/
#include <iostream>
#include <stdio.h>
//#include<iostream>
#include <algorithm>
#include <vector>
using namespace std;
#include <math.h>
typedef long long ll;
#include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
... | /*
ID: Aman Raj
LANG: C++
TASK: milk3
*/
#include <iostream>
#include <stdio.h>
//#include<iostream>
#include <algorithm>
#include <vector>
using namespace std;
#include <math.h>
typedef long long ll;
#include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
... | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operator.compare.change",
"control_flow.loop.condition.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 862,661 | 862,660 | u756289568 | cpp |
p03043 | #include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> k;
double cnt = 0;
for (int i = 1; i <= n; ++i... | #include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int n, k;
cin >> n >> k;
double cnt = 0;
for (int i = 1; i <= n; ++i... | [
"call.add",
"call.arguments.change"
] | 862,662 | 862,663 | u625725849 | cpp |
p03043 | #include <bits/stdc++.h>
using namespace std;
double solve(int N, int K) {
double res = 0;
for (int i = 1; i <= N; i++) {
int point = i;
double ansd = 1;
while (K > point) {
ansd *= 0.50;
point += point;
}
ansd *= (1.0 / N);
res += ansd;
}
return res;
}
int main() {
in... | #include <bits/stdc++.h>
using namespace std;
double solve(int N, int K) {
double res = 0;
for (int i = 1; i <= N; i++) {
int point = i;
double ansd = 1;
while (K > point) {
ansd *= 0.50;
point += point;
}
ansd *= (1.0 / N);
res += ansd;
}
return res;
}
int main() {
in... | [
"io.output.change"
] | 862,669 | 862,670 | u845882023 | cpp |
p03043 | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
int main() {
long n, k, ret;
long ii;
long double sum = 0, one, div;
cin >> n >> k;
for (ii = 1; ii <=... | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
int main() {
long n, k, ret;
long ii;
long double sum = 0, one, div;
cin >> n >> k;
for (ii = 1; ii <=... | [
"expression.operator.compare.change",
"control_flow.loop.condition.change"
] | 862,680 | 862,681 | u146847434 | cpp |
p03043 | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
int main() {
long n, k, ret;
long ii;
double sum = 0, one, div;
cin >> n >> k;
for (ii = 1; ii <= n; i... | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <limits.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
int main() {
long n, k, ret;
long ii;
long double sum = 0, one, div;
cin >> n >> k;
for (ii = 1; ii <=... | [
"variable_declaration.type.widen.change",
"expression.operator.compare.change",
"control_flow.loop.condition.change",
"literal.string.change",
"literal.string.case.change",
"call.arguments.change",
"io.output.change"
] | 862,682 | 862,681 | u146847434 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int N;
int U[100010];
int V[100010];
int W[100010];
class UnionFindTree {
private:
// indexの数の親ノード(ある集合の親を見つけたいときはここを直接参照せず、findを使う)
vector<int> par;
// indexを根とする木のランク
vector<int> rank;
// 集合のサイズ
vector<int> ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int N;
int U[100010];
int V[100010];
int W[100010];
class UnionFindTree {
private:
// indexの数の親ノード(ある集合の親を見つけたいときはここを直接参照せず、findを使う)
vector<int> par;
// indexを根とする木のランク
vector<int> rank;
// 集合のサイズ
vector<int> ... | [] | 862,690 | 862,691 | u489053642 | cpp |
p03044 | #include <algorithm>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
struct nd {
int to, w;
nd(int t, int ww) : to(t), w(ww) {}
};
std::vector<nd> vec[100005];
int drg[100005];
bool vis[100005];
bool col[100005];
int main() {
int n;
std::cin >> n;
int u, v, w;
for (int i = 1; i < n... | #include <algorithm>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
struct nd {
int to, w;
nd(int t, int ww) : to(t), w(ww) {}
};
std::vector<nd> vec[100005];
int drg[100005];
bool vis[100005];
bool col[100005];
int main() {
int n;
std::cin >> n;
int u, v, w;
for (int i = 1; i < n... | [
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"assignment.add"
] | 862,692 | 862,693 | u750215086 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
int u, v, w;
cin >> N;
vector<int> ans(N, -1);
vector<int> odd[100010];
vector<int> even[100010];
for (int i = 0; i < N - 1; i++) {
cin >> u >> v >> w;
if (w % 2 == 0) {
even[u - 1].push_back(v - 1);
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
long u, v, w;
cin >> N;
vector<int> ans(N, -1);
vector<int> odd[100010];
vector<int> even[100010];
for (int i = 0; i < N - 1; i++) {
cin >> u >> v >> w;
if (w % 2 == 0) {
even[u - 1].push_back(v - 1);
... | [
"variable_declaration.type.primitive.change",
"misc.opposites",
"identifier.change",
"call.arguments.change"
] | 862,702 | 862,703 | u854831509 | cpp |
p03044 | #include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
// using namespace boost::multiprecision;
// using namespace __gnu_pbds;
#define all(c) (c).begin()... | #include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/pb_ds/assoc_container.hpp>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
// using namespace boost::multiprecision;
// using namespace __gnu_pbds;
#define all(c) (c).begin()... | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 862,708 | 862,709 | u906227026 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
vector<unsigned long> ans;
void dfs(unsigned long now, unsigned long prev, unsigned long col,
const vector<vector<pair<unsigned long, unsigned long>>> &edge) {
ans[now] = col;
for (const auto &i : edge[now]) {
if (i.first != prev) {
dfs(i.first, now... | #include <bits/stdc++.h>
using namespace std;
vector<unsigned long> ans;
void dfs(unsigned long now, unsigned long prev, unsigned long col,
const vector<vector<pair<unsigned long, unsigned long>>> &edge) {
ans[now] = col;
for (const auto &i : edge[now]) {
if (i.first != prev) {
dfs(i.first, now... | [
"assignment.compound.bitwise.replace.remove",
"expression.operator.bitwise.replace.add",
"call.arguments.change"
] | 862,719 | 862,720 | u462437857 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
vector<unsigned long> ans;
void dfs(unsigned long now, unsigned long prev, unsigned long col,
const vector<vector<pair<unsigned long, unsigned long>>> &edge) {
ans[now] = col;
for (const auto &i : edge[now]) {
if (i.first != prev) {
dfs(i.first, now... | #include <bits/stdc++.h>
using namespace std;
vector<unsigned long> ans;
void dfs(unsigned long now, unsigned long prev, unsigned long col,
const vector<vector<pair<unsigned long, unsigned long>>> &edge) {
ans[now] = col;
for (const auto &i : edge[now]) {
if (i.first != prev) {
dfs(i.first, now... | [
"assignment.compound.bitwise.replace.remove",
"expression.operator.bitwise.replace.add",
"call.arguments.change"
] | 862,719 | 862,721 | u462437857 | cpp |
p03044 | //#include "bits/stdc++.h"
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <tuple>
#in... | //#include "bits/stdc++.h"
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <tuple>
#in... | [
"expression.operation.binary.add"
] | 862,726 | 862,727 | u810724221 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
#define ln '\n'
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for (int i = (a); i <= (int)(b); ++i)
#define FORR(i, a, b) for (int i = (a); i >= (int)(b); --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
... | #include <bits/stdc++.h>
using namespace std;
#define ln '\n'
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for (int i = (a); i <= (int)(b); ++i)
#define FORR(i, a, b) for (int i = (a); i >= (int)(b); --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
... | [
"expression.operation.binary.add"
] | 862,730 | 862,731 | u991083615 | cpp |
p03044 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <st... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <st... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 862,749 | 862,750 | u629650917 | cpp |
p03044 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define M... | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define M... | [
"expression.operation.binary.add"
] | 862,755 | 862,756 | u236433947 | cpp |
p03044 | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int N = 2e5 + 10;
typedef long double ldb;
struct Edge {
int to, nex, val;
} e[N << 2];
int head[N], ecnt;
void adde(int fr, int to, int v) {
e[++ecnt] = (Edge){to, head[fr], v};
head[fr] = ecnt;
}
void addedge(int fr, int to, int v) {
a... | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int N = 2e5 + 10;
typedef long double ldb;
struct Edge {
int to, nex, val;
} e[N << 2];
int head[N], ecnt;
void adde(int fr, int to, int v) {
e[++ecnt] = (Edge){to, head[fr], v};
head[fr] = ecnt;
}
void addedge(int fr, int to, int v) {
a... | [
"assignment.value.change",
"assignment.change"
] | 862,757 | 862,758 | u076784075 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int col[100000];
struct edge {
int to;
ll w;
};
vector<edge> G[100000];
void dfs(int u, bool c) {
col[u] = c;
for (int i = 0; i < G[u].size(); i++) {
if (col[G[u][i].to] != -1)
continue;
ll dif;
dif = G[u][i].w;
if (... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int col[100000];
struct edge {
int to;
ll w;
};
vector<edge> G[100000];
void dfs(int u, bool c) {
col[u] = c;
for (int i = 0; i < G[u].size(); i++) {
if (col[G[u][i].to] != -1)
continue;
ll dif;
dif = G[u][i].w;
if (... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 862,761 | 862,762 | u853947407 | cpp |
p03044 | // D - Even Relation
#include <bits/stdc++.h>
using namespace std;
void dfs(const vector<vector<pair<int, int>>> &g, int u, int c, vector<int> &a,
vector<int> &vi) {
if (vi[u])
return;
vi[u] = 1;
a[u] = c;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
if (!vi[v])
df... | // D - Even Relation
#include <bits/stdc++.h>
using namespace std;
void dfs(const vector<vector<pair<int, int>>> &g, int u, int c, vector<int> &a,
vector<int> &vi) {
if (vi[u])
return;
vi[u] = 1;
a[u] = c;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
if (!vi[v])
df... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 862,765 | 862,766 | u839953699 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef int ll;
typedef long double ld;
const ll N = 100005;
char en = '\n';
vector<pair<ll, ll>> adj[N];
ll color[N];
void dfs(ll curr, ll prev1 = -1, ll prevVal = -1) {
if (prevVal == -1)
color[curr] = 0;
else
color[curr] = 1 - prevVal;
... | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef int ll;
typedef long double ld;
const ll N = 100005;
char en = '\n';
vector<pair<ll, ll>> adj[N];
ll color[N];
void dfs(ll curr, ll prev1 = -1, ll prevVal = -1) {
if (prevVal == -1)
color[curr] = 0;
else
color[curr] = 1 - prevVal;
... | [
"expression.operation.unary.arithmetic.remove"
] | 862,773 | 862,774 | u401416019 | cpp |
p03044 | #include <bits/stdc++.h>
const int MOD = 1000000007;
const int INF = 1000000000;
using namespace std;
typedef long long ll;
typedef tuple<ll, int, int> tup;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vp;
bool visited[100005];
vp g[100005];
int colors[10000... | #include <bits/stdc++.h>
const int MOD = 1000000007;
const int INF = 1000000000;
using namespace std;
typedef long long ll;
typedef tuple<ll, int, int> tup;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef vector<pair<int, int>> vp;
bool visited[100005];
vp g[100005];
int colors[10000... | [
"identifier.change",
"call.arguments.change"
] | 862,777 | 862,778 | u945017646 | cpp |
p03044 | #include <iomanip>
#include <iostream>
//#include<cstdio>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
const int Nmax = 1e5;
int N, U[Nmax], V[Nmax];
ll W[Nmax];
void dfs(int v, vector<vector<pair<int, int>>> &grap... | #include <iomanip>
#include <iostream>
//#include<cstdio>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
const int Nmax = 1e5;
int N, U[Nmax], V[Nmax];
ll W[Nmax];
void dfs(int v, vector<vector<pair<int, int>>> &grap... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 862,781 | 862,782 | u534998883 | cpp |
p03044 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
#define INF 1001001001
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
#define INF 1001001001
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long... | [
"expression.unary.arithmetic.remove"
] | 862,796 | 862,797 | u971166345 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
/*
index=0を白として、そこからDFSしていき距離が偶数なら同じ色、距離が奇数なら違う色を割り当てていく。
dfsにはtreeとどの色を割り当てたかを記録していく必要がある。
あと、どこを訪れたか、これは割り当てた色を使えば大丈夫そう。未：-1, 白: 0, 黒: 1
みたいに
*/
void dfs(vector<vector<pair<int, int>>> &tree, vect... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
/*
index=0を白として、そこからDFSしていき距離が偶数なら同じ色、距離が奇数なら違う色を割り当てていく。
dfsにはtreeとどの色を割り当てたかを記録していく必要がある。
あと、どこを訪れたか、これは割り当てた色を使えば大丈夫そう。未：-1, 白: 0, 黒: 1
みたいに
*/
void dfs(vector<vector<pair<int, int>>> &tree, vect... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 862,821 | 862,822 | u917793793 | cpp |
p03044 | // include
//------------------------------------------
#include <bits/stdc++.h>
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef vector<LL> VL;
typedef vector<VL> VVL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//------------------... | // include
//------------------------------------------
#include <bits/stdc++.h>
using namespace std;
// typedef
//------------------------------------------
typedef long long LL;
typedef vector<LL> VL;
typedef vector<VL> VVL;
typedef vector<string> VS;
typedef pair<LL, LL> PLL;
// container util
//------------------... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 862,841 | 862,842 | u150376070 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
/*#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template<typename T> using gpp_set = tree<T, null_type, less<T>, rb_tree_tag,
tree_order_statistics_node_update>; template<typename T, typename L> using
gpp_map = tre... | #include <bits/stdc++.h>
using namespace std;
/*#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template<typename T> using gpp_set = tree<T, null_type, less<T>, rb_tree_tag,
tree_order_statistics_node_update>; template<typename T, typename L> using
gpp_map = tre... | [
"identifier.change",
"call.arguments.change"
] | 862,846 | 862,847 | u434231045 | cpp |
p03044 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using ll = long long;
using namespace std;
// const int INF = 7+(1e+9);
ll GCD(ll x, ll y) {
if (y == 0) {
return x;... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using ll = long long;
using namespace std;
// const int INF = 7+(1e+9);
ll GCD(ll x, ll y) {
if (y == 0) {
return x;... | [
"literal.number.change",
"call.arguments.change"
] | 862,850 | 862,851 | u759162415 | cpp |
p03044 | #include <bits/stdc++.h>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pii std:... | #include <bits/stdc++.h>
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pii std:... | [
"control_flow.branch.if.condition.change"
] | 862,874 | 862,875 | u752814744 | cpp |
p03044 | #include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
const int sz = 1e5 + 9;
int n, f, t, w;
vector<pair<int, int>> v[sz];
int c[sz];
void dfs(int i, int p = 1) {
int myv;
if (i == p)
myv = 0;
else
myv = c[p];
for (auto u : v[i]) {
int nxt = u.x;
int val = u.y;
if ... | #include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
const int sz = 1e5 + 9;
int n, f, t, w;
vector<pair<int, int>> v[sz];
int c[sz];
void dfs(int i, int p = 1) {
int myv;
if (i == p)
myv = 0;
else
myv = c[i];
for (auto u : v[i]) {
int nxt = u.x;
int val = u.y;
if ... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 862,904 | 862,905 | u353783395 | cpp |
p03044 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#inclu... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#inclu... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 862,936 | 862,937 | u922299738 | cpp |
p03044 | #include <iostream>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int>> e[n]; // to,weight
for (int k = 0; k < n - 1; k++) {
int i, j, w;
cin >> i >> j >> w;
pair<int, int> edge1(j - 1, w);
e[i - 1].push_back(edge1);
... | #include <iostream>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int>> e[n]; // to,weight
for (int k = 0; k < n - 1; k++) {
int i, j, w;
cin >> i >> j >> w;
pair<int, int> edge1(j - 1, w);
e[i - 1].push_back(edge1);
... | [] | 862,971 | 862,972 | u102334466 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
enum COLOR { BLACK, WHITE, NONE };
ll N;
vector<vector<pair<ll, ll>>> G;
vector<COLOR> color;
void dfs(ll u, ll sum_w) {
for (ll i = 0; i < (ll)G[u].size(); i++) {
pair<ll, ll> _v = G[u][i];
ll v = _v.first;
ll w = _v.second;
if (c... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
enum COLOR { BLACK, WHITE, NONE };
ll N;
vector<vector<pair<ll, ll>>> G;
vector<COLOR> color;
void dfs(ll u, ll sum_w) {
for (ll i = 0; i < (ll)G[u].size(); i++) {
pair<ll, ll> _v = G[u][i];
ll v = _v.first;
ll w = _v.second;
if (c... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 862,981 | 862,982 | u251945221 | cpp |
p03044 | // khodaya khodet komak kon
#include <bits/stdc++.h>
#define pb push_back
#define ers erase
#define ins insert
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define debug(x) cerr << #x << " = " << x << endl
#define kill(x) return cout << x, 0;
#define IOS ... | // khodaya khodet komak kon
#include <bits/stdc++.h>
#define pb push_back
#define ers erase
#define ins insert
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define debug(x) cerr << #x << " = " << x << endl
#define kill(x) return cout << x, 0;
#define IOS ... | [
"control_flow.branch.if.condition.change"
] | 862,994 | 862,995 | u349705898 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
#define sd(x) scanf("%d", &x)
#define slld(x) scanf("%lld", &x)
#define all(x) x.begin(), x.end()
#define For(i, st, en) for (ll i = st; i < en; i++)
#define tr(x) for (auto it = x.begin(); it != x.end(); it++)
#define fast ... | #include <bits/stdc++.h>
using namespace std;
#define sd(x) scanf("%d", &x)
#define slld(x) scanf("%lld", &x)
#define all(x) x.begin(), x.end()
#define For(i, st, en) for (ll i = st; i < en; i++)
#define tr(x) for (auto it = x.begin(); it != x.end(); it++)
#define fast ... | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.remove"
] | 863,002 | 863,003 | u623300886 | cpp |
p03044 | #include <bits/stdc++.h>
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define lp(i, a, n) for (int i = a; i <= n; ++i)
#define lpd(i, a, n) for (int i = a; i >= n; --i)
#define mem(a, b) memset(a, b, sizeof a)
#define all(v) v.begin(), v.end()
#define println(a) cout << (a) << endl
#define... | #include <bits/stdc++.h>
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define lp(i, a, n) for (int i = a; i <= n; ++i)
#define lpd(i, a, n) for (int i = a; i >= n; --i)
#define mem(a, b) memset(a, b, sizeof a)
#define all(v) v.begin(), v.end()
#define println(a) cout << (a) << endl
#define... | [
"expression.operation.binary.remove",
"call.arguments.change"
] | 863,016 | 863,017 | u527876446 | cpp |
p03044 | #include <algorithm>
#include <cctype>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <queue>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
template <class Tp> constexpr Tp inf = Tp(1) << (8 * sizeof(Tp) - 3);
template <class Tp, class Compare>
using priority_queue = std::pri... | #include <algorithm>
#include <cctype>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <queue>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
template <class Tp> constexpr Tp inf = Tp(1) << (8 * sizeof(Tp) - 3);
template <class Tp, class Compare>
using priority_queue = std::pri... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 863,022 | 863,023 | u352499693 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
typedef long long int LL;
typedef long long int ll;
typedef pair<long long int, long long int> pii;
typedef pair<double, double> pdd;
#define SORT(c) sort((c).begin(), (c).end())
#define BACKSORT(c) sort((c).begin(), (c).end(), std::greater<LL>())
#define FOR(i, a, b) for... | #include <bits/stdc++.h>
using namespace std;
typedef long long int LL;
typedef long long int ll;
typedef pair<long long int, long long int> pii;
typedef pair<double, double> pdd;
#define SORT(c) sort((c).begin(), (c).end())
#define BACKSORT(c) sort((c).begin(), (c).end(), std::greater<LL>())
#define FOR(i, a, b) for... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 863,028 | 863,029 | u944838431 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, n, m) for (int i = (n); i < (m); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REPR(i, n) for (int i = (n); i >= 0; i--)
#define all(vec) vec.begin(), vec.end()
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vec... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, n, m) for (int i = (n); i < (m); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REPR(i, n) for (int i = (n); i >= 0; i--)
#define all(vec) vec.begin(), vec.end()
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vec... | [
"variable_declaration.type.change",
"call.arguments.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change"
] | 863,038 | 863,039 | u437391064 | cpp |
p03044 | //ライブラリ
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
... | //ライブラリ
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
... | [
"control_flow.return.remove",
"control_flow.continue.add"
] | 863,073 | 863,074 | u823871776 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define fr(i, a, n) for (ll i = a; i < n; i++)
int main() {
ll n;
cin >> n;
vector<pair<ll, ll>> a[n];
ll x, y, z;
fr(i, 0, n - 1) {
cin >> x >> y >> z;
a[x].push_back(make_pair(y, z));
a[y].push_back(make_pair(x, z));
}
l... | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define fr(i, a, n) for (ll i = a; i < n; i++)
int main() {
ll n;
cin >> n;
vector<pair<ll, ll>> a[n + 1];
ll x, y, z;
fr(i, 0, n - 1) {
cin >> x >> y >> z;
a[x].push_back(make_pair(y, z));
a[y].push_back(make_pair(x, z));
}... | [
"literal.string.change",
"io.output.change"
] | 863,092 | 863,093 | u339112743 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define fr(i, a, n) for (ll i = a; i < n; i++)
int main() {
ll n;
cin >> n;
vector<pair<ll, ll>> a[n];
ll x, y, z;
fr(i, 0, n) {
cin >> x >> y >> z;
a[x].push_back(make_pair(y, z));
a[y].push_back(make_pair(x, z));
}
ll di... | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define fr(i, a, n) for (ll i = a; i < n; i++)
int main() {
ll n;
cin >> n;
vector<pair<ll, ll>> a[n + 1];
ll x, y, z;
fr(i, 0, n - 1) {
cin >> x >> y >> z;
a[x].push_back(make_pair(y, z));
a[y].push_back(make_pair(x, z));
}... | [
"literal.string.change",
"io.output.change"
] | 863,094 | 863,093 | u339112743 | cpp |
p03044 | // Standard I/O
#include <cstdio>
#include <iostream>
#include <sstream>
// Standard Library
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
// Template Class
#include <complex>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//... | // Standard I/O
#include <cstdio>
#include <iostream>
#include <sstream>
// Standard Library
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
// Template Class
#include <complex>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//... | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 863,127 | 863,128 | u540438381 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i < (ll)(n); i++)
const ll mo = 1000000007;
const ll INF = 1LL << 60; // MAX 9223372036854775807
int main() {
int ans[100010] = {};
queue<ll> q;
ll n;
cin >> ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i < (ll)(n); i++)
const ll mo = 1000000007;
const ll INF = 1LL << 60; // MAX 9223372036854775807
int main() {
int ans[100010] = {};
queue<ll> q;
ll n;
cin >> ... | [
"expression.operation.binary.remove"
] | 863,129 | 863,130 | u419307948 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i < (ll)(n); i++)
const ll mo = 1000000007;
const ll INF = 1LL << 60; // MAX 9223372036854775807
int main() {
int ans[100010] = {};
queue<ll> q;
ll n;
cin >> ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i < (ll)(n); i++)
const ll mo = 1000000007;
const ll INF = 1LL << 60; // MAX 9223372036854775807
int main() {
int ans[100010] = {};
queue<ll> q;
ll n;
cin >> ... | [
"expression.operation.binary.remove",
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 863,131 | 863,130 | u419307948 | cpp |
p03044 | #include <iostream>
#include <vector>
using namespace std;
int N;
vector<int> ans;
using Edge = pair<int, int>;
using Graph = vector<vector<Edge>>;
Graph G;
void dfs(int v, int p, int c) {
ans[v] = c;
for (auto e : G[v]) {
if (e.first == p)
continue;
if (e.second & 1)
dfs(e.first, v, 1 - c);
... | #include <iostream>
#include <vector>
using namespace std;
int N;
vector<int> ans;
using Edge = pair<int, int>;
using Graph = vector<vector<Edge>>;
Graph G;
void dfs(int v, int p, int c) {
ans[v] = c;
for (auto e : G[v]) {
if (e.first == p)
continue;
if (e.second & 1)
dfs(e.first, v, 1 - c);
... | [
"expression.operation.binary.remove"
] | 863,151 | 863,152 | u806800460 | cpp |
p03044 | #include <bits/stdc++.h>
#define foreach(i, v) \
for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++i)
#define BETWEEN(a, x, b) (a <= x && x < b)
using namespace std;
typedef long long ll;
int n;
// 頂点-頂点-距離
vector<pair<int, int>> g[100005];
int v... | #include <bits/stdc++.h>
#define foreach(i, v) \
for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++i)
#define BETWEEN(a, x, b) (a <= x && x < b)
using namespace std;
typedef long long ll;
int n;
// 頂点-頂点-距離
vector<pair<int, int>> g[100005];
int v... | [
"call.arguments.change"
] | 863,182 | 863,183 | u440032761 | cpp |
p03044 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define inf 2147483647
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rr read()
#define ll long ... | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define inf 2147483647
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rr read()
#define ll long ... | [
"control_flow.branch.if.condition.change"
] | 863,205 | 863,206 | u680195439 | cpp |
p03044 | #include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main() {
int N, u, v, w;
cin >> N;
vector<vector<pair<int, int>>> tree(N);
for (int i = 0; i < N; ++i) {
cin >> u >> v >> w;
tree[--u].push_back(make_pair(--v, w & 1));
tree[v].push_back(make_pair(u, w & 1));
}
vecto... | #include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main() {
int N, u, v, w;
cin >> N;
vector<vector<pair<int, int>>> tree(N);
for (int i = 1; i < N; ++i) {
cin >> u >> v >> w;
tree[--u].push_back(make_pair(--v, w & 1));
tree[v].push_back(make_pair(u, w & 1));
}
vecto... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 863,231 | 863,232 | u550314572 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define mod 1000000007
#define all(v) v.begin(), v.end()
#define pb push_back
ll power(ll a, ll x) {
if (x == 0)
return 1;
ll y = power(a, x / 2);
ll ans = (y * y) % mod;
if (x % 2)
ans = (ans * a) % mod;
return ans;
}
ll inv(ll a... | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define mod 1000000007
#define all(v) v.begin(), v.end()
#define pb push_back
ll power(ll a, ll x) {
if (x == 0)
return 1;
ll y = power(a, x / 2);
ll ans = (y * y) % mod;
if (x % 2)
ans = (ans * a) % mod;
return ans;
}
ll inv(ll a... | [
"control_flow.branch.if.condition.change"
] | 863,248 | 863,249 | u742642200 | cpp |
p03044 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
ll N;
vector<vector<int>> uvw;
vector<vector<pair<int, int>>> graph;
vector<int> black;
void solve(int i) {
for (auto x : graph[i]) {
if (black[x.first] == -1) {
if (x.second % 2 == 0) {
... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
ll N;
vector<vector<int>> uvw;
vector<vector<pair<int, int>>> graph;
vector<int> black;
void solve(int i) {
for (auto x : graph[i]) {
// cout << x.first << endl;
if (black[x.first] == -1) {
... | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.change"
] | 863,279 | 863,280 | u520129469 | cpp |
p03044 | #include <bits/stdc++.h>
using namespace std;
template <class Abel> struct UnionFind {
vector<long long> par;
vector<long long> rank;
vector<Abel> diff_weight;
UnionFind(long long n = 1, Abel SUM_UNITY = 0) { init(n, SUM_UNITY); }
void init(long long n = 1, Abel SUM_UNITY = 0) {
par.resize(n);
rank... | #include <bits/stdc++.h>
using namespace std;
template <class Abel> struct UnionFind {
vector<long long> par;
vector<long long> rank;
vector<Abel> diff_weight;
UnionFind(long long n = 1, Abel SUM_UNITY = 0) { init(n, SUM_UNITY); }
void init(long long n = 1, Abel SUM_UNITY = 0) {
par.resize(n);
rank... | [
"call.add",
"call.arguments.change"
] | 863,281 | 863,282 | u451256159 | cpp |
p03045 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
//////////////////////////////////////////////////////////////////////////////////////... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
//////////////////////////////////////////////////////////////////////////////////////... | [
"call.arguments.change"
] | 863,283 | 863,284 | u873041360 | cpp |
p03045 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MAX_N = 100005;
int ran[MAX_N], par[MAX_N];
set<int> s;
void init() {
rep(i, MAX_N) {
ran[i] = 1;
par[i] = i;
}
}
int find(int x) {
if (par[x] == x)
r... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MAX_N = 100005;
int ran[MAX_N], par[MAX_N];
set<int> s;
void init() {
rep(i, MAX_N) {
ran[i] = 1;
par[i] = i;
}
}
int find(int x) {
if (par[x] == x)
r... | [
"call.arguments.change"
] | 863,293 | 863,294 | u352969025 | cpp |
p03045 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
vector<int> g[100005];
int z[100005];
void dfs(int x, int p) {
for (int i : g[x])
if (i != p) {
z[i] = 1;
d... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
vector<int> g[100005];
int z[100005];
void dfs(int x, int p) {
for (int i : g[x])
if (i != p && !z[i]) {
z[i] = 1... | [
"control_flow.branch.if.condition.change"
] | 863,297 | 863,298 | u151855078 | cpp |
p03045 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
struct UnionFind {
vector<int> par; // par[i]:= iの親の番号
vector<int> siz; // siz[i]:= iの属する連結成分の大きさ
UnionFind(int N) {
par.resize(N);
for (int i = 0; i < N; ++i) {
par[i] = i;
}
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
struct UnionFind {
vector<int> par; // par[i]:= iの親の番号
vector<int> siz; // siz[i]:= iの属する連結成分の大きさ
UnionFind(int N) {
par.resize(N);
for (int i = 0; i < N; ++i) {
par[i] = i;
}
... | [
"call.arguments.change"
] | 863,305 | 863,306 | u115838990 | cpp |
p03045 | #include <algorithm>
#include <bitset>
#include <fstream>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
// typedef pair<ll, ll> P;
// typedef pair<ll, P> T;
#define rep(... | #include <algorithm>
#include <bitset>
#include <fstream>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
// typedef pair<ll, ll> P;
// typedef pair<ll, P> T;
#define rep(... | [
"identifier.change",
"expression.operation.binary.change"
] | 863,312 | 863,313 | u475007080 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> ve(N, 0);
vector<stack<int>> ed(N);
for (int i = 0; i < N; i++) {
int X, Y, Z;
cin >> X >> Y >> Z;
ve[X - 1] = 1;
ve[Y - 1] = 1;
ed[X - 1].push(Y - 1);
ed[Y - 1].push(X - 1);
}
int ans ... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> ve(N, 0);
vector<stack<int>> ed(N);
for (int i = 0; i < M; i++) {
int X, Y, Z;
cin >> X >> Y >> Z;
ve[X - 1] = 1;
ve[Y - 1] = 1;
ed[X - 1].push(Y - 1);
ed[Y - 1].push(X - 1);
}
int ans ... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 863,325 | 863,326 | u182791129 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
class UnionFind {
public:
vector<int> parent;
vector<int> rank;
UnionFind(int n) {
parent.resize(n);
rank.resize(n);
for (int i = 0; i < n; i++) {
parent[i] = i;
rank[i] = 0;
}
}
int find(int x) {
if (parent[x] == x) {
retu... | #include <bits/stdc++.h>
using namespace std;
class UnionFind {
public:
vector<int> parent;
vector<int> rank;
UnionFind(int n) {
parent.resize(n);
rank.resize(n);
for (int i = 0; i < n; i++) {
parent[i] = i;
rank[i] = 0;
}
}
int find(int x) {
if (parent[x] == x) {
retu... | [
"call.arguments.change"
] | 863,327 | 863,328 | u188117876 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
#define CPP_STR(x) CPP_STR_I(x)
#define CPP_CAT(x, y) CPP_CAT_I(x, y)
#define CPP_STR_I(args...) #args
#define CPP_CAT_I(x, y) x##y
using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int... | #include <bits/stdc++.h>
using namespace std;
#define CPP_STR(x) CPP_STR_I(x)
#define CPP_CAT(x, y) CPP_CAT_I(x, y)
#define CPP_STR_I(args...) #args
#define CPP_CAT_I(x, y) x##y
using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int... | [
"call.arguments.change"
] | 863,329 | 863,330 | u461336793 | cpp |
p03045 | #include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int n, m;
vector<int> ve[100005];
int cnt;
bool v[100005];
void dfs(int p) {
if (v[p])
return;
v[p] = true;
for (int i = 0; i < ve[p].size(); i++) {
dfs(ve[p][i]);
}
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
... | #include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int n, m;
vector<int> ve[100005];
int cnt;
bool v[100005];
void dfs(int p) {
if (v[p])
return;
v[p] = true;
for (int i = 0; i < ve[p].size(); i++) {
dfs(ve[p][i]);
}
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
... | [
"literal.string.change",
"call.arguments.change"
] | 863,336 | 863,337 | u307227472 | cpp |
p03045 | #include <algorithm>
#include <atomic>
#include <cmath>
#include <future>
#include <iomanip>
#include <iostream>
#include <map>
#include <mutex>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <thread>
#include <time.h>
#include <vector>
#define double ... | #include <algorithm>
#include <atomic>
#include <cmath>
#include <future>
#include <iomanip>
#include <iostream>
#include <map>
#include <mutex>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <thread>
#include <time.h>
#include <vector>
#define double ... | [
"call.arguments.change"
] | 863,340 | 863,341 | u054475353 | cpp |
p03045 | #define _GLIBCXX_DEBUG
#include <algorithm> //next_permutation
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define dec(n) cout << fixed << setprecision(n);
#define large "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define small "abcdefghijklmnopqrstuvwxyz"
using namespace... | #define _GLIBCXX_DEBUG
#include <algorithm> //next_permutation
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define dec(n) cout << fixed << setprecision(n);
#define large "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define small "abcdefghijklmnopqrstuvwxyz"
using namespace... | [
"call.add",
"call.arguments.change"
] | 863,350 | 863,351 | u434398296 | cpp |
p03045 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define FORR(i, a, b) for (int i = b - 1; i >= a; --i)
#define SORT(v) sort(v.begin(), v.end())
#define SORTR(v) sort(v.rbegin(), v.rend())
#define ... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define FORR(i, a, b) for (int i = b - 1; i >= a; --i)
#define SORT(v) sort(v.begin(), v.end())
#define SORTR(v) sort(v.rbegin(), v.rend())
#define ... | [] | 863,352 | 863,353 | u285991898 | cpp |
p03045 | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
typedef long long ll;
using namespace std;
int par[100001];
int ran[100001];
void init(int n) {
for (int i = 1; i <= n; i++) {
... | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
typedef long long ll;
using namespace std;
int par[100001];
int ran[100001];
void init(int n) {
for (int i = 1; i <= n; i++) {
... | [
"call.arguments.change"
] | 863,367 | 863,368 | u075296067 | cpp |
p03045 | #pragma optimize("O3")
#pragma GCC target("sse4")
#include <bits/stdc++.h>
// #include<iomanip>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pii;
#define f(i, a, b) for (ll i = a; i < b; i++)
#define fo(i, a, b) for (ll i = a; i <= b; i += 1)
#define rf(i, a, b) for (ll i = a; i >= b; i--)
#def... | #pragma optimize("O3")
#pragma GCC target("sse4")
#include <bits/stdc++.h>
// #include<iomanip>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pii;
#define f(i, a, b) for (ll i = a; i < b; i++)
#define fo(i, a, b) for (ll i = a; i <= b; i += 1)
#define rf(i, a, b) for (ll i = a; i >= b; i--)
#def... | [
"call.arguments.change"
] | 863,372 | 863,373 | u545385207 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 863,374 | 863,375 | u722640678 | cpp |
p03045 | // 7/4
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
struct UnionFind {
vector<int> d;
UnionFind(int n = 0) : d(n, -1) {}
int find(int x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool un... | // 7/4
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
struct UnionFind {
vector<int> d;
UnionFind(int n = 0) : d(n, -1) {}
int find(int x) {
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool un... | [
"expression.operation.binary.add"
] | 863,381 | 863,382 | u581094488 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
ll n, k;
vector<ll> ch[100010];
bool ans[100010];
void dep(ll now, ll s) {
if (now != s && ch[now].size() == 1) {
return;
}
for (ll i = 0; i < ch[now].size(); i++) {
ll next = ch[now][i];
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
ll n, k;
vector<ll> ch[100010];
bool ans[100010];
void dep(ll now, ll s) {
if (now != s && ch[now].size() == 1) {
return;
}
for (ll i = 0; i < ch[now].size(); i++) {
ll next = ch[now][i];
... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 863,385 | 863,386 | u166378830 | cpp |
p03045 | #include <bits/stdc++.h>
#define rep(i, n) for (long long int i = 0; i < n; i++)
#define _rep(i, m, n) for (long long int i = m; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MAX_N = 100010;
const ll mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1,... | #include <bits/stdc++.h>
#define rep(i, n) for (long long int i = 0; i < n; i++)
#define _rep(i, m, n) for (long long int i = m; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MAX_N = 100010;
const ll mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1,... | [
"call.arguments.change"
] | 863,389 | 863,390 | u999788719 | cpp |
p03045 | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < (int)(n); i++)
#define ALL(a) a.begin(), a.end()
#define MOD 1000000007
using namespace std;
using ll = long long;
class UnionFindTree {
public:
vector<int> parent;
vector<int> siz;
UnionFindTree(int n) {
siz.resize(n, 1);
parent.resize(n... | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < (int)(n); i++)
#define ALL(a) a.begin(), a.end()
#define MOD 1000000007
using namespace std;
using ll = long long;
class UnionFindTree {
public:
vector<int> parent;
vector<int> siz;
UnionFindTree(int n) {
siz.resize(n, 1);
parent.resize(n... | [
"identifier.change",
"expression.operation.binary.change"
] | 863,391 | 863,392 | u483992368 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> par;
vector<int> rank;
UnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n);
rank.resize(n);
for (int i = 0; i < n; ++i)
par[i] = i, rank[i] = 0;
}
int root(int x) {
if (par[x] == x)
... | #include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> par;
vector<int> rank;
UnionFind(int n = 1) { init(n); }
void init(int n = 1) {
par.resize(n);
rank.resize(n);
for (int i = 0; i < n; ++i)
par[i] = i, rank[i] = 0;
}
int root(int x) {
if (par[x] == x)
... | [
"call.add",
"call.arguments.change"
] | 863,393 | 863,394 | u543466827 | cpp |
p03045 | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using namespace std;
const int INF = 1 << 30;
const long long MOD = 1000000000 + 7;
const double PI = acos(-1);
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n) {... | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using namespace std;
const int INF = 1 << 30;
const long long MOD = 1000000000 + 7;
const double PI = acos(-1);
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n) {... | [
"identifier.change",
"expression.operation.binary.change"
] | 863,399 | 863,400 | u289578952 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int x, y, z;
vector<int> a(n);
vector<set<int>> s(n + 1);
int i;
for (i = 0; i < m; i++) {
cin >> x >> y >> z;
s[x].insert(y);
s[y].insert(x);
}
vector<bool> rikai(n + 1);
queue<int> q;
int cnt = 0;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int x, y, z;
vector<int> a(n);
vector<set<int>> s(n + 1);
int i;
for (i = 0; i < m; i++) {
cin >> x >> y >> z;
s[x].insert(y);
s[y].insert(x);
}
vector<bool> rikai(n + 1);
queue<int> q;
int cnt = 0;
... | [] | 863,407 | 863,408 | u523698212 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int n;
int parent[500000];
int rnk[500000];
int find(int x) {
if (parent[x] == x)
return x;
return parent[x] = find(parent[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rnk[x] < rnk[y]) {
... | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int n;
int parent[500000];
int rnk[500000];
int find(int x) {
if (parent[x] == x)
return x;
return parent[x] = find(parent[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rnk[x] < rnk[y]) {
... | [
"call.arguments.add",
"call.arguments.change"
] | 863,411 | 863,412 | u313766957 | cpp |
p03045 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define INCANT cin.tie(0), cout.tie(0), ios::sync_with_stdio(... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define INCANT cin.tie(0), cout.tie(0), ios::sync_with_stdio(... | [
"call.arguments.change"
] | 863,417 | 863,418 | u288087195 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
struct edge {
int x, y;
} e[100001];
int fa[100001];
int findfa(int x) {
if (x != fa[x])
fa[x] = findfa(fa[x]);
return x;
}
int main() {
int n, m, i, a;
int f1, f2;
cin >> n >> m;
for (i = 1; i <= n; i++)
fa[i] = i;
for (i = 1; i <= m; i++) {
... | #include <bits/stdc++.h>
using namespace std;
struct edge {
int x, y;
} e[100001];
int fa[100001];
int findfa(int x) {
if (x != fa[x])
fa[x] = findfa(fa[x]);
return fa[x];
}
int main() {
int n, m, i, a;
int f1, f2;
cin >> n >> m;
for (i = 1; i <= n; i++)
fa[i] = i;
for (i = 1; i <= m; i++)... | [
"function.return_value.change"
] | 863,421 | 863,422 | u762918924 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
struct edge {
int x, y;
} e[100001];
int fa[100001];
int findfa(int x) {
if (x != fa[x])
fa[x] = findfa(fa[x]);
return x;
}
int main() {
int n, m, i, a;
int f1, f2;
cin >> n >> m;
for (i = 1; i <= n; i++)
fa[i] = i;
for (i = 1; i <= m; i++) {
... | #include <bits/stdc++.h>
using namespace std;
struct edge {
int x, y;
} e[100001];
int fa[100001];
int findfa(int x) {
if (x != fa[x])
fa[x] = findfa(fa[x]);
return fa[x];
}
int main() {
int n, m, i, a;
int f1, f2;
cin >> n >> m;
for (i = 1; i <= n; i++)
fa[i] = i;
for (i = 1; i <= m; i++)... | [
"function.return_value.change"
] | 863,423 | 863,422 | u762918924 | cpp |
p03045 | #include <bits/stdc++.h>
#include <cstdint>
#include <vector>
#define FOR(i, l, r) for (int i = (l); i < (r); ++i)
#define RFOR(i, l, r) for (int i = (l); i >= (int)(r); i--)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) RFOR(i, n - 1, 0)
#define int long long
using namespace std;
const int MX = 1e6;
const int inf... | #include <bits/stdc++.h>
#include <cstdint>
#include <vector>
#define FOR(i, l, r) for (int i = (l); i < (r); ++i)
#define RFOR(i, l, r) for (int i = (l); i >= (int)(r); i--)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) RFOR(i, n - 1, 0)
#define int long long
using namespace std;
const int MX = 1e6;
const int inf... | [
"call.arguments.change"
] | 863,424 | 863,425 | u762160119 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0) {
return a;
} else {
return par[a] = find(par[a]);
}
}
bool same(int a, int b) { return (find(a) == find(b)); }
int size(int a) {... | #include <bits/stdc++.h>
using namespace std;
struct Union {
vector<int> par;
Union(int a) { par = vector<int>(a, -1); }
int find(int a) {
if (par[a] < 0) {
return a;
} else {
return par[a] = find(par[a]);
}
}
bool same(int a, int b) { return (find(a) == find(b)); }
int size(int a) {... | [
"expression.operation.binary.add"
] | 863,437 | 863,438 | u222643545 | cpp |
p03045 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
struct UnionFind {
vector<int> data;
UnionFind(int sz) { data.assign(sz, -1); }
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return (false);
if (data[x] > data[y])
swap(x, y);
data[x... | #include <iostream>
#include <vector>
using namespace std;
struct UnionFind {
vector<int> data;
UnionFind(int sz) { data.assign(sz, -1); }
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return (false);
if (data[x] > data[y])
swap(x, y);
data[x] += data[y];
dat... | [
"expression.operation.unary.add",
"control_flow.branch.if.condition.change"
] | 863,445 | 863,446 | u976833038 | cpp |
p03045 | #include <bits/stdc++.h>
#define INF 1000000000
#define ll long long
#define pll pair<ll, ll>
using namespace std;
// ============union_find_tree===============
vector<ll> par; // MAX_N == num of node
vector<ll> tree_rank;
void init(ll n) {
par = vector<ll>(n);
tree_rank = vector<ll>(n, 0);
for (ll i = 0; i < n... | #include <bits/stdc++.h>
#define INF 1000000000
#define ll long long
#define pll pair<ll, ll>
using namespace std;
// ============union_find_tree===============
vector<ll> par; // MAX_N == num of node
vector<ll> tree_rank;
void init(ll n) {
par = vector<ll>(n);
tree_rank = vector<ll>(n, 0);
for (ll i = 0; i < n... | [
"call.add"
] | 863,449 | 863,450 | u023958502 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.