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 9
values |
|---|---|---|---|---|---|---|---|
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef tuple<int, int, int> tiii;
constexpr int INF = 1e9;
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<int>> G(N + 1);
vector<vector<int>> invG(N + 1);
vector<tiii> edge(M);
for (int i = 0; i < M; i++) {
int A, B, C;
cin >> A >> B >> C... | #include <bits/stdc++.h>
using namespace std;
typedef tuple<int, int, int> tiii;
constexpr int INF = 1e9;
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<int>> G(N + 1);
vector<vector<int>> invG(N + 1);
vector<tiii> edge(M);
for (int i = 0; i < M; i++) {
int A, B, C;
cin >> A >> B >> C... | [
"assignment.variable.change",
"identifier.change"
] | 750,738 | 750,739 | u858575800 | cpp |
p02949 | #include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
int N, M, P, A[5050], B[5050], C[5050];
bool visit[2555], rvisit[2555];
long long dist[2555];
bool nvisit[2555];
long long ndist[2555];
int main() {
scanf("%d %d %d", &N, &M, &P);
for (int i = 0; i < M; i++)
scanf("%d %d %d", &A[i], ... | #include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
int N, M, P, A[5050], B[5050], C[5050];
bool visit[2555], rvisit[2555];
long long dist[2555];
bool nvisit[2555];
long long ndist[2555];
int main() {
scanf("%d %d %d", &N, &M, &P);
for (int i = 0; i < M; i++)
scanf("%d %d %d", &A[i], ... | [
"assignment.variable.change",
"identifier.change"
] | 750,740 | 750,741 | u233632872 | cpp |
p02949 | #include <algorithm>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP(i, n) for (int i = 1; i < (int)(n); ++i)
using namespace std;
constexpr long long INF = 1e18;
struct edge {
int from;
int to;
int cost;
};
vector<int> go_0; // 0からいける？
vector<int> go_N; //... | #include <algorithm>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP(i, n) for (int i = 1; i < (int)(n); ++i)
using namespace std;
constexpr long long INF = 1e18;
struct edge {
int from;
int to;
int cost;
};
vector<int> go_0; // 0からいける？
vector<int> go_N; //... | [
"variable_access.subscript.index.change"
] | 750,752 | 750,753 | u826189900 | cpp |
p02949 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
vector<pair<int, long long>> edges[250... | #define _USE_MATH_DEFINES
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
vector<pair<int, long long>> edges[250... | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 750,758 | 750,759 | u623349537 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll n, m, p;
cin >> n >> m >> p;
vector<ll> a(m), b(m), c(m), dp(n, 1e11);
vector<bool> reach(n, false);
bool flag = false;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
c[i] = p... | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
ll n, m, p;
cin >> n >> m >> p;
vector<ll> a(m), b(m), c(m), dp(n, 1e11);
vector<bool> reach(n, false);
bool flag = false;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
c[i] = p... | [
"literal.number.change",
"assignment.value.change"
] | 750,775 | 750,776 | u246401216 | cpp |
p02949 | #include "bits/stdc++.h"
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define For(i, n1, n2) for (int i = (int)(n1); i < (int)(n2); i++)
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define RREP(i, n) for (ll i = ((ll)(n)-1); i >= 0; i--)
#define FOR(i, n1, n2) for (ll i = (ll)(n1); i... | #include "bits/stdc++.h"
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define For(i, n1, n2) for (int i = (int)(n1); i < (int)(n2); i++)
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define RREP(i, n) for (ll i = ((ll)(n)-1); i >= 0; i--)
#define FOR(i, n1, n2) for (ll i = (ll)(n1); i... | [
"identifier.change",
"call.arguments.change"
] | 750,779 | 750,780 | u030685402 | cpp |
p02949 | #include "bits/stdc++.h"
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define For(i, n1, n2) for (int i = (int)(n1); i < (int)(n2); i++)
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define RREP(i, n) for (ll i = ((ll)(n)-1); i >= 0; i--)
#define FOR(i, n1, n2) for (ll i = (ll)(n1); i... | #include "bits/stdc++.h"
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define For(i, n1, n2) for (int i = (int)(n1); i < (int)(n2); i++)
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define RREP(i, n) for (ll i = ((ll)(n)-1); i >= 0; i--)
#define FOR(i, n1, n2) for (ll i = (ll)(n1); i... | [
"identifier.change",
"call.arguments.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 750,781 | 750,780 | u030685402 | cpp |
p02949 | #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 = 1001001001;
vector<int> to[2505];
vector<int> rto[2505];
bool reachableFrom1[2505];
bool reachableToN[2505];
bool ok[2505];
void dfs(int v) {
if (reachableFrom1[v])
return;
reachab... | #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 = 1001001001;
vector<int> to[2505];
vector<int> rto[2505];
bool reachableFrom1[2505];
bool reachableToN[2505];
bool ok[2505];
void dfs(int v) {
if (reachableFrom1[v])
return;
reachab... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 750,785 | 750,783 | u506858457 | cpp |
p02949 | #include <bits/stdc++.h>
#define int long long
using namespace std;
struct edge {
int a, b, c;
};
vector<vector<pair<int, int>>> adj1, adj2;
edge s[5005];
int dp[2505];
int n, m, p;
int ans = 0;
int vis1[2505], vis2[2505];
int mm[2505];
void solve() {
for (int i = 0; i < n - 1; ++i) {
for (int j = 0; j < m; +... | #include <bits/stdc++.h>
#define int long long
using namespace std;
struct edge {
int a, b, c;
};
vector<vector<pair<int, int>>> adj1, adj2;
edge s[5005];
int dp[2505];
int n, m, p;
int ans = 0;
int vis1[2505], vis2[2505];
int mm[2505];
void solve() {
for (int i = 0; i < n - 1; ++i) {
for (int j = 0; j < m; +... | [
"identifier.change",
"call.function.change"
] | 750,786 | 750,787 | u193815565 | cpp |
p02949 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const int INF = 1001001001;
vector<int> to[2505];
vector<int> rto[2505];
int reachableFrom1[2505];
int reachableFromN[2505];
int ok[2505];
void dfs(int v) {
if (reachableFrom1[v])
return;
reachableFrom1[v] = true;
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const int INF = 1001001001;
vector<int> to[2505];
vector<int> rto[2505];
int reachableFrom1[2505];
int reachableFromN[2505];
int ok[2505];
void dfs(int v) {
if (reachableFrom1[v])
return;
reachableFrom1[v] = true;
... | [
"identifier.change"
] | 750,788 | 750,789 | u976045502 | cpp |
p02949 | #include <algorithm>
#include <iostream>
using namespace std;
long long N, M, P, A[1 << 18], B[1 << 18], C[1 << 18];
long long dist[1 << 18], predist[1 << 18];
bool used1[1 << 18], used2[1 << 18];
int main() {
cin >> N >> M >> P;
for (int i = 1; i <= M; i++) {
cin >> A[i] >> B[i] >> C[i];
C[i] -= P;
}
... | #include <algorithm>
#include <iostream>
using namespace std;
long long N, M, P, A[1 << 18], B[1 << 18], C[1 << 18];
long long dist[1 << 18], predist[1 << 18];
bool used1[1 << 18], used2[1 << 18];
int main() {
cin >> N >> M >> P;
for (int i = 1; i <= M; i++) {
cin >> A[i] >> B[i] >> C[i];
C[i] -= P;
}
... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 750,790 | 750,791 | u504103417 | cpp |
p02949 | #include <algorithm>
#include <iostream>
using namespace std;
long long N, M, P, A[1 << 18], B[1 << 18], C[1 << 18];
long long dist[1 << 18], predist[1 << 18];
bool used1[1 << 18], used2[1 << 18];
int main() {
cin >> N >> M >> P;
for (int i = 1; i <= M; i++) {
cin >> A[i] >> B[i] >> C[i];
C[i] -= P;
}
... | #include <algorithm>
#include <iostream>
using namespace std;
long long N, M, P, A[1 << 18], B[1 << 18], C[1 << 18];
long long dist[1 << 18], predist[1 << 18];
bool used1[1 << 18], used2[1 << 18];
int main() {
cin >> N >> M >> P;
for (int i = 1; i <= M; i++) {
cin >> A[i] >> B[i] >> C[i];
C[i] -= P;
}
... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 750,792 | 750,791 | u504103417 | cpp |
p02949 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long int
#define MAX 1000000000000
using namespace std;
int main(void) {
ll n, m, p;
cin >> n >> m >> p;
vector<vector<pair<ll, ll>>> list(n + 1);
rep(i, ... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long int
#define MAX 1000000000000
using namespace std;
int main(void) {
ll n, m, p;
cin >> n >> m >> p;
vector<vector<pair<ll, ll>>> list(n + 1);
rep(i, ... | [
"control_flow.break.remove",
"control_flow.continue.add"
] | 750,795 | 750,796 | u582848517 | cpp |
p02949 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &os, const vecto... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &os, const vecto... | [
"expression.operation.binary.remove"
] | 750,797 | 750,798 | u532573979 | cpp |
p02949 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007, INF = 1111111111;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostrea... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007, INF = 1111111111;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostrea... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 750,800 | 750,801 | u532573979 | cpp |
p02949 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &os, const vecto... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
const int MOD = 1000000007;
using namespace std;
using lint = long long;
template <class T> ostream &operator<<(ostream &os, const vecto... | [
"control_flow.branch.if.condition.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 750,805 | 750,804 | u532573979 | cpp |
p02949 | // #define DEBUGGING
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ALL(V) (V).begin(), (V).end()
#define ALLR(V) (V).rbegin(), (V).rend()
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
using ll = int64_t;
using ull = uint64_t;
using PLL = pair<ll, ll>;
t... | // #define DEBUGGING
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ALL(V) (V).begin(), (V).end()
#define ALLR(V) (V).rbegin(), (V).rend()
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
using ll = int64_t;
using ull = uint64_t;
using PLL = pair<ll, ll>;
t... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 750,818 | 750,819 | u216962796 | cpp |
p02949 | // #define DEBUGGING
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ALL(V) (V).begin(), (V).end()
#define ALLR(V) (V).rbegin(), (V).rend()
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
using ll = int64_t;
using ull = uint64_t;
using PLL = pair<ll, ll>;
t... | // #define DEBUGGING
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ALL(V) (V).begin(), (V).end()
#define ALLR(V) (V).rbegin(), (V).rend()
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
using ll = int64_t;
using ull = uint64_t;
using PLL = pair<ll, ll>;
t... | [
"identifier.change",
"control_flow.branch.if.condition.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 750,820 | 750,819 | u216962796 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
typedef pair<LL, LL> PL;
typedef pair<P, LL> PP;
typedef pair<P, LL> PP;
typedef long long LL;
#define xx first
#define yy second
vector<int> G1[110000], G2[110000];
vector<tuple<int, int, int>> vt;
int n, m, p;
int eg[11000... | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
typedef pair<LL, LL> PL;
typedef pair<P, LL> PP;
typedef pair<P, LL> PP;
typedef long long LL;
#define xx first
#define yy second
vector<int> G1[110000], G2[110000];
vector<tuple<int, int, int>> vt;
int n, m, p;
int eg[11000... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 750,840 | 750,841 | u032032867 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "../lib/dump.hpp"
#else
#define dump(...)
#define dumpv(...)
#endif
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 1e9 + 7;
const int INF = 1001001001;
const ll LINF = 10010020030040050... | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "../lib/dump.hpp"
#else
#define dump(...)
#define dumpv(...)
#endif
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 1e9 + 7;
const int INF = 1001001001;
const ll LINF = 10010020030040050... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 750,845 | 750,846 | u147305315 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
// [a -> b-1]
#define reps(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
// [0 -> a-1]
#define rep(i, a) reps(i, 0, (a))
// [a-1 -> b]
#define rreps(i, a, b) for (int i = (int)((a)-1); i >= (int)(b); i--)
// [a-1 -> 0]
#def... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
// [a -> b-1]
#define reps(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
// [0 -> a-1]
#define rep(i, a) reps(i, 0, (a))
// [a-1 -> b]
#define rreps(i, a, b) for (int i = (int)((a)-1); i >= (int)(b); i--)
// [a-1 -> 0]
#def... | [
"expression.operation.unary.add",
"call.arguments.change"
] | 750,847 | 750,848 | u946322619 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <climits> // LLONG_MAX, LLONG_MIN, INT_MIN, INT_MAX
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <util... | #include <algorithm>
#include <assert.h>
#include <climits> // LLONG_MAX, LLONG_MIN, INT_MIN, INT_MAX
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <util... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 750,858 | 750,859 | u703205079 | cpp |
p02949 |
#include <climits>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
class BellmanFord {
class Edge {
int from, to; // 2端点のインデックス
int weight; // コスト
public:
Edge(int n, int m, int w) {
from = n;
to = m;
weight = w;
}
int GetFrom() { return from; }... | #include <climits>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
class BellmanFord {
class Edge {
int from, to; // 2端点のインデックス
int weight; // コスト
public:
Edge(int n, int m, int w) {
from = n;
to = m;
weight = w;
}
int GetFrom() { return from; }
... | [
"expression.operation.unary.logical.remove",
"control_flow.loop.condition.change"
] | 750,862 | 750,863 | u924514474 | cpp |
p02949 | #pragma GCC optimize("O3")
#include "bits/stdc++.h"
using namespace std;
using ll = long long int;
#define debugos cout
#define debug(v) \
{ \
printf("L%d %s > ", __LINE__, #v... | #pragma GCC optimize("O3")
#include "bits/stdc++.h"
using namespace std;
using ll = long long int;
#define debugos cout
#define debug(v) \
{ \
printf("L%d %s > ", __LINE__, #v... | [
"assignment.change"
] | 750,870 | 750,871 | u079330987 | cpp |
p02949 | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
void *wmem;
template <class T> inline void walloc1d(T **arr, int x, void **mem = &wmem) {
static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
(*mem) = (void *)(((char *)(*mem)) + skip[((unsigned long long)(*mem)) &... | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
void *wmem;
template <class T> inline void walloc1d(T **arr, int x, void **mem = &wmem) {
static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
(*mem) = (void *)(((char *)(*mem)) + skip[((unsigned long long)(*mem)) &... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 750,879 | 750,880 | u066369439 | cpp |
p02949 | /* ---------- STL Libraries ---------- */
// IO library
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm library
#include <algorithm>
#include <cmath>
#include <cstring>
#include <numeric>
#include <random>
// container library
#include <array>
#include <bitset>
... | /* ---------- STL Libraries ---------- */
// IO library
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm library
#include <algorithm>
#include <cmath>
#include <cstring>
#include <numeric>
#include <random>
// container library
#include <array>
#include <bitset>
... | [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 750,881 | 750,882 | u853132965 | cpp |
p02949 | #include <iostream>
#include <tuple>
#include <vector>
using namespace std;
const int INF = 1001001001;
vector<int> v[2505];
vector<int> rv[2505];
vector<tuple<int, int, int>> edge;
bool reachable1[2505];
bool reachable2[2505];
bool ok[2505];
void dfs(int n) {
if (reachable1[n]) {
return;
}
reachable1[n] ... | #include <iostream>
#include <tuple>
#include <vector>
using namespace std;
const int INF = 1001001001;
vector<int> v[2505];
vector<int> rv[2505];
vector<tuple<int, int, int>> edge;
bool reachable1[2505];
bool reachable2[2505];
bool ok[2505];
void dfs(int n) {
if (reachable1[n]) {
return;
}
reachable1[n] ... | [
"identifier.change",
"control_flow.loop.condition.change"
] | 750,885 | 750,886 | u993229809 | cpp |
p02949 | #include <iostream>
#include <tuple>
#include <vector>
using namespace std;
const int INF = 1e9;
vector<int> v[2505];
vector<int> rv[2505];
vector<tuple<int, int, int>> edge;
bool reachable1[2505];
bool reachable2[2505];
bool ok[2505];
void dfs(int n) {
if (reachable1[n]) {
return;
}
reachable1[n] = true;... | #include <iostream>
#include <tuple>
#include <vector>
using namespace std;
const int INF = 1001001001;
vector<int> v[2505];
vector<int> rv[2505];
vector<tuple<int, int, int>> edge;
bool reachable1[2505];
bool reachable2[2505];
bool ok[2505];
void dfs(int n) {
if (reachable1[n]) {
return;
}
reachable1[n] ... | [
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"control_flow.loop.condition.change"
] | 750,887 | 750,886 | u993229809 | cpp |
p02949 | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vec... | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vec... | [
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.variable.change",
"call.arguments.change"
] | 750,888 | 750,889 | u419330815 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <cstring>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ... | #include <algorithm>
#include <assert.h>
#include <cstring>
#include <iterator>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
#define MIN(a, b) ((a) > (b) ... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"control_flow.loop.for.condition.change",
"expression.operation.unary.add",
"control_flow.branch.if.condition.change"
] | 750,890 | 750,891 | u209713918 | cpp |
p02949 | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
... | #include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 750,892 | 750,893 | u561443723 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
int n, m, p;
vector<vector<pair<int, int>>> edge(2501, vector<pair<int, int>>()),
redge(2501, vector<pair<int, int>>());
vector<int> score(2501, -2000000000), used(2501, 0), pass(2501, 0);
void dfs(int crnt, int t) {
used[crnt] = 1;
fo... | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
int n, m, p;
vector<vector<pair<int, int>>> edge(2501, vector<pair<int, int>>()),
redge(2501, vector<pair<int, int>>());
vector<int> score(2501, -2000000000), used(2501, 0), pass(2501, 0);
void dfs(int crnt, int t) {
used[crnt] = 1;
fo... | [
"expression.operation.binary.remove"
] | 750,896 | 750,895 | u905270643 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
struct edge {
int from, to, cost;
};
edge es[5001];
int d[2501], V, E, INF = 1e9;
int shortest_path() {
rep(i, V) d[i + 1] = INF;
d[1] = 0;
while (true) {
int x = 0;
rep(i, E) {
edge e... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
struct edge {
int from, to, cost;
};
edge es[5001];
int d[2501], V, E, INF = 1e9;
int shortest_path() {
rep(i, V) d[i + 1] = INF;
d[1] = 0;
while (true) {
int x = 0;
rep(i, E) {
edge e... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 750,900 | 750,901 | u441296840 | cpp |
p02949 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <vector>
using namespace std;
struct edge {
int to;
int cost;
};
int main() {
int n, m, p;
cin >> n >> m >> p;
vector<vector<edge>> edges(n + 1);
for (int i = 0; i < m; i++) {
int a, b, c;
... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <vector>
using namespace std;
struct edge {
int to;
int cost;
};
int main() {
int n, m, p;
cin >> n >> m >> p;
vector<vector<edge>> edges(n + 1);
for (int i = 0; i < m; i++) {
int a, b, c;
... | [
"control_flow.loop.for.condition.change"
] | 750,904 | 750,905 | u538188080 | cpp |
p02949 | #include <cstdio>
int n, m, i, j, k, k2, t, x, y, z, a[2505], v[2505], st[5005], en[5005],
len[5005], last[2505], nxt[5005], st2[5005], en2[5005], last2[2505],
nxt2[5005], find[10000005];
bool b[2505], f[2505];
void build(int x, int y, int z) {
k++, st[k] = x, en[k] = y, len[k] = z, nxt[k] = last[x], last[x] ... | #include <cstdio>
int n, m, i, j, k, k2, t, x, y, z, a[2505], v[2505], st[5005], en[5005],
len[5005], last[2505], nxt[5005], st2[5005], en2[5005], last2[2505],
nxt2[5005], find[10000005];
bool b[2505], f[2505];
void build(int x, int y, int z) {
k++, st[k] = x, en[k] = y, len[k] = z, nxt[k] = last[x], last[x] ... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 750,908 | 750,907 | u764483026 | cpp |
p02949 | #include <cstdio>
int n, m, i, j, k, k2, t, x, y, z, a[2505], v[2505], st[5005], en[5005],
len[5005], last[2505], nxt[5005], st2[5005], en2[5005], last2[2505],
nxt2[5005], find[10000005];
bool b[2505], f[2505];
void build(int x, int y, int z) {
k++, st[k] = x, en[k] = y, len[k] = z, nxt[k] = last[x], last[x] ... | #include <cstdio>
int n, m, i, j, k, k2, t, x, y, z, a[2505], v[2505], st[5005], en[5005],
len[5005], last[2505], nxt[5005], st2[5005], en2[5005], last2[2505],
nxt2[5005], find[10000005];
bool b[2505], f[2505];
void build(int x, int y, int z) {
k++, st[k] = x, en[k] = y, len[k] = z, nxt[k] = last[x], last[x] ... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 750,908 | 750,909 | u764483026 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, j, n) for (long long i = j; i <= n; i++)
const ll N = 123456;
vector<pair<ll, pair<ll, ll>>> a;
ll dist[N];
ll len[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
ll p;
cin >> p... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, j, n) for (long long i = j; i <= n; i++)
const ll N = 123456;
vector<pair<ll, pair<ll, ll>>> a;
ll dist[N];
ll len[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
cin >> n >> m;
ll p;
cin >> p... | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 750,910 | 750,911 | u095029955 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ' ' << n << endl;
inline bool ChangeMin(int &a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void CheckReachableNode(const vector<unordered_set<int>> &movable_list, int pos,
bitset<2500>... | #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ' ' << n << endl;
inline bool ChangeMin(int &a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void CheckReachableNode(const vector<unordered_set<int>> &movable_list, int pos,
bitset<2500>... | [
"literal.number.change",
"call.arguments.change"
] | 750,912 | 750,913 | u691380397 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ' ' << n << endl;
inline bool ChangeMin(int &a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void CheckReachableNode(const vector<unordered_set<int>> &movable_list, int pos,
bitset<2500>... | #include <bits/stdc++.h>
using namespace std;
#define debug(n) cerr << #n << ' ' << n << endl;
inline bool ChangeMin(int &a, int b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void CheckReachableNode(const vector<unordered_set<int>> &movable_list, int pos,
bitset<2500>... | [] | 750,914 | 750,913 | u691380397 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int MAXN = 5555;
vector<pair<int, int>> adj[MAXN];
vector<int> radj[MAXN];
int n, m, p;
int dis[MAXN];
int vis[MAXN];
int rel[MAXN], rel2[MAXN];
void dfs(int u) {
vis[u] = rel[u] = 1;
for (auto p : adj[u]) {
int... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int MAXN = 5555;
vector<pair<int, int>> adj[MAXN];
vector<int> radj[MAXN];
int n, m, p;
int dis[MAXN];
int vis[MAXN];
int rel[MAXN], rel2[MAXN];
void dfs(int u) {
vis[u] = rel[u] = 1;
for (auto p : adj[u]) {
int... | [
"identifier.change",
"call.function.change"
] | 750,928 | 750,929 | u161130215 | cpp |
p02949 | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
inline ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <class S, class T>
ostream &op... | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
inline ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <class S, class T>
ostream &op... | [
"identifier.change",
"call.arguments.change"
] | 750,930 | 750,931 | u728732647 | cpp |
p02949 | #include <cstdio>
const int N = 5e3 + 5;
struct Edge {
int u, v, c;
};
Edge e[N];
int start[N];
int end[N];
int d[N];
int max(int a, int b) { return a > b ? a : b; }
int main() {
int n, m, p;
scanf("%d%d%d", &n, &m, &p);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].c);
e[i].c ... | #include <cstdio>
const int N = 5e3 + 5;
struct Edge {
int u, v, c;
};
Edge e[N];
int start[N];
int end[N];
int d[N];
int max(int a, int b) { return a > b ? a : b; }
int main() {
int n, m, p;
scanf("%d%d%d", &n, &m, &p);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].c);
e[i].c ... | [
"call.add",
"call.arguments.change"
] | 750,935 | 750,936 | u602509796 | cpp |
p02949 | #include <algorithm>
#include <cstdio>
#include <queue>
#include <vector>
const int MAXN = 1e5 + 5;
int n, m, p, u, v, k;
int dist[MAXN], num[MAXN];
bool flag[MAXN], inQueue[MAXN];
struct graph {
int vertex, val;
graph(int vv = 0, int vval = 0) {
vertex = vv;
val = vval;
}
};
std::vector<graph> con[M... | #include <algorithm>
#include <cstdio>
#include <queue>
#include <vector>
const int MAXN = 1e5 + 5;
int n, m, p, u, v, k;
int dist[MAXN], num[MAXN];
bool flag[MAXN], inQueue[MAXN];
struct graph {
int vertex, val;
graph(int vv = 0, int vval = 0) {
vertex = vv;
val = vval;
}
};
std::vector<graph> con[M... | [
"call.arguments.change"
] | 750,951 | 750,952 | u645561303 | cpp |
p02949 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#inc... | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#inc... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 750,955 | 750,956 | u202928696 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define int ll
#define BUF 1e5
#define INF 1 << 30
#define vi vector<int>
#define vvi vector<vector<int>>
#define all(a) (a).begin(), (a).end()
#define bit(n) (1LL << (n))
... | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define int ll
#define BUF 1e5
#define INF 1 << 30
#define vi vector<int>
#define vvi vector<vector<int>>
#define all(a) (a).begin(), (a).end()
#define bit(n) (1LL << (n))
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 750,960 | 750,961 | u030090262 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define int ll
#define BUF 1e5
#define INF 1 << 30
#define vi vector<int>
#define vvi vector<vector<int>>
#define all(a) (a).begin(), (a).end()
#define bit(n) (1LL << (n))
... | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define int ll
#define BUF 1e5
#define INF 1 << 30
#define vi vector<int>
#define vvi vector<vector<int>>
#define all(a) (a).begin(), (a).end()
#define bit(n) (1LL << (n))
... | [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 750,963 | 750,961 | u030090262 | cpp |
p02949 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
#define all(x) x.begin(), x.en... | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
#define all(x) x.begin(), x.en... | [
"call.remove",
"call.arguments.change"
] | 750,966 | 750,967 | u700986952 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct edge {
int from;
int to;
ll cost;
};
typedef pair<ll, ll> P;
vector<edge> es;
ll dist[2505];
ll inf = pow(1, 50);
std::vector<int> rev_g[2505];
int ok[2505];
ll n, m, p;
void bfs(int v) {
ok[v] = 1;
for (auto u : rev_g[v]) {
i... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct edge {
int from;
int to;
ll cost;
};
typedef pair<ll, ll> P;
vector<edge> es;
ll dist[2505];
ll inf = 1ll << 50;
std::vector<int> rev_g[2505];
int ok[2505];
ll n, m, p;
void bfs(int v) {
ok[v] = 1;
for (auto u : rev_g[v]) {
if... | [
"call.remove",
"call.arguments.change"
] | 750,968 | 750,969 | u440032761 | cpp |
p02949 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define INF 1000000000;
typedef long long ll;
ll n, m, P, d[2500], d1[2500], d2[2500];
struct edge {
ll a;
ll b;
ll c;
};
vector<edge> v;
queue<ll> q;
vector<ll> ch1[2500], ch2[2500];
int main(void) {
cin >> n >> m >> P;
for (int i = 1; i < n... | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define INF 1000000000;
typedef long long ll;
ll n, m, P, d[2500], d1[2500], d2[2500];
struct edge {
ll a;
ll b;
ll c;
};
vector<edge> v;
queue<ll> q;
vector<ll> ch1[2500], ch2[2500];
int main(void) {
cin >> n >> m >> P;
for (int i = 1; i < n... | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 750,975 | 750,976 | u050428930 | cpp |
p02949 | #include <bits/stdc++.h>
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
#define int long long
typedef long long ll;
const int MOD = 1000000007;
const int INF = 1010000000;
const double EPS = 1e-10;
using namespace std;
signed main() {
int n, m, p;
cin >> n >> m >> p;
pair<p... | #include <bits/stdc++.h>
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
#define int long long
typedef long long ll;
const int MOD = 1000000007;
const int INF = 1010000000;
const double EPS = 1e-10;
using namespace std;
signed main() {
int n, m, p;
cin >> n >> m >> p;
pair<p... | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 750,994 | 750,995 | u317754719 | cpp |
p02949 | #include <functional>
#include <iostream>
#include <limits>
#include <queue>
#include <vector>
using namespace std;
//===
template <class T> struct Edge {
int src, to;
T cost;
Edge(int to, T cost) : src(-1), to(to), cost(cost){};
Edge(int src, int to, T cost) : src(src), to(to), cost(cost){};
operator int(... | #include <functional>
#include <iostream>
#include <limits>
#include <queue>
#include <vector>
using namespace std;
//===
template <class T> struct Edge {
int src, to;
T cost;
Edge(int to, T cost) : src(-1), to(to), cost(cost){};
Edge(int src, int to, T cost) : src(src), to(to), cost(cost){};
operator int(... | [
"expression.operation.unary.arithmetic.remove",
"call.arguments.change"
] | 750,999 | 751,000 | u683588090 | cpp |
p02949 | #ifdef _MSC_VER
#pragma warning(disable : 4996)
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#include <limits.h>
#include <math.h>
#include <time.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional... | #ifdef _MSC_VER
#pragma warning(disable : 4996)
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#include <limits.h>
#include <math.h>
#include <time.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,001 | 751,002 | u859396346 | cpp |
p02949 | #ifdef _MSC_VER
#pragma warning(disable : 4996)
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#include <limits.h>
#include <math.h>
#include <time.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional... | #ifdef _MSC_VER
#pragma warning(disable : 4996)
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#include <limits.h>
#include <math.h>
#include <time.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional... | [
"control_flow.branch.if.condition.change"
] | 751,003 | 751,002 | u859396346 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
struct edge {
ll from;
ll to;
ll cost;
};
int main(void) {
ll n, m, p;
ll d[2500];
vector<edge> edges;
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
struct edge add;
cin >> add.from >> add.to >> add... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
struct edge {
ll from;
ll to;
ll cost;
};
int main(void) {
ll n, m, p;
ll d[2500];
vector<edge> edges;
cin >> n >> m >> p;
for (int i = 0; i < m; i++) {
struct edge add;
cin >> add.from >> add.to >> add... | [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,006 | 751,007 | u675509234 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define db double
#define pii pair<int, int>
#define pli pair<ll, int>
#define pil pair<int, ll>
#define pll pair<ll, ll>
#define mat vector<vector<int>>
const int inf = 1 << 30;
const ll linf = 1e18;
const db EPS = 1e-7;
template <class T> void chmin(T... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define db double
#define pii pair<int, int>
#define pli pair<ll, int>
#define pil pair<int, ll>
#define pll pair<ll, ll>
#define mat vector<vector<int>>
const int inf = 1 << 30;
const ll linf = 1e18;
const db EPS = 1e-7;
template <class T> void chmin(T... | [] | 751,010 | 751,011 | u554116180 | cpp |
p02949 |
#include <time.h>
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <deque>
#include <fstream> // ifstream, ofstream
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <omp.h... |
#include <time.h>
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <deque>
#include <fstream> // ifstream, ofstream
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <omp.h... | [
"expression.operation.binary.remove"
] | 751,015 | 751,016 | u279976468 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
... | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
... | [
"expression.operation.binary.remove"
] | 751,021 | 751,022 | u105791541 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
... | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
... | [
"expression.operation.binary.remove"
] | 751,023 | 751,022 | u105791541 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
... | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
... | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 751,021 | 751,024 | u105791541 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
... | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
... | [
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 751,023 | 751,024 | u105791541 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,034 | 751,035 | u711985352 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 751,038 | 751,037 | u711985352 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove",
"io.output.change"
] | 751,039 | 751,037 | u711985352 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"io.output.change"
] | 751,040 | 751,037 | u711985352 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"io.output.change"
] | 751,041 | 751,037 | u711985352 | cpp |
p02949 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#includ... | [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"io.output.change"
] | 751,042 | 751,037 | u711985352 | cpp |
p02949 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector... | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector... | [
"control_flow.branch.if.condition.change"
] | 751,043 | 751,044 | u783675879 | cpp |
p02949 | #include <algorithm>
#include <iostream>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const int VMAX = 2600, EMAX = 5010;
const ll INFLL = 1e+17;
int V, E;
ll p;
int a[5010], b[5010];
ll c[5010];
struct edge {
int from, to;
ll cost;
};
edge e[EMAX];
ll d[VMAX];
bool updat... | #include <algorithm>
#include <iostream>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const int VMAX = 2600, EMAX = 5010;
const ll INFLL = 1e+17;
int V, E;
ll p;
int a[5010], b[5010];
ll c[5010];
struct edge {
int from, to;
ll cost;
};
edge e[EMAX];
ll d[VMAX];
bool updat... | [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,050 | 751,051 | u110996038 | cpp |
p02949 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
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;
}
#define rep(i, n) for (int i = 0; i... | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
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;
}
#define rep(i, n) for (int i = 0; i... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,054 | 751,055 | u136342563 | cpp |
p02949 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define MOD (1000000007)
using namespace std;
... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define MOD (1000000007)
using namespace std;
... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 751,062 | 751,063 | u498141549 | cpp |
p02949 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define MOD (1000000007)
using namespace std;
... | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define MOD (1000000007)
using namespace std;
... | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"identifier.change",
"control_flow.loop.for.condition.change"
] | 751,064 | 751,063 | u498141549 | cpp |
p02949 | /*
/T￣「ヽ
│ ｌ | |
| l l !
l l ! L_
／ヽ ｀丶 , -─┐
/ ｎ ｎ ,r‐ヽ ／ ,r─,'
ャ‐ﾊ ﾋ! ﾋ! / └ｧ′／ /
ム ヽ! ＿'__'_ j く ／ /
ヽﾍ! ￣（-‐ヽrｰﾄ──/
｀Tヽ､ 弋 Y ト--'
ｊ_,_,ﾉ￣｀j_,_,ﾉ｀'‐'′No.258:ミズゴロウ
*/
// AOJだとboostライブラリは... | /*
/T￣「ヽ
│ ｌ | |
| l l !
l l ! L_
／ヽ ｀丶 , -─┐
/ ｎ ｎ ,r‐ヽ ／ ,r─,'
ャ‐ﾊ ﾋ! ﾋ! / └ｧ′／ /
ム ヽ! ＿'__'_ j く ／ /
ヽﾍ! ￣（-‐ヽrｰﾄ──/
｀Tヽ､ 弋 Y ト--'
ｊ_,_,ﾉ￣｀j_,_,ﾉ｀'‐'′No.258:ミズゴロウ
*/
// AOJだとboostライブラリは... | [
"call.add",
"call.arguments.add"
] | 751,065 | 751,066 | u607229598 | cpp |
p02949 | // g++ -std=c++14 test.cpp -o test.out
//問題URL
// https://atcoder.jp/contests/abc137/tasks/abc137_e
//有向グラフの、負の辺を含む最短路問題→ベルマンフォード法
//ベルマンフォード法について
// https://qiita.com/wakimiko/items/69b86627bea0e8fe29d5
// Bellman-Ford法とは、グラフの二点間の最短距離を求めるアルゴリズムです。
// Dijkstra法と比べて辺の重みが負でも動きますが、重みに負の数がないならDijkstra法を使った方が高速です。
//負の閉路が... | // g++ -std=c++14 test.cpp -o test.out
//問題URL
// https://atcoder.jp/contests/abc137/tasks/abc137_e
//有向グラフの、負の辺を含む最短路問題→ベルマンフォード法
//ベルマンフォード法について
// https://qiita.com/wakimiko/items/69b86627bea0e8fe29d5
// Bellman-Ford法とは、グラフの二点間の最短距離を求めるアルゴリズムです。
// Dijkstra法と比べて辺の重みが負でも動きますが、重みに負の数がないならDijkstra法を使った方が高速です。
//負の閉路が... | [
"assignment.change"
] | 751,077 | 751,076 | u302000346 | cpp |
p02949 | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr ll INF = 1e16;
constexpr ll MOD = 1000000007;
// modint: mod 計算を int を扱うように扱える構造体
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
v ... | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr ll INF = 1e16;
constexpr ll MOD = 1000000007;
// modint: mod 計算を int を扱うように扱える構造体
template <int MOD> struct Fp {
long long val;
constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
if (val < 0)
v ... | [
"identifier.change",
"call.arguments.change"
] | 751,078 | 751,079 | u554843701 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
struct edge {
int64_t from;
int64_t to;
int64_t cost;
};
int main() {
int64_t N, M, P;
cin >> N >> M >> P;
vector<edge> G(M);
for (int i = 0; i < M; i++) {
int64_t a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
edge add;
add.from ... | #include <bits/stdc++.h>
using namespace std;
struct edge {
int64_t from;
int64_t to;
int64_t cost;
};
int main() {
int64_t N, M, P;
cin >> N >> M >> P;
vector<edge> G(M);
for (int i = 0; i < M; i++) {
int64_t a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
edge add;
add.from ... | [
"control_flow.branch.if.condition.change"
] | 751,080 | 751,081 | u835534008 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
struct edge {
int64_t from;
int64_t to;
int64_t cost;
};
int main() {
int64_t N, M, P;
cin >> N >> M >> P;
vector<edge> G(M);
for (int i = 0; i < M; i++) {
int64_t a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
edge add;
add.from ... | #include <bits/stdc++.h>
using namespace std;
struct edge {
int64_t from;
int64_t to;
int64_t cost;
};
int main() {
int64_t N, M, P;
cin >> N >> M >> P;
vector<edge> G(M);
for (int i = 0; i < M; i++) {
int64_t a, b, c;
cin >> a >> b >> c;
a--;
b--;
c -= P;
edge add;
add.from ... | [
"control_flow.branch.if.condition.change"
] | 751,082 | 751,083 | u835534008 | cpp |
p02949 | #include <cstring>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return fa... | #include <cstring>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return fa... | [
"literal.number.change",
"variable_declaration.value.change"
] | 751,089 | 751,090 | u537905693 | cpp |
p02949 | #include <algorithm>
#include <iostream>
#include <stack>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<int>> adj(N);
vector<vector<int>> adj_rev(N);
vector<tuple<int, int, int>> edges(M);
for (int i = 0; i < M;... | #include <algorithm>
#include <iostream>
#include <stack>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int N, M, P;
cin >> N >> M >> P;
vector<vector<int>> adj(N);
vector<vector<int>> adj_rev(N);
vector<tuple<int, int, int>> edges(M);
for (int i = 0; i < M;... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 751,095 | 751,096 | u425351967 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Edge {
int to;
ll cost;
};
vector<Edge> G[2510];
ll INF = 1e18;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int V, E;
cin >> V >> E;
ll P;
cin >> P;
vector<ll> d(V, INF);
for (int i = 0; i < E; i++) {
int a,... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Edge {
int to;
ll cost;
};
vector<Edge> G[2510];
ll INF = 1e18;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int V, E;
cin >> V >> E;
ll P;
cin >> P;
vector<ll> d(V, INF);
for (int i = 0; i < E; i++) {
int a,... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operator.compare.change"
] | 751,108 | 751,107 | u339233484 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
template <class T>... | #include <bits/stdc++.h>
using namespace std;
#define repr(i, a, b) for (int i = a; i < b; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define reprrev(i, a, b) for (int i = b - 1; i >= a; i--) // [a, b)
#define reprev(i, n) reprrev(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
template <class T>... | [
"call.add",
"call.arguments.change"
] | 751,111 | 751,112 | u052332717 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
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;
}
typedef long long int ll;
#define ALL(v) (v).begin(), (v)... | #include <bits/stdc++.h>
using namespace std;
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;
}
typedef long long int ll;
#define ALL(v) (v).begin(), (v)... | [
"control_flow.loop.for.condition.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 751,115 | 751,116 | u551351897 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <cl... | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <cl... | [
"control_flow.loop.for.condition.change"
] | 751,122 | 751,123 | u554953477 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <cl... | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <cl... | [
"control_flow.loop.for.condition.change"
] | 751,122 | 751,124 | u554953477 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <cl... | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <cl... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 751,125 | 751,126 | u554953477 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <cl... | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
#define PI 3.141592653589
typedef pair<int, int> PP;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <cl... | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 751,127 | 751,126 | u554953477 | cpp |
p02949 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define MOD 1000000007
#... | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define MOD 1000000007
#... | [
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 751,130 | 751,131 | u537874719 | cpp |
p02949 | #include <bits/stdc++.h>
#include <math.h>
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define MOD (1000000007)
#define vi vector<int>
#define vl vector<ll>
#define vvi vector<... | #include <bits/stdc++.h>
#include <math.h>
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
#define MOD (1000000007)
#define vi vector<int>
#define vl vector<ll>
#define vvi vector<... | [
"control_flow.branch.if.condition.change",
"assignment.change"
] | 751,132 | 751,133 | u354567428 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp,... | #include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
// using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp,... | [] | 751,141 | 751,142 | u878615689 | cpp |
p02949 | #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 = 1001001001;
vector<int> to[2505];
vector<int> ot[2505];
bool reach[2505];
bool reach1[2505];
bool ok[2505];
void dfs(int i) {
if (reach[i])
return;
reach[i] = true;
for (int j... | #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 = 1001001001;
vector<int> to[2505];
vector<int> ot[2505];
bool reach[2505];
bool reach1[2505];
bool ok[2505];
void dfs(int i) {
if (reach[i])
return;
reach[i] = true;
for (int j... | [
"control_flow.loop.condition.change"
] | 751,143 | 751,144 | u147556624 | cpp |
p02949 | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 6031)
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostr... | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 6031)
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostr... | [
"expression.operation.unary.add"
] | 751,151 | 751,152 | u648324897 | cpp |
p02949 | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 6031)
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostr... | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 6031)
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostr... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.unary.add"
] | 751,153 | 751,152 | u648324897 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
#define rep(i, m, n) for (ll i = (m); i <= (n); i++)
#define rrep(i, m, n) for (ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x, m, n) ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
#define rep(i, m, n) for (ll i = (m); i <= (n); i++)
#define rrep(i, m, n) for (ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x, m, n) ... | [
"identifier.change",
"call.arguments.change"
] | 751,156 | 751,157 | u388697579 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
#define rep(i, m, n) for (ll i = (m); i <= (n); i++)
#define rrep(i, m, n) for (ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x, m, n) ... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
#define rep(i, m, n) for (ll i = (m); i <= (n); i++)
#define rrep(i, m, n) for (ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x, m, n) ... | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.change",
"call.arguments.change"
] | 751,158 | 751,157 | u388697579 | cpp |
p02949 | #include <algorithm>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vect... | #include <algorithm>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vect... | [
"identifier.change",
"call.function.change"
] | 751,159 | 751,160 | u917048429 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
using GraphType = vector<vector<pair<int, i64>>>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
for (int i = 0; i < V; +... | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
using GraphType = vector<vector<pair<int, int>>>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
for (int i = 0; i < V; +... | [
"expression.operation.binary.remove"
] | 751,161 | 751,162 | u031178961 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
using GraphType = vector<vector<pair<int, int>>>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
for (int i = 0; i < V; +... | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
using GraphType = vector<vector<pair<int, int>>>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
for (int i = 0; i < V; +... | [
"expression.operation.binary.remove"
] | 751,163 | 751,162 | u031178961 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
struct edge {
int from, to;
i64 wei;
};
using GraphType = vector<edge>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
... | #include <bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
struct edge {
int from, to;
i64 wei;
};
using GraphType = vector<edge>;
template <typename Int>
bool Bellman_Ford(GraphType &Graph, vector<Int> &dist, int V, int start) {
dist[start] = 0;
... | [
"expression.operation.binary.remove"
] | 751,164 | 751,165 | u031178961 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const ll INF = 1LL << 60;
void solve();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
solve();
}
#define fi first
#define ... | #include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
using ld = long double;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const ll INF = 1LL << 60;
void solve();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
solve();
}
#define fi first
#define ... | [
"identifier.change",
"call.arguments.change",
"control_flow.branch.if.condition.change"
] | 751,166 | 751,167 | u440566786 | cpp |
p02949 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int maxM = 1e5 + 7;
const int maxV = 90010;
const int MOD = 1e9 + 7;
int T;
const int maxN = 1e5 + 8;
const ll INF = 1000000000000000010LL;
const int K = 15;... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int maxM = 1e5 + 7;
const int maxV = 90010;
const int MOD = 1e9 + 7;
int T;
const int maxN = 1e5 + 8;
const ll INF = 1000000000000000010LL;
const int K = 15;... | [
"control_flow.branch.else.remove"
] | 751,177 | 751,178 | u807919574 | cpp |
p02949 | #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define chmax(a, b) a = max(a, b)
#define N 3010
#define M 5010
ll a[M], b[M], c[M];
ll d[N... | #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define mod 1000000007
#define mad(a, b) a = (a + b) % mod;
#define chmax(a, b) a = max(a, b)
#define N 3010
#define M 5010
ll a[M], b[M], c[M];
ll d[N... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 751,203 | 751,204 | u924885571 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.