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 |
|---|---|---|---|---|---|---|---|
p03221 | #include <bits/stdc++.h>
typedef long long int lint;
#define PI acos(-1)
#define INF64 1LL << 60
#define INF32 1 << 29
#define LIMIT(d_in, d_min, d_max) max(d_min, min(d_max, d_in))
#define all(a) (a).begin(), (a).end()
#define INV ((long long int)1000000007)
using namespace std;
void execute() {
int N, M;
cin >... | #include <bits/stdc++.h>
typedef long long int lint;
#define PI acos(-1)
#define INF64 1LL << 60
#define INF32 1 << 29
#define LIMIT(d_in, d_min, d_max) max(d_min, min(d_max, d_in))
#define all(a) (a).begin(), (a).end()
#define INV ((long long int)1000000007)
using namespace std;
void execute() {
int N, M;
cin >... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,017,422 | 1,017,423 | u874525170 | cpp |
p03221 | //
// Created by Hideaki Imamura on 2020-03-15.
//
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline boo... | //
// Created by Hideaki Imamura on 2020-03-15.
//
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline boo... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,017,424 | 1,017,425 | u477855214 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <... | [
"literal.string.change",
"call.arguments.change",
"io.output.change",
"io.output.newline.add"
] | 1,017,432 | 1,017,433 | u484274300 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
struct city {
// 誕生年, 入力された順番
int64_t year;
int in_order;
};
int main() {
int n, m;
cin >> n >> m;
vector<city> prefecture[101111];
for (int i = 0; i < m; ++i) {
int p;
int64_t y;
cin >> p >> y;
prefecture[p].push_back({y, i + 1});
}
// ... | #include <bits/stdc++.h>
using namespace std;
struct city {
// 誕生年, 入力された順番
int64_t year;
int in_order;
};
int main() {
int n, m;
cin >> n >> m;
vector<city> prefecture[101010];
for (int i = 0; i < m; ++i) {
int p;
int64_t y;
cin >> p >> y;
prefecture[p].push_back({y, i + 1});
}
// ... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_declaration.type.primitive.change"
] | 1,017,439 | 1,017,440 | u914330401 | cpp |
p03221 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
#define int long long
#define mod(int) (1000000007)
using namespace std;
int test[213456]... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
#define int long long
#define mod(int) (1000000007)
using namespace std;
int test[213456]... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,017,441 | 1,017,442 | u986568278 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <iomanip> // std::setw(int), std::setfill(char)
#include <ios> // std::left, std::right
using namespace std;
t... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <iomanip> // std::setw(int), std::setfill(char)
#include <ios> // std::left, std::right
using namespace std;
t... | [
"misc.opposites",
"expression.operator.compare.change",
"call.arguments.change",
"function.return_value.change",
"expression.operation.binary.change",
"identifier.change"
] | 1,017,449 | 1,017,448 | u130020973 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
// #define int long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define MOD 1000000007
using namespace std;
vector<int> compress(int n, vector<int> a) {
vector<int> vals(n);
REP(... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
// #define int long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define MOD 1000000007
using namespace std;
vector<int> compress(int n, vector<int> a) {
vector<int> vals(n);
REP(... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,017,452 | 1,017,453 | u023540496 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n, mm;
cin >> n >> mm;
map<int, vector<ll>> m;
vector<pair<int, ll>> v(n);
for (int i = 0; i < mm; i++) ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n, mm;
cin >> n >> mm;
map<int, vector<ll>> m;
vector<pair<int, ll>> v(mm);
for (int i = 0; i < mm; i++)... | [
"identifier.change",
"call.function.change",
"expression.operation.binary.change"
] | 1,017,460 | 1,017,459 | u724012411 | cpp |
p03221 | #include <algorithm>]
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n, mm;
cin >> n >> mm;
map<int, vector<ll>> m;
vector<pair<int, ll>> v(n);
for (int i = 0; i < mm; i++)... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n, mm;
cin >> n >> mm;
map<int, vector<ll>> m;
vector<pair<int, ll>> v(mm);
for (int i = 0; i < mm; i++)... | [
"identifier.change",
"call.function.change",
"expression.operation.binary.change"
] | 1,017,461 | 1,017,459 | u724012411 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M), Y(M);
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
}
// vals[v] := P[i] = v であるようなiについてのY[i]の値を集めたもの
vector<vector<int>> vals(N + 1);
for (int i = 0; i < M; i++) {
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M), Y(M);
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
}
// vals[v] := P[i] = v であるようなiについてのY[i]の値を集めたもの
vector<vector<int>> vals(N + 1);
for (int i = 0; i < M; i++) {
... | [
"literal.string.change",
"call.arguments.change",
"io.output.change",
"io.output.newline.add"
] | 1,017,464 | 1,017,465 | u241312295 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3;
#define pb push_back
#define all(x) (x).begin(), (x).end()
typedef long long ll;
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
const int inf = 1e9;
int n, m, a[N], b[N], k, q, u, tc, c, l, r, p, cnt, v, x;
char s[N];
int ok[26];
strin... | #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 3;
#define pb push_back
#define all(x) (x).begin(), (x).end()
typedef long long ll;
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
const int inf = 1e9;
int n, m, a[N], b[N], k, q, u, tc, c, l, r, p, cnt, v, x;
char s[N];
int ok[26];
strin... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change"
] | 1,017,467 | 1,017,468 | u318875010 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#inclu... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#inclu... | [] | 1,017,471 | 1,017,472 | u698883164 | cpp |
p03221 | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); ... | #include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORR(i, a, b) for (ll i = (a); i <= (b); ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,017,473 | 1,017,474 | u103850114 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
int main() {
int N, M;
scanf("%d", &N);
scanf("%d", &M);
std::vector<int> P(M + 5), Y(M + 5);
std::vector<int> year[100005];... | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
int main() {
int N, M;
scanf("%d", &N);
scanf("%d", &M);
std::vector<int> P(M + 5), Y(M + 5);
std::vector<int> year[100005];... | [
"control_flow.loop.for.condition.change"
] | 1,017,475 | 1,017,476 | u339419997 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
int main() {
int N, M;
scanf("%d", &N);
scanf("%d", &M);
std::vector<int> to(M + 5);
std::vector<int> order(M + 5);
int P,... | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
int main() {
int N, M;
scanf("%d", &N);
scanf("%d", &M);
std::vector<int> to(M + 5);
std::vector<int> order(M + 5);
int P,... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,017,477 | 1,017,478 | u339419997 | cpp |
p03221 | #include <bits/stdc++.h>
#include <cmath>
const double PI = 3.14159265358979323846;
// using namespace boost::multiprecision;
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<ll, ll> P;
const ll INF = 1e15;
#define cmin(x, y) x = min(x, y)... | #include <bits/stdc++.h>
#include <cmath>
const double PI = 3.14159265358979323846;
// using namespace boost::multiprecision;
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<ll, ll> P;
const ll INF = 1e15;
#define cmin(x, y) x = min(x, y)... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,017,479 | 1,017,480 | u564182781 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
struct city... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
struct city... | [
"literal.number.change",
"variable_declaration.value.change"
] | 1,017,481 | 1,017,482 | u873538240 | cpp |
p03221 | #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;
void print(int x) {
int n = x;
int d = 0;
while (n) {
n /= 10;
d++;
}
rep(i, 6 - d) { cout << 0; }
cout << x;
}
int main(void) {
int n, m;
cin >> n >> m;
... | #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;
void print(int x) {
int n = x;
int d = 0;
while (n) {
n /= 10;
d++;
}
rep(i, 6 - d) { cout << 0; }
cout << x;
}
int main(void) {
int n, m;
cin >> n >> m;
... | [
"identifier.change",
"variable_declaration.array_dimensions.change"
] | 1,017,483 | 1,017,484 | u243407720 | cpp |
p03221 | #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;
void print(int x) {
int n = x;
int d = 0;
while (n) {
n /= 10;
d++;
}
rep(i, 6 - d) { cout << 0; }
cout << x;
}
int main(void) {
int n, m;
cin >> n >> m;
... | #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;
void print(int x) {
int n = x;
int d = 0;
while (n) {
n /= 10;
d++;
}
rep(i, 6 - d) { cout << 0; }
cout << x;
}
int main(void) {
int n, m;
cin >> n >> m;
... | [
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,017,485 | 1,017,484 | u243407720 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> v(m);
vector<vector<int>> r(n + 1);
rep(i, m) {
cin >> v[i].first >> v[i].second;
r[v[i].first].push_back(v[i].second);
}
rep(i, n) sort(r[i].be... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> v(m);
vector<vector<int>> r(n + 1);
rep(i, m) {
cin >> v[i].first >> v[i].second;
r[v[i].first].push_back(v[i].second);
}
rep(i, n + 1) sort(r[i... | [
"expression.operation.binary.add"
] | 1,017,487 | 1,017,488 | u757584836 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int n, m;
struct Node {
int x, y, num;
} Edge[100005];
bool cmp(Node a, Node b) {
if (a.x == b.x) {
return a.y < b.y;
}
return a.x < b.x;
}
bool cmp1(Node a, Node b) { return a.num < b.num; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++)... | #include <bits/stdc++.h>
using namespace std;
int n, m;
struct Node {
int x, y, num;
} Edge[100005];
bool cmp(Node a, Node b) {
if (a.x == b.x) {
return a.y < b.y;
}
return a.x < b.x;
}
bool cmp1(Node a, Node b) { return a.num < b.num; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++)... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,017,489 | 1,017,490 | u226023982 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i >= 0; i--)
#define REP(i, m, n) for (int i = (int)(m); i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
template <class T> inline bool chmax(T &a, T ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i >= 0; i--)
#define REP(i, m, n) for (int i = (int)(m); i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
template <class T> inline bool chmax(T &a, T ... | [
"expression.unary.arithmetic.add"
] | 1,017,511 | 1,017,512 | u328179672 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i >= 0; i--)
#define REP(i, m, n) for (int i = (int)(m); i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
template <class T> inline bool chmax(T &a, T ... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i >= 0; i--)
#define REP(i, m, n) for (int i = (int)(m); i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
template <class T> inline bool chmax(T &a, T ... | [
"expression.unary.arithmetic.add"
] | 1,017,513 | 1,017,512 | u328179672 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define LL long int
struct ST {
int num, p, y, pnum;
};
bool comp1(ST a, ST b) { return a.num > b.num; }
bool comp2(ST a, ST b) {
if (a.p != b.p)
return a.y < b.y;
else
return a.p < b.p;
}
void solve() {
int n, m;
cin >> n >> m;
vector<ST> data(m);
... | #include <bits/stdc++.h>
using namespace std;
#define LL long int
struct ST {
int num, p, y, pnum;
};
bool comp1(ST a, ST b) { return a.num < b.num; }
bool comp2(ST a, ST b) {
if (a.p == b.p)
return a.y < b.y;
else
return a.p < b.p;
}
void solve() {
int n, m;
cin >> n >> m;
vector<ST> data(m);
... | [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 1,017,514 | 1,017,515 | u798665594 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define LL long int
struct ST {
int num, p, y, pnum;
};
bool comp1(ST a, ST b) { return a.num < b.num; }
bool comp2(ST a, ST b) {
if (a.p != b.p)
return a.y < b.y;
else
return a.p < b.p;
}
void solve() {
int n, m;
cin >> n >> m;
vector<ST> data(m);
... | #include <bits/stdc++.h>
using namespace std;
#define LL long int
struct ST {
int num, p, y, pnum;
};
bool comp1(ST a, ST b) { return a.num < b.num; }
bool comp2(ST a, ST b) {
if (a.p == b.p)
return a.y < b.y;
else
return a.p < b.p;
}
void solve() {
int n, m;
cin >> n >> m;
vector<ST> data(m);
... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 1,017,516 | 1,017,515 | u798665594 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(m), y(m);
vector<vector<ll>> yd(n + 1);
rep(i, m) cin >> p[i] >> y[i], yd[p[i]].push_back(y[i]);
rep(i, n) sort(yd[p[i... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(m), y(m);
vector<vector<ll>> yd(n + 1);
rep(i, m) cin >> p[i] >> y[i], yd[p[i]].push_back(y[i]);
rep(i, n) sort(yd[i +... | [
"call.arguments.change"
] | 1,017,525 | 1,017,526 | u620269708 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
vector<ll> p(100000), y(100000), yd[100001];
int main() {
ll n, m;
cin >> n >> m;
rep(i, m) cin >> p[i] >> y[i], yd[p[i]].push_back(y[i]);
rep(i, m) sort(yd[i + 1].begin(),... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
vector<ll> p(100000), y(100000), yd[100001];
int main() {
ll n, m;
cin >> n >> m;
rep(i, m) cin >> p[i] >> y[i], yd[p[i]].push_back(y[i]);
rep(i, n) sort(yd[i + 1].begin(),... | [
"identifier.change",
"call.arguments.change"
] | 1,017,527 | 1,017,528 | u620269708 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(100000), y(100000), yd[100001];
rep(i, m) cin >> p[i] >> y[i], yd[p[i]].push_back(y[i]);
rep(i, m) sort(yd[i + 1].begin(... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(100000), y(100000), yd[100001];
rep(i, m) cin >> p[i] >> y[i], yd[p[i]].push_back(y[i]);
rep(i, n) sort(yd[i + 1].begin(... | [
"identifier.change",
"call.arguments.change"
] | 1,017,529 | 1,017,530 | u620269708 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(10000), y(10000), yd[10001];
rep(i, m) cin >> p[i] >> y[i], yd[p[i]].push_back(y[i]);
rep(i, m) sort(yd[i + 1].begin(), ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(100000), y(100000), yd[100001];
rep(i, m) cin >> p[i] >> y[i], yd[p[i]].push_back(y[i]);
rep(i, n) sort(yd[i + 1].begin(... | [
"literal.number.change",
"call.arguments.change",
"variable_declaration.array_dimensions.change",
"identifier.change"
] | 1,017,531 | 1,017,530 | u620269708 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(m), y(m), yd[m + 1];
rep(i, m) cin >> p[i] >> y[i], yd[p[i]].push_back(y[i]);
rep(i, m) sort(yd[i + 1].begin(), yd[i + 1... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(100000), y(100000), yd[100001];
rep(i, m) cin >> p[i] >> y[i], yd[p[i]].push_back(y[i]);
rep(i, n) sort(yd[i + 1].begin(... | [
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"identifier.change",
"call.arguments.change"
] | 1,017,532 | 1,017,530 | u620269708 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
string make_id(int p, int y) {
string Pid, Yid;
Pid = to_string(p);
for (int i = Pid.size(); i <= 6; ++i) {
Pid = "0" + Pid;
}
Yid = to_string(y);
for (int i = Yid.size(); ... | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
string make_id(int p, int y) {
string Pid, Yid;
Pid = to_string(p);
for (int i = Pid.size(); i < 6; ++i) {
Pid = "0" + Pid;
}
Yid = to_string(y);
for (int i = Yid.size(); i... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,017,667 | 1,017,668 | u709583164 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
vector<vector<pii>> PY(N + 1);
vector<pii> res(N);
for (int i = 0; i < M; i++) {
int p, y;
cin >> p >> y;
PY[p].push_back(make_pair(y, i));... | #include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
vector<vector<pii>> PY(N + 1);
vector<pii> res(M);
for (int i = 0; i < M; i++) {
int p, y;
cin >> p >> y;
PY[p].push_back(make_pair(y, i));... | [] | 1,017,536 | 1,017,537 | u782098901 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <set>
using namespace std;
using P = pair<int, long>;
int main() {
int n, m;
cin >> n >> m;
P cities[m];
for (auto &c : cities)
cin >> c.first >> c.second;
int ids[m];
iota(ids, ids + m, 0);
sort(ids, ids + m, [... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <set>
using namespace std;
using P = pair<int, long>;
int main() {
int n, m;
cin >> n >> m;
P cities[m];
for (auto &c : cities)
cin >> c.first >> c.second;
int ids[m];
iota(ids, ids + m, 0);
sort(ids, ids + m, [... | [
"literal.number.change",
"io.output.change"
] | 1,017,669 | 1,017,670 | u956758464 | cpp |
p03221 | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
// define
const int INF = 1 << 24;
#define endl "\n"
#ifdef LOCAL
#define lout cerr
#else
ostream devnull(0);
#define lout devnull
#endif
#define AMULET \
cin.tie(0); ... | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
// define
const int INF = 1 << 24;
#define endl "\n"
#ifdef LOCAL
#define lout cerr
#else
ostream devnull(0);
#define lout devnull
#endif
#define AMULET \
cin.tie(0); ... | [
"call.arguments.add"
] | 1,017,673 | 1,017,674 | u530606147 | cpp |
p03221 | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
// define
const int INF = 1 << 24;
#define endl "\n"
#ifdef LOCAL
#define lout cerr
#else
ostream devnull(0);
#define lout devnull
#endif
#define AMULET \
cin.tie(0); ... | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
// define
const int INF = 1 << 24;
#define endl "\n"
#ifdef LOCAL
#define lout cerr
#else
ostream devnull(0);
#define lout devnull
#endif
#define AMULET \
cin.tie(0); ... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 1,017,675 | 1,017,674 | u530606147 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define YES cout << "YES" << endl;
#define NO cout << "NO" << endl;
#define Yes cout << "Yes" << endl;
#define No cout << "No" << endl;
#define INF INT_MAX
#define MOD 1000000007
#define PI acos(-1)
using ll = long long;
using ull = unsigned long long;
using Pii = pair<... | #include <bits/stdc++.h>
using namespace std;
#define YES cout << "YES" << endl;
#define NO cout << "NO" << endl;
#define Yes cout << "Yes" << endl;
#define No cout << "No" << endl;
#define INF INT_MAX
#define MOD 1000000007
#define PI acos(-1)
using ll = long long;
using ull = unsigned long long;
using Pii = pair<... | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 1,017,676 | 1,017,677 | u458798873 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <vector>
#define all(x) (x).begin(), (x).end()
using namespace std;
using P = pair<int, int>;
int main() {
int N, M;
cin >> N >> M;
vector<int> City[N + 1];
int P[M], Y[M];
for (int i = 0; i < M; i++) {
int p, y;
cin ... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <vector>
#define all(x) (x).begin(), (x).end()
using namespace std;
using P = pair<int, int>;
int main() {
int N, M;
cin >> N >> M;
vector<int> City[N + 1];
int P[M], Y[M];
for (int i = 0; i < M; i++) {
int p, y;
cin ... | [
"call.arguments.change"
] | 1,017,557 | 1,017,558 | u329706129 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <vector>
#define all(x) (x).begin(), (x).end()
using namespace std;
using P = pair<int, int>;
int main() {
int N, M;
cin >> N >> M;
vector<int> City[N + 1];
int P[M], Y[M];
for (int i = 0; i < M; i++) {
int p, y;
cin ... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <vector>
#define all(x) (x).begin(), (x).end()
using namespace std;
using P = pair<int, int>;
int main() {
int N, M;
cin >> N >> M;
vector<int> City[N + 1];
int P[M], Y[M];
for (int i = 0; i < M; i++) {
int p, y;
cin ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"call.arguments.change"
] | 1,017,559 | 1,017,558 | u329706129 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<long long int> P(M), Y(M);
vector<vector<long long int>> ken(N + 1);
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
ken[P[i]].push_back(Y[i]);
}
for (int i = 0; i < N; i++) {
sort(ken[i].begin(),... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<long long int> P(M), Y(M);
vector<vector<long long int>> ken(N + 1);
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
ken[P[i]].push_back(Y[i]);
}
for (int i = 0; i <= N; i++) {
sort(ken[i].begin()... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 1,017,562 | 1,017,563 | u926416331 | cpp |
p03221 | #include <algorithm> // sort
#include <bits/stdc++.h>
#include <map>
#include <set>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<tuple<int, long long int, int>> pyi(m);
int p;
long long y;
for (int i = 0; i < m; i++) {
cin >> p >> y;
pyi[i] ... | #include <algorithm> // sort
#include <bits/stdc++.h>
#include <map>
#include <set>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<tuple<int, long long int, int>> pyi(m);
int p;
long long y;
for (int i = 0; i < m; i++) {
cin >> p >> y;
pyi[i] ... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,017,694 | 1,017,695 | u704064492 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll deg(ll n) {
ll count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
int main() {
ll n, m;
cin >> n >> m;
ll y[m]... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll deg(ll n) {
ll count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
int main() {
ll n, m;
cin >> n >> m;
ll y[m]... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,017,564 | 1,017,565 | u677400065 | cpp |
p03221 | #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> p(M);
// vector<int> y(M);
vector<pair<int, int>> order(M);
vector<int> cnt(N, 0);
for (int i = 0; i... | #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> p(M);
// vector<int> y(M);
vector<pair<int, int>> order(M);
vector<int> cnt(N, 0);
for (int i = 0; i... | [
"literal.number.change",
"io.output.change"
] | 1,017,696 | 1,017,697 | u311874435 | cpp |
p03221 | // {{{ by unolight
#include <bits/stdc++.h>
#include <unistd.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#define SZ(x) ((int)(x).size())
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define REP1(i, a, b) for (int i = (a); i <= int(b); i++)... | // {{{ by unolight
#include <bits/stdc++.h>
#include <unistd.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#define SZ(x) ((int)(x).size())
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define REP1(i, a, b) for (int i = (a); i <= int(b); i++)... | [
"identifier.change",
"call.function.change",
"call.arguments.add"
] | 1,017,570 | 1,017,571 | u385825353 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
// 入力
long N, M;
cin >> N >> M;
vector<long> P(M);
vector<pair<pair<long, long>, long>> cities(M);
for (long i = 0; i < M; i++) {
long Y;
cin >> P[i] >> Y;
cities[i] = make_pair(mak... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
// 入力
long N, M;
cin >> N >> M;
vector<long> P(M);
vector<pair<pair<long, long>, long>> cities(M);
for (long i = 0; i < M; i++) {
long Y;
cin >> P[i] >> Y;
cities[i] = make_pair(mak... | [
"assignment.change"
] | 1,017,576 | 1,017,577 | u865500049 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> PA;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i, x) for (long long i = 0; i < x; i++)
#define repn(i, x) ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> PA;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i, x) for (long long i = 0; i < x; i++)
#define repn(i, x) ... | [] | 1,017,708 | 1,017,709 | u709604332 | cpp |
p03221 | #include <algorithm>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
#define ll long long int
#define rep(i, a, n) for (int i = a; i < n; i++)
#define INF 1e9
#define LINF 1e17
#define MOD (int)(1e9 +... | #include <algorithm>
#include <ctype.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
#define ll long long int
#define rep(i, a, n) for (int i = a; i < n; i++)
#define INF 1e9
#define LINF 1e17
#define MOD (int)(1e9 +... | [
"literal.number.change",
"assignment.value.change"
] | 1,017,710 | 1,017,711 | u705296057 | cpp |
p03221 | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for (int i = x; i < n; i++)
#define OP(m) cout << m << endl
typedef long long ll;
typedef unsigned long long ull;
... | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for (int i = x; i < n; i++)
#define OP(m) cout << m << endl
typedef long long ll;
typedef unsigned long long ull;
... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,017,584 | 1,017,585 | u016189984 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REP(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr << #x << " = " << x << endl
const long long MOD = 1000000007;
int main() {
ll n, m;
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REP(i, n) for (ll i = n - 1; i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr << #x << " = " << x << endl
const long long MOD = 1000000007;
int main() {
ll n, m;
... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,017,717 | 1,017,718 | u355923883 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl... | [
"expression.operation.binary.add"
] | 1,017,589 | 1,017,590 | u491550356 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define p(s) std::cout << s;
#define pl(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl... | [
"control_flow.branch.if.condition.change"
] | 1,017,591 | 1,017,590 | u491550356 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
#define p(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl;
#define Yes(j) std::cout << (j ? "Yes" : "N... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
#define p(s) std::cout << s << endl;
#define printIf(j, s1, s2) cout << (j ? s1 : s2) << endl;
#define YES(j) cout << (j ? "YES" : "NO") << endl;
#define Yes(j) std::cout << (j ? "Yes" : "N... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,017,592 | 1,017,593 | u491550356 | cpp |
p03221 | //#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <vector>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
using namespace std;
#define FAST \
ios_base ::sync_with_stdio(false); ... | //#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <vector>
#include <climits>
#include <cmath>
#include <cstring>
#include <iomanip>
using namespace std;
#define FAST \
ios_base ::sync_with_stdio(false); ... | [
"identifier.change",
"expression.operation.binary.change"
] | 1,017,594 | 1,017,595 | u564089749 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
#include <vector>
#define lli long long
#define all(i) i.begin(), i.end()
#define rall(i) i.rbegin(), i.rend()
#define rep0(i, j) for (int i = 0; i < j; i++)
#define rep1(i, j) for (int i = 1; i <= j; i++)
#define rep0d(i, j) for (int i = j -... | #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
#include <vector>
#define lli long long
#define all(i) i.begin(), i.end()
#define rall(i) i.rbegin(), i.rend()
#define rep0(i, j) for (int i = 0; i < j; i++)
#define rep1(i, j) for (int i = 1; i <= j; i++)
#define rep0d(i, j) for (int i = j -... | [
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 1,017,726 | 1,017,727 | u950603962 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> PtoY(n + 1);
vector<pair<int, int>> ID(m);
for (int i = 0; i < m; i++) {
int p, y;
cin >> p... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> PtoY(n + 1);
vector<pair<int, int>> ID(m);
for (int i = 0; i < m; i++) {
int p, y;
cin >> p... | [
"literal.number.change",
"io.output.change"
] | 1,017,728 | 1,017,729 | u990764614 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <tuple>
#include <vector>
#define int long long
using namespace std;
int swap(int a, int b) {
int tmp;
tmp = a;
a = b;
b = tmp;
}
signed main() {
int N, M... | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <tuple>
#include <vector>
#define int long long
using namespace std;
int swap(int a, int b) {
int tmp;
tmp = a;
a = b;
b = tmp;
}
signed main() {
int N, M... | [
"expression.operation.binary.remove"
] | 1,017,730 | 1,017,731 | u322714721 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
class city {
public:
city(unsigned long i, unsigned long y);
unsigned long i, y;
};
city::city(unsigned long i, unsigned long y) : i(i), y(y) {}
int main() {
unsigned long N, M;
cin >> N >> M;
vector<vector<city *>> ps(N + 1)... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
class city {
public:
city(unsigned long i, unsigned long y);
unsigned long i, y;
};
city::city(unsigned long i, unsigned long y) : i(i), y(y) {}
int main() {
unsigned long N, M;
cin >> N >> M;
vector<vector<city *>> ps(N + 1)... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"call.remove"
] | 1,017,600 | 1,017,601 | u494655741 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,017,732 | 1,017,733 | u612271542 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | [] | 1,017,734 | 1,017,733 | u612271542 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,017,735 | 1,017,733 | u612271542 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,017,732 | 1,017,736 | u612271542 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | [] | 1,017,734 | 1,017,736 | u612271542 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(n), y(n);
vector<vector<int>> data(
n); // (prefecture, year), be careful with the initialization...
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
data[p[i] - 1].push_back(y[i]);
}
for (... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<long long int> p(m), y(m);
vector<vector<long long int>> data(
n); // (prefecture, year), be careful with the initialization...
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
data[p[i] - 1].push_back... | [
"variable_declaration.type.widen.change"
] | 1,017,610 | 1,017,611 | u180716041 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
using namespace std;
using Int = long long;
Int INF = 1LL << 60;
const Int MOD = 1000000007;
struct city {
Int pr... | [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 1,017,735 | 1,017,736 | u612271542 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define itn int
#define mod 1000000007
#define INFi 2147483647
#define INFl 9223372036854775807LL
#define fi first
#define se second
#define be begin()
#define en end()
int abs(int a, int b) {
int c = max(a, b) - min(a, b);
return c;
}
int gcd(int ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define itn int
#define mod 1000000007
#define INFi 2147483647
#define INFl 9223372036854775807LL
#define fi first
#define se second
#define be begin()
#define en end()
int abs(int a, int b) {
int c = max(a, b) - min(a, b);
return c;
}
int gcd(int ... | [
"expression.operation.binary.remove"
] | 1,017,612 | 1,017,613 | u831161882 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(n + 1);
vector<int> y(m + 1);
vector<int> id[n + 1];
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
id[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; i++) {
... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(m + 1);
vector<int> y(m + 1);
vector<int> id[n + 1];
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
id[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; i++) {
... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,017,737 | 1,017,738 | u160754729 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(n + 1);
vector<int> y(m + 1);
vector<int> id[n + 1];
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
id[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; i++) {
... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(m + 1);
vector<int> y(m + 1);
vector<int> id[n + 1];
for (int i = 0; i < m; i++) {
cin >> p[i] >> y[i];
id[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; i++) {
... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 1,017,739 | 1,017,738 | u160754729 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int64_t i = 0; i < (int64_t)(n); i++)
using namespace std;
... | #include <algorithm>
#include <bitset>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int64_t i = 0; i < (int64_t)(n); i++)
using namespace std;
... | [
"literal.number.change",
"io.output.change"
] | 1,017,616 | 1,017,617 | u702462808 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
scanf("%d%d", &N, &M);
vector<tuple<int, int, int>> pref_year_id(M);
for (int i = 0; i < M; i++) {
int pid, year;
scanf("%d%d", &pid, &year);
pref_year_id.at(i) = make_tuple(pid, year, i);
}
sort(pref_year_id.begin(), pref_y... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
scanf("%d%d", &N, &M);
vector<tuple<int, int, int>> pref_year_id(M);
for (int i = 0; i < M; i++) {
int pid, year;
scanf("%d%d", &pid, &year);
pref_year_id.at(i) = make_tuple(pid, year, i);
}
sort(pref_year_id.begin(), pref_y... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"variable_access.subscript.index.change",
"assignment.value.change"
] | 1,017,624 | 1,017,622 | u553129408 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <set>
#include <string>
#include <vector>
#define SORT(a) sort((a).begin(), (a).end())
#define RSORT(a) sort((a).rbegin(), (a).rend())
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(a) a.begin(), a.end()
using namespace std;
int main() {
... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <set>
#include <string>
#include <vector>
#define SORT(a) sort((a).begin(), (a).end())
#define RSORT(a) sort((a).rbegin(), (a).rend())
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(a) a.begin(), a.end()
using namespace std;
int main() {
... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change"
] | 1,017,751 | 1,017,752 | u324303263 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
struct Data {
int idx;
int P; // prefacture
int Y; // year
};
inline bool operator<(const Data &a, const Data &b) { return a.Y < b.Y; }
int keta(int... | #include <algorithm>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
struct Data {
int idx;
int P; // prefacture
int Y; // year
};
inline bool operator<(const Data &a, const Data &b) { return a.Y > b.Y; }
int keta(int... | [
"misc.opposites",
"expression.operator.compare.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 1,017,628 | 1,017,629 | u231541008 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
#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, m, n) for (int i = m; i <= n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end()... | #include <bits/stdc++.h>
using namespace std;
#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, m, n) for (int i = m; i <= n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end()... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,017,630 | 1,017,631 | u986276444 | cpp |
p03221 | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define drrep(i, n) for (int i = n; i > 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#... | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define drrep(i, n) for (int i = n; i > 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#... | [] | 1,017,632 | 1,017,633 | u700484101 | cpp |
p03221 | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define drrep(i, n) for (int i = n; i > 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#... | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define drrep(i, n) for (int i = n; i > 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#... | [
"identifier.change",
"expression.operation.binary.change",
"call.arguments.change"
] | 1,017,634 | 1,017,633 | u700484101 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<long>> data(M, vector<long>(3));
vector<long> count(N);
vector<pair<long, long>> sub(M);
for (int i = 0; i < M; i++) {
cin >> sub.at(i).first >> sub.at(i).second;
data.at(i).at(0) = sub.at(i).second;
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<long>> data(M, vector<long>(3));
vector<long> count(N);
vector<pair<long, long>> sub(M);
for (int i = 0; i < M; i++) {
cin >> sub.at(i).first >> sub.at(i).second;
data.at(i).at(0) = sub.at(i).second;
... | [
"literal.number.change",
"io.output.change"
] | 1,017,769 | 1,017,770 | u239087789 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> P(m), Y(m);
rep(i, m) {
cin >> P[i] >> Y[i];
P[i]--;
}
vector<vector<int>> vals(n);
rep(i, n) vals[P[i]].push_back(Y[i]);
rep(i, ... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> P(m), Y(m);
rep(i, m) {
cin >> P[i] >> Y[i];
P[i]--;
}
vector<vector<int>> vals(n);
rep(i, m) vals[P[i]].push_back(Y[i]);
rep(i, n) sort(vals[i].begin... | [
"identifier.change",
"call.arguments.change"
] | 1,017,642 | 1,017,643 | u747390421 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
in... | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
in... | [
"call.arguments.change"
] | 1,017,771 | 1,017,772 | u947304300 | cpp |
p03221 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> P(m), Y(m);
vector<int> P_Y[100001];
for (int i = 0; i < m; i++) {
cin >> P[i] >> Y[i];
P_Y[P[i]].push_back(Y[i]);
}
for (int i = 0; i < m + 1; i++)... | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<long int> P(m), Y(m);
vector<int> P_Y[100001];
for (int i = 0; i < m; i++) {
cin >> P[i] >> Y[i];
P_Y[P[i]].push_back(Y[i]);
}
for (int i = 0; i < 100001... | [
"variable_declaration.type.widen.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,017,775 | 1,017,774 | u476534289 | cpp |
p03221 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
int P[M], Y[M];
rep(i, M) cin >> P[i] >> Y[i];
vector<int> vec[N + 1];
rep(i, M) vec[P[i]].push_back(Y[i]);
rep(i, N) sort(vec[i].begin(), vec[i].end(... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
int P[M], Y[M];
rep(i, M) cin >> P[i] >> Y[i];
vector<int> vec[N + 1];
rep(i, M) vec[P[i]].push_back(Y[i]);
rep(i, N + 1) sort(vec[i].begin(), vec[i].... | [
"expression.operation.binary.add"
] | 1,017,648 | 1,017,649 | u408372746 | cpp |
p03221 | #include <algorithm>
#include <bitset>
#include <complex>
#include <cstdio>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#i... | #include <algorithm>
#include <bitset>
#include <complex>
#include <cstdio>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#i... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change"
] | 1,017,782 | 1,017,783 | u940569542 | cpp |
p03221 | #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 rng(x) (x).begin(), (x).end()
#define rrng(x) (x).rbegin(), (x).rend()
#define debug(x) cout << #x << " = " << (x) << endl;
#define SUM(x) accumulate(rng(x), 0)
#define fi first
#defin... | #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 rng(x) (x).begin(), (x).end()
#define rrng(x) (x).rbegin(), (x).rend()
#define debug(x) cout << #x << " = " << (x) << endl;
#define SUM(x) accumulate(rng(x), 0)
#define fi first
#defin... | [
"identifier.change",
"expression.operation.binary.change"
] | 1,017,657 | 1,017,658 | u850516963 | cpp |
p03221 | #include <bits/stdc++.h>
typedef long long ll;
#define SZ(x) ((int)(x).size())
using namespace std;
string zero_fill(int number, int n) {
stringstream ss;
ss << setw(n) << setfill('0') << number;
return ss.str();
}
int main() {
int N, M;
cin >> N >> M;
vector<pair<pair<int, int>, int>> P(M); // pair<pa... | #include <bits/stdc++.h>
typedef long long ll;
#define SZ(x) ((int)(x).size())
using namespace std;
string zero_fill(int number, int n) {
stringstream ss;
ss << setw(n) << setfill('0') << number;
return ss.str();
}
int main() {
int N, M;
cin >> N >> M;
vector<pair<pair<int, int>, int>> P(M); // pair<pa... | [
"assignment.add"
] | 1,017,784 | 1,017,785 | u725069695 | cpp |
p03221 | #include <bits/stdc++.h>
typedef long long ll;
#define SZ(x) ((int)(x).size())
using namespace std;
string zero_fill(int number, int n) {
stringstream ss;
ss << setw(n) << setfill('0') << number;
return ss.str();
}
int main() {
int N, M;
cin >> N >> M;
vector<pair<pair<int, ll>, int>> P(M); // pair<pai... | #include <bits/stdc++.h>
typedef long long ll;
#define SZ(x) ((int)(x).size())
using namespace std;
string zero_fill(int number, int n) {
stringstream ss;
ss << setw(n) << setfill('0') << number;
return ss.str();
}
int main() {
int N, M;
cin >> N >> M;
vector<pair<pair<int, ll>, int>> P(M); // pair<pai... | [
"assignment.add"
] | 1,017,786 | 1,017,787 | u725069695 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return
// true; } return false; } template<class T> inline bool chmin(T& a, T b) { if (a
// > b) { a = b; return true; } return false; }
/* attention
long longのシフト演算には気をつけよう
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return
// true; } return false; } template<class T> inline bool chmin(T& a, T b) { if (a
// > b) { a = b; return true; } return false; }
/* attention
long longのシフト演算には気をつけよう
... | [
"identifier.change",
"expression.operation.binary.change"
] | 1,017,661 | 1,017,662 | u052332717 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ll INF = (1LL << 60);
int ma... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const ll INF = (1LL << 60);
int ma... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,017,663 | 1,017,664 | u052332717 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, x;
cin >> n >> m;
vector<int> c(n), d(n);
vector<vector<int>> e(n + 1);
for (int i = 0; i < m; i++) {
cin >> c[i] >> d[i];
e[c[i]].push_back(d[i]);
}
for (int i = 0; i < n + 1; i++) {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, x;
cin >> n >> m;
vector<int> c(m), d(m);
vector<vector<int>> e(n + 1);
for (int i = 0; i < m; i++) {
cin >> c[i] >> d[i];
e[c[i]].push_back(d[i]);
}
for (int i = 0; i < n + 1; i++) {
... | [] | 1,017,792 | 1,017,793 | u885523920 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, x;
cin >> n >> m;
vector<int> c(n), d(n);
vector<vector<int>> e(n + 1);
for (int i = 0; i < n; i++) {
cin >> c[i] >> d[i];
e[c[i]].push_back(d[i]);
}
for (int i = 0; i < n + 1; i++) {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, x;
cin >> n >> m;
vector<int> c(m), d(m);
vector<vector<int>> e(n + 1);
for (int i = 0; i < m; i++) {
cin >> c[i] >> d[i];
e[c[i]].push_back(d[i]);
}
for (int i = 0; i < n + 1; i++) {
... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,017,794 | 1,017,793 | u885523920 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<int>> vvi;
const int MOD = 1e9 + 7;
const int INF = 2e9;
#define pb push_back
#define mp make_pair
#define mt make_tuple
template <class T> bool chmax(T... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<int>> vvi;
const int MOD = 1e9 + 7;
const int INF = 2e9;
#define pb push_back
#define mp make_pair
#define mt make_tuple
template <class T> bool chmax(T... | [
"identifier.change",
"call.arguments.change"
] | 1,017,810 | 1,017,811 | u193591892 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<int>> vvi;
const int MOD = 1e9 + 7;
const int INF = 2e9;
#define pb push_back
#define mp make_pair
#define mt make_tuple
template <class T> bool chmax(T... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<int>> vvi;
const int MOD = 1e9 + 7;
const int INF = 2e9;
#define pb push_back
#define mp make_pair
#define mt make_tuple
template <class T> bool chmax(T... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.remove"
] | 1,017,812 | 1,017,811 | u193591892 | cpp |
p03221 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i < i##_len; ++i)
#define ALL(x) (x).begin(), (x).end()
#define PRINT(A) std::cout << (#A) << ":" << (A) << std::endl;
typedef long long int ll;
const int MOD = 1e9 + 7;
const i... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i < i##_len; ++i)
#define ALL(x) (x).begin(), (x).end()
#define PRINT(A) std::cout << (#A) << ":" << (A) << std::endl;
typedef long long int ll;
const int MOD = 1e9 + 7;
const i... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,017,815 | 1,017,816 | u743229067 | cpp |
p03221 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i < i##_len; ++i)
#define ALL(x) (x).begin(), (x).end()
#define PRINT(A) std::cout << (#A) << ":" << (A) << std::endl;
typedef long long int ll;
const int MOD = 1e9 + 7;
const i... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i < i##_len; ++i)
#define ALL(x) (x).begin(), (x).end()
#define PRINT(A) std::cout << (#A) << ":" << (A) << std::endl;
typedef long long int ll;
const int MOD = 1e9 + 7;
const i... | [
"identifier.replace.remove",
"literal.replace.add",
"variable_declaration.array_dimensions.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,017,817 | 1,017,816 | u743229067 | cpp |
p03221 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<pair<long long, long long>, long long>> ypx(m);
vector<long long> ans(m);
vector<long long> cnt(n);
for (int i = 0; i < m; ++i) {
cin >... | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<pair<long long, long long>, long long>> ypx(m);
vector<long long> ans(m);
vector<long long> cnt(n + 1);
for (int i = 0; i < m; ++i) {
c... | [
"assignment.change"
] | 1,017,820 | 1,017,821 | u848359007 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
map<int, vector<int>> mp;
for (int i = 0; i < m; i++)
mp[p[i]].push_back(y[i]);
for (int i = 0; i < n; i++)
sort(begin(mp[i]), end(mp[i]... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> p(m), y(m);
for (int i = 0; i < m; i++)
cin >> p[i] >> y[i];
map<int, vector<int>> mp;
for (int i = 0; i < m; i++)
mp[p[i]].push_back(y[i]);
for (int i = 0; i < mp.size(); i++)
sort(begin(mp[i]), e... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"call.add"
] | 1,017,822 | 1,017,823 | u731175398 | cpp |
p03221 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> ... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> ... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,017,826 | 1,017,827 | u723550619 | cpp |
p03221 | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<pair<int, int>>> city(M + 1);
for (int i = 0; i < M; ++i) {
int P, Y;
cin >> P >> Y;
--P;
city[P].push_back({Y, i});
}
vector<pair<int, int>> ans(M + 1);
for (int i = 0; i... | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<pair<int, int>>> city(1e5 + 1); //ここの数に注意
for (int i = 0; i < M; ++i) {
int P, Y;
cin >> P >> Y;
--P;
city[P].push_back({Y, i});
}
vector<pair<int, int>> ans(M);
for (int ... | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 1,017,828 | 1,017,829 | u701556979 | cpp |
p03221 | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<pair<int, int>>> city(M);
for (int i = 0; i < M; ++i) {
int P, Y;
cin >> P >> Y;
--P;
city[P].push_back({Y, i});
}
vector<pair<int, int>> ans(M);
for (int i = 0; i < N; ++... | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<pair<int, int>>> city(1e5 + 1); //ここの数に注意
for (int i = 0; i < M; ++i) {
int P, Y;
cin >> P >> Y;
--P;
city[P].push_back({Y, i});
}
vector<pair<int, int>> ans(M);
for (int ... | [
"assignment.change"
] | 1,017,830 | 1,017,829 | u701556979 | cpp |
p03221 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M), Y(M);
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
P[i]--;
}
vector<vector<int>> vals(N);
for (int i = 0; i < M; i++) {
vals[P[i]].push_back(Y[i]);... | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> P(M), Y(M);
for (int i = 0; i < M; i++) {
cin >> P[i] >> Y[i];
P[i]--;
}
vector<vector<int>> vals(N);
for (int i = 0; i < M; i++) {
vals[P[i]].push_back(Y[i]);... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,017,833 | 1,017,834 | u845882023 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<ll> a[100000];
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(m), y(m);
for (int i = 0; i < m; ++i) {
cin >> p[i] >> y[i];
a[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; ++i) {
sort(a[i].begin(), a[i].end());
}
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<ll> a[100000];
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(m), y(m);
for (int i = 0; i < m; ++i) {
cin >> p[i] >> y[i];
a[p[i]].push_back(y[i]);
}
for (int i = 1; i <= n; ++i) {
sort(a[i].begin(), a[i].end());
}... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,017,845 | 1,017,846 | u614576698 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<ll> a[100000];
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(n), y(m);
for (int i = 0; i < m; ++i) {
cin >> p[i] >> y[i];
a[p[i]].push_back(y[i]);
}
for (int i = 0; i < n; ++i) {
sort(a[i].begin(), a[i].end());
}
... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<ll> a[100000];
int main() {
ll n, m;
cin >> n >> m;
vector<ll> p(m), y(m);
for (int i = 0; i < m; ++i) {
cin >> p[i] >> y[i];
a[p[i]].push_back(y[i]);
}
for (int i = 1; i <= n; ++i) {
sort(a[i].begin(), a[i].end());
}... | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,017,847 | 1,017,846 | u614576698 | cpp |
p03221 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <vector>
#define int long long
#define endre \
getchar(); ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <vector>
#define int long long
#define endre \
getchar(); ... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 1,017,848 | 1,017,849 | u147049801 | cpp |
p03221 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> data;
for (int i = 0; i < m; i++) {
vector<int> x;
data.push_back(x);
}
int input_order[m][2];
for (int i = 0; i < m; i++) {
int perfecture, year;
cin >> perfecture >> year;
input_or... | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> data;
for (int i = 0; i < 100010; i++) {
vector<int> x;
data.push_back(x);
}
int input_order[m][2];
for (int i = 0; i < m; i++) {
int perfecture, year;
cin >> perfecture >> year;
inp... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 1,017,862 | 1,017,861 | u240010800 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.