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 |
|---|---|---|---|---|---|---|---|
p03054 | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define REP(i, l, n) for (int i = (l), i##_len = (n); i < i##_len; ++i)
#define ALL(x) (x).begin(), (x).end()
#define pb push_back
ll gcd(ll a, ll b) { return b ? gcd(b, a... | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define REP(i, l, n) for (int i = (l), i##_len = (n); i < i##_len; ++i)
#define ALL(x) (x).begin(), (x).end()
#define pb push_back
ll gcd(ll a, ll b) { return b ? gcd(b, a... | [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,548 | 869,546 | u639426108 | cpp |
p03054 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
int dx[] = {... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
int dx[] = {... | [
"misc.opposites",
"expression.operator.compare.change",
"assignment.variable.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 869,556 | 869,557 | u266874640 | cpp |
p03054 | #include "bits/stdc++.h"
using namespace std;
typedef long long int lint;
typedef pair<lint, lint> plint;
typedef pair<double long, double long> pld;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) ... | #include "bits/stdc++.h"
using namespace std;
typedef long long int lint;
typedef pair<lint, lint> plint;
typedef pair<double long, double long> pld;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) ... | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 869,558 | 869,559 | u554988565 | cpp |
p03054 | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>... | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>... | [
"assignment.value.change",
"identifier.change"
] | 869,562 | 869,563 | u489108157 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
typedef long double ld;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define F first
#define S second
const int mx = 1000... | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
typedef long double ld;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define F first
#define S second
const int mx = 1000... | [
"literal.string.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 869,572 | 869,573 | u980909653 | cpp |
p03054 | #include <queue>
#include <stdio.h>
using namespace std;
typedef long long ll;
int main(void) {
ll i, j, k, h, w, n, r, c, now;
scanf("%lld%lld%lld%lld%lld", &h, &w, &n, &r, &c);
char s[n + 10], t[n + 10], d[5] = "RLUD", dr[5] = "LRDU";
ll f[4] = {w + 1 - c, c, h + 1 - r, r}, fr[4] = {c, w + 1 - c, r, h + 1 - ... | #include <queue>
#include <stdio.h>
using namespace std;
typedef long long ll;
int main(void) {
ll i, j, k, h, w, n, r, c, now;
scanf("%lld%lld%lld%lld%lld", &h, &w, &n, &r, &c);
char s[n + 10], t[n + 10], d[5] = "RLDU", dr[5] = "LRUD";
ll f[4] = {w + 1 - c, c, h + 1 - r, r}, fr[4] = {c, w + 1 - c, r, h + 1 - ... | [
"literal.string.change",
"variable_declaration.value.change"
] | 869,585 | 869,586 | u440920318 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W, N;
cin >> H >> W >> N;
int r, c;
cin >> r >> c;
string s, t;
cin >> s >> t;
bool x = true;
int a = r;
for (int i = 0; i < N; i++) {
if (s.at(i) == 'U')
a--;
if (a <= 0)
x = false;
if (t.at(i) == 'D') {
i... | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W, N;
cin >> H >> W >> N;
int r, c;
cin >> r >> c;
string s, t;
cin >> s >> t;
bool x = true;
int a = r;
for (int i = 0; i < N; i++) {
if (s.at(i) == 'U')
a--;
if (a <= 0)
x = false;
if (t.at(i) == 'D') {
i... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 869,607 | 869,608 | u101018317 | cpp |
p03054 | #include <algorithm>
#include <iostream>
#include <string>
#define flush fflush(stdout)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1e9 + 7, INF = 1e9;
int main(void) {
int h, w, n, si, sj, i, pi1, pi2, pj1, pj2;
string s, t;
scanf("%d%d%d%d%d", &h, &w, &n, &si, &sj);
... | #include <algorithm>
#include <iostream>
#include <string>
#define flush fflush(stdout)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int mod = 1e9 + 7, INF = 1e9;
int main(void) {
int h, w, n, si, sj, i, pi1, pi2, pj1, pj2;
string s, t;
scanf("%d%d%d%d%d", &h, &w, &n, &si, &sj);
... | [
"assignment.change",
"literal.number.change",
"assignment.value.change",
"call.arguments.change"
] | 869,623 | 869,622 | u088895504 | cpp |
p03054 | #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;
using namespace std;
const int MOD = 1000000007;
const int INF = 1010000000;
const double EPS = 1e-10;
const array<pair<int, int>, 4> fd{make_pair(1, 0), make_pair(-... | #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;
using namespace std;
const int MOD = 1000000007;
const int INF = 1010000000;
const double EPS = 1e-10;
const array<pair<int, int>, 4> fd{make_pair(1, 0), make_pair(-... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 869,630 | 869,631 | u317754719 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
// #define int long long
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define ir... | #include <bits/stdc++.h>
using namespace std;
// #define int long long
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define ir... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 869,634 | 869,635 | u530107518 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
// #define int long long
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define ir... | #include <bits/stdc++.h>
using namespace std;
// #define int long long
#define rep(i, n) for (int i = (int)(0); i < (int)(n); ++i)
#define reps(i, n) for (int i = (int)(1); i <= (int)(n); ++i)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rreps(i, n) for (int i = ((int)(n)); i > 0; i--)
#define ir... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 869,636 | 869,635 | u530107518 | cpp |
p03054 | #include <bits/stdc++.h>
/*
#include<algorithm>
#include<array>
#include<cassert>
#include<cmath>
#include<cstdlib>
#include<functional>
#include<iomanip>
#include<iostream>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<typeinfo>
#include<utility>
#include<vecto... | #include <bits/stdc++.h>
/*
#include<algorithm>
#include<array>
#include<cassert>
#include<cmath>
#include<cstdlib>
#include<functional>
#include<iomanip>
#include<iostream>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<typeinfo>
#include<utility>
#include<vecto... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 869,658 | 869,659 | u068654145 | cpp |
p03054 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < x; i++)
#define repn(i, x) for (ll i... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < x; i++)
#define repn(i, x) for (ll i... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 869,660 | 869,661 | u004411048 | cpp |
p03054 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < x; i++)
#define repn(i, x) for (ll i... | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#define _USE_MATH_DEFINES
#include <functional>
#include <math.h>
using namespace std;
#define rep(i, x) for (ll i = 0; i < x; i++)
#define repn(i, x) for (ll i... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change",
"literal.string.change",
"control_flow.branch.if.condition.change"
] | 869,662 | 869,661 | u004411048 | cpp |
p03054 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, x) for (ll i = 0; i < (int)(x); i++)
#define reps(i, x) for (ll i = 1; i <= (int)(x); i++)
#define rrep(i, x) for (ll i = ((int)(x)-1); i >= 0; i... | #include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, x) for (ll i = 0; i < (int)(x); i++)
#define reps(i, x) for (ll i = 1; i <= (int)(x); i++)
#define rrep(i, x) for (ll i = ((int)(x)-1); i >= 0; i... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 869,378 | 869,379 | u150255544 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define pb push_back
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmi... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, l, r) for (int i = (int)(l); i < (int)(r); i++)
#define all(x) (x).begin(), (x).end()
#define pb push_back
template <class T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmi... | [
"assignment.variable.change",
"identifier.change"
] | 869,388 | 869,389 | u057866967 | cpp |
p03054 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using n... | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using n... | [
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 869,398 | 869,399 | u938945369 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> ii;
#define x first
#define y second
ii con(char a) {
if (a == 'D')
return {1, 0};
if (a == 'U')
return {-1, 0};
if (a == 'R')
return {0, 1};
if (a == 'L')
return {0, -1};
}
int h, w, n;
ii sp;
string s, t;
void sub(int &a) ... | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> ii;
#define x first
#define y second
ii con(char a) {
if (a == 'D')
return {1, 0};
if (a == 'U')
return {-1, 0};
if (a == 'R')
return {0, 1};
if (a == 'L')
return {0, -1};
}
int h, w, n;
ii sp;
string s, t;
void sub(int &a) ... | [
"identifier.change",
"control_flow.branch.if.condition.change",
"misc.opposites"
] | 869,419 | 869,420 | u924215188 | cpp |
p03054 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
// #define int... | #include <algorithm>
#include <cmath>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
// #define int... | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"io.output.change"
] | 869,422 | 869,423 | u799021348 | cpp |
p03054 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main(int argc, char **argv) {
int H, W, N, sr, sc;
cin >> H >> W >> N >> sr >> sc;
string S, T;
cin >> S >> T;
int cur = sc - 1;
for (int i = 0; i < N; i++) {
if (S[i] == 'R')
cur++;
if (cur == W) {
co... | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main(int argc, char **argv) {
int H, W, N, sr, sc;
cin >> H >> W >> N >> sr >> sc;
string S, T;
cin >> S >> T;
int cur = sc - 1;
for (int i = 0; i < N; i++) {
if (S[i] == 'R')
cur++;
if (cur == W) {
co... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 869,444 | 869,445 | u878657050 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
//#define MOD 1000000007
#define MOD 998244353
#define INF 100000000000000009
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define ZREP(i, n) for (... | #include <bits/stdc++.h>
using namespace std;
//#define MOD 1000000007
#define MOD 998244353
#define INF 100000000000000009
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define ZREP(i, n) for (... | [
"identifier.replace.remove",
"literal.replace.add",
"control_flow.branch.if.condition.change"
] | 869,453 | 869,454 | u554953477 | cpp |
p03054 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define VAR(v, i) __typeof(i) v = (i)
#define FORE(i, c) for (VAR(i, (c).begin()); i != (c).end(); ++i)
#define all(v) (v).begin(), (v).end()
#define PII pair<int, int>
#define mp make_... | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define VAR(v, i) __typeof(i) v = (i)
#define FORE(i, c) for (VAR(i, (c).begin()); i != (c).end(); ++i)
#define all(v) (v).begin(), (v).end()
#define PII pair<int, int>
#define mp make_... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 869,459 | 869,460 | u684583379 | cpp |
p03054 | #include <cstdio>
#include <cstring>
#define ran 202202
int n, m, L;
int x, y;
char a[ran], b[ran];
int fa[ran], fb[ran];
bool calc(int st, int lim) {
int l = 1, r = lim;
for (int i = L - 1; i >= 0; i--) {
if (fb[i] == 1 && l > 1)
l--;
if (fb[i] == -1 && r < lim)
r++;
if (fa[i] == -1)
... | #include <cstdio>
#include <cstring>
#define ran 202202
int n, m, L;
int x, y;
char a[ran], b[ran];
int fa[ran], fb[ran];
bool calc(int st, int lim) {
int l = 1, r = lim;
for (int i = L - 1; i >= 0; i--) {
if (fb[i] == 1 && l > 1)
l--;
if (fb[i] == -1 && r < lim)
r++;
if (fa[i] == -1)
... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.branch.if.condition.change"
] | 869,488 | 869,489 | u534772498 | cpp |
p03054 | #include <bits/stdc++.h>
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; i++)
#define rep(i, n) FOR(i, 0, n)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
constexpr ll Mod = 998244353;
constexpr ll mod = 1e9 + 7;
constexpr ll inf = 1LL << 60;
template <typename T> constexpr bool ... | #include <bits/stdc++.h>
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; i++)
#define rep(i, n) FOR(i, 0, n)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
constexpr ll Mod = 998244353;
constexpr ll mod = 1e9 + 7;
constexpr ll inf = 1LL << 60;
template <typename T> constexpr bool ... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 869,675 | 869,676 | u047554023 | cpp |
p03054 | #include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define ll long long
using namespace std;
long long MOD = 1000000007;
template <typename T> void cout_vec(vector<T> &v... | #include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define ll long long
using namespace std;
long long MOD = 1000000007;
template <typename T> void cout_vec(vector<T> &v... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change",
"control_flow.branch.if.condition.change"
] | 869,692 | 869,691 | u658993896 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int h, w, n;
cin >> h >> w >> n;
int sr, sc;
cin >> sr >> sc;
--sr;
--sc;
string s, t;
cin >> s >> t;
int l = 0, r = w - 1, u = 0, d = h - 1;
if (s[n - 1] == 'L') {
l = 1;
} else if (s[n - 1] == 'R') {
r = w... | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int h, w, n;
cin >> h >> w >> n;
int sr, sc;
cin >> sr >> sc;
--sr;
--sc;
string s, t;
cin >> s >> t;
int l = 0, r = w - 1, u = 0, d = h - 1;
if (s[n - 1] == 'L') {
l = 1;
} else if (s[n - 1] == 'R') {
r = w... | [
"assignment.variable.change",
"identifier.change"
] | 869,693 | 869,694 | u313766957 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int h, w, n;
cin >> h >> w >> n;
int sr, sc;
cin >> sr >> sc;
--sr;
--sc;
string s, t;
cin >> s >> t;
int l = 0, r = w - 1, u = 0, d = h - 1;
if (s[n - 1] == 'L') {
l = 1;
} else if (s[n - 1] == 'R') {
r = w... | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int h, w, n;
cin >> h >> w >> n;
int sr, sc;
cin >> sr >> sc;
--sr;
--sc;
string s, t;
cin >> s >> t;
int l = 0, r = w - 1, u = 0, d = h - 1;
if (s[n - 1] == 'L') {
l = 1;
} else if (s[n - 1] == 'R') {
r = w... | [
"assignment.variable.change",
"identifier.change",
"misc.opposites",
"control_flow.branch.if.condition.change"
] | 869,695 | 869,694 | u313766957 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int h, w, n, x, y;
char a[maxn], b[maxn];
void no() {
puts("NO");
exit(0);
}
int main() {
scanf("%d%d%d", &h, &w, &n);
scanf("%d%d", &x, &y);
scanf("%s%s", a + 1, b + 1);
int s = 1, t = w;
for (int i = n; i; --i) {
if (b[i] == 'L... | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int h, w, n, x, y;
char a[maxn], b[maxn];
void no() {
puts("NO");
exit(0);
}
int main() {
scanf("%d%d%d", &h, &w, &n);
scanf("%d%d", &x, &y);
scanf("%s%s", a + 1, b + 1);
int s = 1, t = w;
for (int i = n; i; --i) {
if (b[i] == 'L... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 869,696 | 869,697 | u915913072 | cpp |
p03054 | #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
#... | [
"literal.string.change",
"literal.string.case.change",
"variable_declaration.value.change",
"assignment.value.change"
] | 869,713 | 869,714 | u537874719 | cpp |
p03054 | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long int lli;
int gcd(int a, int b) { return b != 0 ? gcd(b, a % b) : a; }
int lcm(int a, ... | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long int lli;
int gcd(int a, int b) { return b != 0 ? gcd(b, a % b) : a; }
int lcm(int a, ... | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"control_flow.return.add"
] | 869,717 | 869,716 | u103357948 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
typedef pair<int, int> P;
int main() {
int h, w, n, sr, sc;
string s, t;
cin >> h >> w >> n >> sr >> sc >> s >> t;
int x = 1;
int xr = sr, xc = sc;
rep(i, n) {
if (s[i] == 'U')
xr--;
... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
typedef pair<int, int> P;
int main() {
int h, w, n, sr, sc;
string s, t;
cin >> h >> w >> n >> sr >> sc >> s >> t;
int x = 1;
int xr = sr, xc = sc;
rep(i, n) {
if (s[i] == 'U')
xr--;
... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 869,722 | 869,723 | u441296840 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define in(x, y, h, w) x >= 0 && x < h &&y >= 0 && y < w
//#define int long l... | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define in(x, y, h, w) x >= 0 && x < h &&y >= 0 && y < w
//#define int long l... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 869,734 | 869,735 | u456611841 | cpp |
p03054 | //
// main.cpp
//
#include <algorithm>
#include <array>
#include <assert.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#in... | //
// main.cpp
//
#include <algorithm>
#include <array>
#include <assert.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#in... | [
"variable_declaration.value.change"
] | 869,736 | 869,737 | u578938637 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W, N;
cin >> H >> W >> N;
int sr, sc;
cin >> sr >> sc;
string S, T;
cin >> S >> T;
int L = 0;
int R = W;
int U = 0;
int D = H;
for (int i = N - 1; i >= 0; i--) {
char C = T.at(i);
if (i < N - 1) {
if ('U' == C) {
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W, N;
cin >> H >> W >> N;
int sr, sc;
cin >> sr >> sc;
string S, T;
cin >> S >> T;
int L = 0;
int R = W;
int U = 0;
int D = H;
for (int i = N - 1; i >= 0; i--) {
char C = T.at(i);
if (i < N - 1) {
if ('U' == C) {
... | [] | 869,763 | 869,764 | u216849520 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j) for (int i = 0; i < j; i++)
#define all(obj) (obj).begin(), (obj).end()
#define rall(obj) (obj).rbegin(), (obj).rend()
typedef long long int ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef ve... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j) for (int i = 0; i < j; i++)
#define all(obj) (obj).begin(), (obj).end()
#define rall(obj) (obj).rbegin(), (obj).rend()
typedef long long int ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef ve... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,765 | 869,766 | u463697306 | cpp |
p03054 | #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;
int main() {
int H;
int W;
int N... | #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;
int main() {
int H;
int W;
int N... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,772 | 869,773 | u623349537 | cpp |
p03054 | #include <bits/stdc++.h>
#define pb push_back
#define int long long
#define mp make_pair
#define inf 1000000007
#define LINF 1000000000000000007LL
#define ll long long
using namespace std;
signed main() {
int h, w, n;
cin >> h >> w >> n;
string s, t;
int sr, sc;
cin >> sr >> sc;
cin >> s >> t;
int fl = fa... | #include <bits/stdc++.h>
#define pb push_back
#define int long long
#define mp make_pair
#define inf 1000000007
#define LINF 1000000000000000007LL
#define ll long long
using namespace std;
signed main() {
int h, w, n;
cin >> h >> w >> n;
string s, t;
int sr, sc;
cin >> sr >> sc;
cin >> s >> t;
int fl = fa... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 869,780 | 869,781 | u335590796 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W, N, sr, sc;
cin >> H >> W >> N;
cin >> sr >> sc;
string S, T;
cin >> S;
cin >> T;
bool awin = false;
int bwinl = 1;
int bwinr = W;
int bwinu = 1;
int bwind = H;
for (int i = N - 1; i >= 0; i--) {
if (T[i] == 'R')
bwin... | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W, N, sr, sc;
cin >> H >> W >> N;
cin >> sr >> sc;
string S, T;
cin >> S;
cin >> T;
bool awin = false;
int bwinl = 1;
int bwinr = W;
int bwinu = 1;
int bwind = H;
for (int i = N - 1; i >= 0; i--) {
if (T[i] == 'R')
bwin... | [
"assignment.variable.change",
"identifier.change"
] | 869,782 | 869,783 | u548834738 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W, N, sr, sc;
cin >> H >> W >> N;
cin >> sr >> sc;
string S, T;
cin >> S;
cin >> T;
bool awin = false;
int bwinl = 1;
int bwinr = W;
int bwinu = 1;
int bwind = H;
for (int i = N - 1; i >= 0; i--) {
if (T[i] == 'R')
bwin... | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W, N, sr, sc;
cin >> H >> W >> N;
cin >> sr >> sc;
string S, T;
cin >> S;
cin >> T;
bool awin = false;
int bwinl = 1;
int bwinr = W;
int bwinu = 1;
int bwind = H;
for (int i = N - 1; i >= 0; i--) {
if (T[i] == 'R')
bwin... | [
"assignment.variable.change",
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,784 | 869,783 | u548834738 | cpp |
p03054 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string.h>
#include <unordered_map>
#include <vector>
using namespace std;
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define rep(i, n) for (int ... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <string.h>
#include <unordered_map>
#include <vector>
using namespace std;
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define rep(i, n) for (int ... | [
"assignment.change",
"assignment.value.change",
"call.arguments.change"
] | 869,785 | 869,786 | u328294851 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
struct Benri {
Benri() {
std::cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
}
} benri;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
using vll = vector<long long>;
using pll ... | #include <bits/stdc++.h>
using namespace std;
struct Benri {
Benri() {
std::cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
}
} benri;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
using vll = vector<long long>;
using pll ... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 869,787 | 869,788 | u073486874 | cpp |
p03054 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include ... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include ... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.unary.arithmetic.add",
"expression.operation.unary.arithmetic.remove"
] | 869,807 | 869,806 | u703999673 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef double db;
#define go(u) for (int i = head[u], v = e[i].to; i; i = e[i].lst, v = e[i].to)
#define rep(i, a, b) for (int i = a; i <= b; ++i)
#define pb push_back
#define re(x) memset(x, 0, sizeof x)
inline int gi() {
int x = 0, f = 1;
char c... | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef double db;
#define go(u) for (int i = head[u], v = e[i].to; i; i = e[i].lst, v = e[i].to)
#define rep(i, a, b) for (int i = a; i <= b; ++i)
#define pb push_back
#define re(x) memset(x, 0, sizeof x)
inline int gi() {
int x = 0, f = 1;
char c... | [
"identifier.change",
"call.arguments.change"
] | 869,822 | 869,823 | u543414214 | cpp |
p03054 | #include <bits/stdc++.h>
#define pb push_back
#define FOR(x, to) for (int x = 0; x < (to); x++)
#define F0R(x, in, to) for (int x = (in); x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define ALL(a) (a.begin()), (a.end())
#define ZE... | #include <bits/stdc++.h>
#define pb push_back
#define FOR(x, to) for (int x = 0; x < (to); x++)
#define F0R(x, in, to) for (int x = (in); x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define ALL(a) (a.begin()), (a.end())
#define ZE... | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change"
] | 869,840 | 869,841 | u204082108 | cpp |
p03054 | #include <bits/stdc++.h>
#define pb push_back
#define FOR(x, to) for (int x = 0; x < (to); x++)
#define F0R(x, in, to) for (int x = (in); x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define ALL(a) (a.begin()), (a.end())
#define ZE... | #include <bits/stdc++.h>
#define pb push_back
#define FOR(x, to) for (int x = 0; x < (to); x++)
#define F0R(x, in, to) for (int x = (in); x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define ALL(a) (a.begin()), (a.end())
#define ZE... | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change",
"identifier.change"
] | 869,842 | 869,841 | u204082108 | cpp |
p03054 | #include <iomanip>
#include <iostream>
//#include<cstdio>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
int H, W, N;
int Sr, Sc;
string S, T;
int main() {
cin >> H >> W >> N;
cin >> Sr >> Sc;
cin >> S >> T;
... | #include <iomanip>
#include <iostream>
//#include<cstdio>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <map>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
int H, W, N;
int Sr, Sc;
string S, T;
int main() {
cin >> H >> W >> N;
cin >> Sr >> Sc;
cin >> S >> T;
... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,845 | 869,846 | u534998883 | cpp |
p03054 | #include <cstdio>
#include <string>
using namespace std;
int main() {
int H, W, N, sr, sc;
int i;
scanf("%d %d %d", &H, &W, &N);
char *s = new char[N];
char *t = new char[N];
scanf(" %d %d", &sr, &sc);
scanf(" %s", s);
scanf(" %s", t);
//高橋君が最も移動させられる距離が分かればよい
int L = 0, R = 0, U = 0, D = 0;
for ... | #include <cstdio>
#include <string>
using namespace std;
int main() {
int H, W, N, sr, sc;
int i;
scanf("%d %d %d", &H, &W, &N);
char *s = new char[N];
char *t = new char[N];
scanf(" %d %d", &sr, &sc);
scanf(" %s", s);
scanf(" %s", t);
//高橋君が最も移動させられる距離が分かればよい
int L = 0, R = 0, U = 0, D = 0;
for ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,875 | 869,876 | u203033720 | cpp |
p03054 | #include <algorithm>
#include <chrono>
#include <iostream>
#include <map>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
bool judge(vector<int> w_dir, vector<int> w_who, int w, int start) {
int L = 1, R = w;
for (int i = w_dir.size() - 1; i >= 0; ... | #include <algorithm>
#include <chrono>
#include <iostream>
#include <map>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
bool judge(vector<int> w_dir, vector<int> w_who, int w, int start) {
int L = 1, R = w;
for (int i = w_dir.size() - 1; i >= 0; ... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 869,879 | 869,880 | u766009355 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define rep(i, x, y) \
for (i64 i = i64(x), i##_max_for_repmacro = i64(y); \
i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#de... | #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
#define rep(i, x, y) \
for (i64 i = i64(x), i##_max_for_repmacro = i64(y); \
i < i##_max_for_repmacro; ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#de... | [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 869,884 | 869,885 | u759266806 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W, N, sr, sc;
string S, T;
cin >> H >> W >> N >> sr >> sc >> S >> T;
bool flag = true;
int r, c;
r = sr;
for (int i = 0; i < N; i++) {
if (S[i] == 'U')
r--;
if (r == 0)
flag = false;
if (T[i] == 'D' && r < H)
... | #include <bits/stdc++.h>
using namespace std;
int main() {
int H, W, N, sr, sc;
string S, T;
cin >> H >> W >> N >> sr >> sc >> S >> T;
bool flag = true;
int r, c;
r = sr;
for (int i = 0; i < N; i++) {
if (S[i] == 'U')
r--;
if (r == 0)
flag = false;
if (T[i] == 'D' && r < H)
... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 869,909 | 869,910 | u573082373 | cpp |
p03054 | /*
`-:://:::-
`//:-------:/:`
.+:--.......--:+`
`+:--..`````..--//`
.o:--..`` ``..--:o`
... | /*
`-:://:::-
`//:-------:/:`
.+:--.......--:+`
`+:--..`````..--//`
.o:--..`` ``..--:o`
... | [
"control_flow.branch.if.condition.change"
] | 869,911 | 869,912 | u656721037 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i ... | #include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,921 | 869,922 | u434231045 | cpp |
p03054 | #pragma optimize "-O3"
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef long long ll;
int h, w, n;
int x, y;
string s, t;
int balR, balL, balU, balD;
void bad() {
cout << "NO";
exit(0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
// freopen("input.txt", "r"... | #pragma optimize "-O3"
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef long long ll;
int h, w, n;
int x, y;
string s, t;
int balR, balL, balU, balD;
void bad() {
cout << "NO";
exit(0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
// freopen("input.txt", "r"... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 869,923 | 869,924 | u720150053 | cpp |
p03054 | /*input
2 3 3
2 2
RRL
LUD
*/
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
#define IOS ... | /*input
1 5 5
1 3
RRRRR
LLLUU
*/
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
#define IOS ... | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 869,929 | 869,930 | u010467501 | cpp |
p03054 | #include <iostream>
using namespace std;
int H, W, N, sx, sy;
int direction[4] = {};
string S, T;
int main() {
cin >> H >> W >> N;
cin >> sx >> sy;
cin >> S >> T;
for (int i = 1; i <= N; i++) {
if (S[i - 1] == 'U')
direction[0]++;
if (S[i - 1] == 'L')
direction[1]++;
if (S[i - 1] == 'D'... | #include <iostream>
using namespace std;
int H, W, N, sx, sy;
int direction[4] = {};
string S, T;
int main() {
cin >> H >> W >> N;
cin >> sx >> sy;
cin >> S >> T;
for (int i = 1; i <= N; i++) {
if (S[i - 1] == 'U')
direction[0]++;
if (S[i - 1] == 'L')
direction[1]++;
if (S[i - 1] == 'D'... | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 869,931 | 869,932 | u623954643 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define repp(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define repm(i, a, b) for (int i = (int)(a); i > (int)(b); --i)
int main() {
int H, W, N;
cin >> H >> W >> N;
int sr, sc;
cin >> sr >> sc;
string S;
cin >> S;
string T;
... | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define repp(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define repm(i, a, b) for (int i = (int)(a); i > (int)(b); --i)
int main() {
int H, W, N;
cin >> H >> W >> N;
int sr, sc;
cin >> sr >> sc;
string S;
cin >> S;
string T;
... | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 869,933 | 869,934 | u007446928 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
const int MX = 200000;
bool solve(int w, int n, int x, int *ds, int *dt) {
int L = 1, R = w;
for (int i = n - 1; i >= 0; i--) {
if (dt[i] == 1)
L = max(L - 1, 1);
if (dt[i] == -1)
R = min(R + 1, n);
if (ds[i] == 1)
R--;
if (ds[i] ==... | #include <bits/stdc++.h>
using namespace std;
const int MX = 200000;
bool solve(int w, int n, int x, int *ds, int *dt) {
int L = 1, R = w;
for (int i = n - 1; i >= 0; i--) {
if (dt[i] == 1)
L = max(L - 1, 1);
if (dt[i] == -1)
R = min(R + 1, w);
if (ds[i] == 1)
R--;
if (ds[i] ==... | [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 869,940 | 869,941 | u037304230 | cpp |
p03054 | #include <bits/stdc++.h>
using namespace std;
using int64 = long long;
const int mod = 1e9 + 7;
const int64 infll = (1LL << 62) - 1;
const int inf = (1 << 30) - 1;
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprec... | #include <bits/stdc++.h>
using namespace std;
using int64 = long long;
const int mod = 1e9 + 7;
const int64 infll = (1LL << 62) - 1;
const int inf = (1 << 30) - 1;
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprec... | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 869,944 | 869,945 | u524343822 | cpp |
p03054 | #include <bits/stdc++.h>
#define r(i, n) for (int i = 0; i < n; i++)
using namespace std;
#define int long long
typedef pair<int, int> P;
int Y, X, h, w, n;
string s, t;
bool U() {
int y = Y;
r(i, n) {
if (s[i] == 'U')
y--;
if (y == 0)
return 1;
if (t[i] == 'D')
y++;
y = min(y, h... | #include <bits/stdc++.h>
#define r(i, n) for (int i = 0; i < n; i++)
using namespace std;
#define int long long
typedef pair<int, int> P;
int Y, X, h, w, n;
string s, t;
bool U() {
int y = Y;
r(i, n) {
if (s[i] == 'U')
y--;
if (y == 0)
return 1;
if (t[i] == 'D')
y++;
y = min(y, h... | [
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 869,946 | 869,947 | u777468981 | cpp |
p03055 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, n) for... | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, n) for... | [
"variable_declaration.value.change",
"identifier.change",
"literal.number.change"
] | 869,965 | 869,966 | u190761897 | cpp |
p03055 | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <assert.h>
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <climits>
#include <complex> // complex
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include... | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <assert.h>
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <climits>
#include <complex> // complex
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include... | [
"literal.number.change",
"variable_declaration.value.change"
] | 869,971 | 869,972 | u550014122 | cpp |
p03055 | #include <bits/stdc++.h>
#include <random>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef double ld;
#define int ll
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<vvc> vvvc;
typedef pair<int, int> pii;
typedef pair<pii, pii> piii;
typedef pair<ll, ll> pll;
typedef ... | #include <bits/stdc++.h>
#include <random>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef double ld;
#define int ll
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<vvc> vvvc;
typedef pair<int, int> pii;
typedef pair<pii, pii> piii;
typedef pair<ll, ll> pll;
typedef ... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 869,975 | 869,976 | u844213925 | cpp |
p03055 | #include <bits/stdc++.h>
#include <random>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef double ld;
#define int ll
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<vvc> vvvc;
typedef pair<int, int> pii;
typedef pair<pii, pii> piii;
typedef pair<ll, ll> pll;
typedef ... | #include <bits/stdc++.h>
#include <random>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef double ld;
#define int ll
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<vvc> vvvc;
typedef pair<int, int> pii;
typedef pair<pii, pii> piii;
typedef pair<ll, ll> pll;
typedef ... | [
"literal.number.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 869,977 | 869,976 | u844213925 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1,... | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1,... | [] | 869,988 | 869,989 | u914173586 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
class TreeDiameter {
public:
int V;
vector<vector<int>> G;
vector<int> diameter;
TreeDiameter(int node_size) : V(node_size), G(V) {}
void add(int u, int v) { G.at(u).push_back(v), G.at(v).push_back(u); }
void dfs(int u, int p, int d, int &far, int &mx) {
if... | #include <bits/stdc++.h>
using namespace std;
class TreeDiameter {
public:
int V;
vector<vector<int>> G;
vector<int> diameter;
TreeDiameter(int node_size) : V(node_size), G(V) {}
void add(int u, int v) { G.at(u).push_back(v), G.at(v).push_back(u); }
void dfs(int u, int p, int d, int &far, int &mx) {
if... | [
"call.function.change",
"call.arguments.change"
] | 869,995 | 869,996 | u045289115 | cpp |
p03055 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<string> VS;
typedef... | #include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<string> VS;
typedef... | [
"control_flow.branch.if.condition.change",
"expression.operator.arithmetic.change"
] | 870,013 | 870,014 | u154756110 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<i... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<i... | [
"literal.number.change",
"assignment.value.change",
"control_flow.branch.if.condition.change"
] | 870,017 | 870,018 | u347057617 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<i... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<i... | [
"literal.number.change",
"assignment.value.change"
] | 870,019 | 870,018 | u347057617 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
// const ull mod = 1e9 + 7;
const ll mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
// debug
#define dump(x) ce... | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
// const ull mod = 1e9 + 7;
const ll mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
// debug
#define dump(x) ce... | [] | 870,036 | 870,037 | u895971408 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
ll mod = 1e9 + 7;
int main() {
ll n;
cin >> n;
vector<set<ll>> E(n);
for (ll i = 0; i < n - 1; i++) {
ll a, b;
cin >> a >> b;
a--;
b--;
E[a].insert(b);
E[b].insert(a);
}
vector<ll> d1(n, -1... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
ll mod = 1e9 + 7;
int main() {
ll n;
cin >> n;
vector<set<ll>> E(n);
for (ll i = 0; i < n - 1; i++) {
ll a, b;
cin >> a >> b;
a--;
b--;
E[a].insert(b);
E[b].insert(a);
}
vector<ll> d1(n, -1... | [
"variable_declaration.value.change",
"expression.operation.unary.logical.remove",
"control_flow.branch.if.condition.change",
"literal.number.change"
] | 870,042 | 870,041 | u718758485 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
struct Edge {
int to, w;
Edge(int t, int w) : to(t), w(w) {}
};
struct Tree {
int N;
vector<vector<Edge>> edges;
void addEdge(int a, int b) { addEdge(a, b, 1); }
void addEdge(int a, int b, int w) { edges[a]... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
struct Edge {
int to, w;
Edge(int t, int w) : to(t), w(w) {}
};
struct Tree {
int N;
vector<vector<Edge>> edges;
void addEdge(int a, int b) { addEdge(a, b, 1); }
void addEdge(int a, int b, int w) { edges[a]... | [
"literal.number.change",
"variable_declaration.value.change"
] | 870,049 | 870,050 | u544437817 | cpp |
p03055 | #pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define INF 1LL << 30
#define MAX 1000... | #pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define INF 1LL << 30
#define MAX 1000... | [
"assignment.variable.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 870,057 | 870,058 | u591914971 | cpp |
p03055 | #pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define INF 1LL << 30
#define MAX 1000... | #pragma GCC optimize("Ofast")
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define INF 1LL << 30
#define MAX 1000... | [
"assignment.variable.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"expression.unary.arithmetic.add"
] | 870,059 | 870,058 | u591914971 | cpp |
p03055 | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
#pragma GCC optimize("O3")
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define EPS (1e-9)
#define INF (1e17)
#define PI (acos(-1))
// const double PI = aco... | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
#pragma GCC optimize("O3")
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, n) for (int i = 1; i <= n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define EPS (1e-9)
#define INF (1e17)
#define PI (acos(-1))
// const double PI = aco... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 870,060 | 870,061 | u222293734 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL_DEBUG
#include "LOCAL_DEBUG.hpp"
#endif
#define int long long
struct edge {
int to, cost;
};
pair<int, int> dfs(const vector<vector<edge>> &g, int idx, int par) {
pair<int, int> ret(0, idx);
for (auto &e : g[idx]) {
if (e.to == par)
continue;
... | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL_DEBUG
#include "LOCAL_DEBUG.hpp"
#endif
#define int long long
struct edge {
int to, cost;
};
pair<int, int> dfs(const vector<vector<edge>> &g, int idx, int par) {
pair<int, int> ret(0, idx);
for (auto &e : g[idx]) {
if (e.to == par)
continue;
... | [] | 870,064 | 870,065 | u344122377 | cpp |
p03055 | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
#define l first
#define r second
#define int long long
int n;
vector<int> graph[500000];
int d[500000];
int dp[500000];
signed main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int v, u;
cin ... | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
#define l first
#define r second
#define int long long
int n;
vector<int> graph[500000];
int d[500000];
int dp[500000];
signed main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int v, u;
cin ... | [
"assignment.variable.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 870,068 | 870,069 | u798339690 | cpp |
p03055 | /*Unknown_Ghost*/
/*AGC033C Removing Coins*/
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
#define LL long long
#define MAXN 200000
#define MOD 998244353
#define Pr pair<int, int>
#define X first
#define Y second
#define mem(x, p) memset(x, p, sizeof(... | /*Unknown_Ghost*/
/*AGC033C Removing Coins*/
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
#define LL long long
#define MAXN 200000
#define MOD 998244353
#define Pr pair<int, int>
#define X first
#define Y second
#define mem(x, p) memset(x, p, sizeof(... | [
"expression.operation.binary.add"
] | 870,078 | 870,079 | u778193086 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return... | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return... | [
"literal.string.change",
"io.output.change"
] | 870,080 | 870,081 | u615258936 | cpp |
p03055 | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <unordered_map>
#include <vector>
#define mod 1000000007
using namespace std;
typedef long long ll;
bool chmax(ll &a, ll b) {
if (a > b)
return 0;
a = b;
return 1;
}
bool chmin(ll &a, ll b) {
if (a < b)
return 0;
a = b;
... | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <unordered_map>
#include <vector>
#define mod 1000000007
using namespace std;
typedef long long ll;
bool chmax(ll &a, ll b) {
if (a > b)
return 0;
a = b;
return 1;
}
bool chmin(ll &a, ll b) {
if (a < b)
return 0;
a = b;
... | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 870,088 | 870,087 | u924885571 | cpp |
p03055 | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <unordered_map>
#include <vector>
#define mod 1000000007
using namespace std;
typedef long long ll;
bool chmax(ll &a, ll b) {
if (a > b)
return 0;
a = b;
return 1;
}
bool chmin(ll &a, ll b) {
if (a < b)
return 0;
a = b;
... | #include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <unordered_map>
#include <vector>
#define mod 1000000007
using namespace std;
typedef long long ll;
bool chmax(ll &a, ll b) {
if (a > b)
return 0;
a = b;
return 1;
}
bool chmin(ll &a, ll b) {
if (a < b)
return 0;
a = b;
... | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"literal.string.change",
"literal.string.case.change",
"io.output.change"
] | 870,089 | 870,087 | u924885571 | cpp |
p03055 | #include <algorithm> // minmax, sort, swap
#include <climits> // INT_MIN, LLONG_MIN
#include <cmath> // long, trig, pow
#include <cstdio> // printf, scanf
#include <deque> // deque
#include <functional> // std::function<void(int)>
#include <iomanip> // cout<<setprecision(n)
#in... | #include <algorithm> // minmax, sort, swap
#include <climits> // INT_MIN, LLONG_MIN
#include <cmath> // long, trig, pow
#include <cstdio> // printf, scanf
#include <deque> // deque
#include <functional> // std::function<void(int)>
#include <iomanip> // cout<<setprecision(n)
#in... | [
"variable_declaration.value.change"
] | 870,090 | 870,091 | u128456980 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
vector<vector<int>> g;
P bfs(int s) {
vector<int> dist(g.size(), -1);
queue<int> que;
que.push(s);
dist[s] = 0;
while (!que.empty()) {
int v = que.front();
que.pop();
for (auto u : g[v]) {
if (dist... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
vector<vector<int>> g;
P bfs(int s) {
vector<int> dist(g.size(), -1);
queue<int> que;
que.push(s);
dist[s] = 0;
while (!que.empty()) {
int v = que.front();
que.pop();
for (auto u : g[v]) {
if (dist... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.off_by_one",
"io.output.change"
] | 870,092 | 870,093 | u271063202 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
vector<vector<int>> g(n);
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
vector<int> d(n);
for (int i = 0; i < n; i++) {
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
vector<vector<int>> g(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
vector<int> d(n);
for (int i = 0; i < n; i++) {
... | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 870,096 | 870,097 | u410878763 | cpp |
p03055 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define pb push_back
#define mk make_pair
#define eb emplace_back
#define eps 1e-8
#define fi first
#def... | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define pb push_back
#define mk make_pair
#define eb emplace_back
#define eps 1e-8
#define fi first
#def... | [
"variable_declaration.value.change"
] | 870,110 | 870,111 | u778948914 | cpp |
p03055 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <regex>
#include <set>
#include <sstr... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <regex>
#include <set>
#include <sstr... | [
"literal.string.change",
"io.output.change"
] | 870,112 | 870,113 | u385617244 | cpp |
p03055 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <regex>
#include <set>
#include <sstr... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <regex>
#include <set>
#include <sstr... | [
"literal.string.change",
"io.output.change"
] | 870,114 | 870,113 | u385617244 | cpp |
p03055 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <regex>
#include <set>
#include <sstr... | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <regex>
#include <set>
#include <sstr... | [
"expression.operation.binary.remove",
"literal.string.change",
"io.output.change",
"literal.string.case.change"
] | 870,115 | 870,113 | u385617244 | cpp |
p03055 | ////////////////////////////////////////////
/// ///
/// Template ver. 1 rapel ///
/// Fear is Temporary, Regret is Forever ///
/// Must Try and Get AC ///
/// ///
////////////////////////////////////////////
#incl... | ////////////////////////////////////////////
/// ///
/// Template ver. 1 rapel ///
/// Fear is Temporary, Regret is Forever ///
/// Must Try and Get AC ///
/// ///
////////////////////////////////////////////
#incl... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 870,116 | 870,117 | u236830524 | cpp |
p03055 | #include "bits/stdc++.h"
using ll = long long;
using namespace std;
#define int ll
// 0 -> a-1
#define rep(i, a) for (int i = 0; (i) < (int)(a); (i)++)
// a -> b-1
#define reps(i, a, b) for (int i = (int)(a); (i) < (int)(b); (i)++)
// a-1 -> 0
#define rrep(i, a) for (int i = (int)a - 1; (i) >= 0; (i)--)
// a-1 -> b
... | #include "bits/stdc++.h"
using ll = long long;
using namespace std;
#define int ll
// 0 -> a-1
#define rep(i, a) for (int i = 0; (i) < (int)(a); (i)++)
// a -> b-1
#define reps(i, a, b) for (int i = (int)(a); (i) < (int)(b); (i)++)
// a-1 -> 0
#define rrep(i, a) for (int i = (int)a - 1; (i) >= 0; (i)--)
// a-1 -> b
... | [
"expression.operation.unary.logical.remove",
"control_flow.branch.if.condition.change",
"expression.unary.arithmetic.add"
] | 870,120 | 870,121 | u946322619 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, rt, tot, d[N], head[N], nex[2 * N], to[2 * N];
void add(int u, int v) {
to[++tot] = v;
nex[tot] = head[u];
head[u] = tot;
}
void dfs(int u, int fa) {
d[u] = d[fa] + 1;
if (d[u] > d[rt])
rt = u;
for (int i = head[u]; i; i = nex[i... | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, rt, tot, d[N], head[N], nex[2 * N], to[2 * N];
void add(int u, int v) {
to[++tot] = v;
nex[tot] = head[u];
head[u] = tot;
}
void dfs(int u, int fa) {
d[u] = d[fa] + 1;
if (d[u] > d[rt])
rt = u;
for (int i = head[u]; i; i = nex[i... | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 870,132 | 870,133 | u676323984 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, rt, tot, d[N], head[N], nex[2 * N], to[2 * N];
void add(int u, int v) {
to[++tot] = v;
nex[tot] = head[u];
head[u] = tot;
}
void dfs(int u, int fa) {
d[u] = d[fa] + 1;
if (d[u] > d[rt])
rt = u;
for (int i = head[u]; i; i = nex[i... | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, rt, tot, d[N], head[N], nex[2 * N], to[2 * N];
void add(int u, int v) {
to[++tot] = v;
nex[tot] = head[u];
head[u] = tot;
}
void dfs(int u, int fa) {
d[u] = d[fa] + 1;
if (d[u] > d[rt])
rt = u;
for (int i = head[u]; i; i = nex[i... | [] | 870,134 | 870,133 | u676323984 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
const int inf = (1 << 30) - 1;
const ll infll = (1LL << 61) - 1;
template <typename 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), ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
const int inf = (1 << 30) - 1;
const ll infll = (1LL << 61) - 1;
template <typename 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), ... | [] | 870,142 | 870,143 | u394482932 | cpp |
p03055 | #include <iostream>
#include <queue>
#include <vector>
using namespace std;
pair<int, int> bfs(const vector<vector<int>> &g, int start) {
const int n = g.size();
vector<int> step(n, 1000000007);
queue<int> qu;
qu.push(start);
step[start] = 0;
pair<int, int> res = make_pair(start, 0);
while (!qu.empty())... | #include <iostream>
#include <queue>
#include <vector>
using namespace std;
pair<int, int> bfs(const vector<vector<int>> &g, int start) {
const int n = g.size();
vector<int> step(n, 1000000007);
queue<int> qu;
qu.push(start);
step[start] = 0;
pair<int, int> res = make_pair(start, 0);
while (!qu.empty())... | [
"literal.number.change",
"control_flow.loop.condition.change"
] | 870,147 | 870,148 | u002023395 | cpp |
p03055 | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = long long;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) FOR(i, 0, b)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
... | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = long long;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) FOR(i, 0, b)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
... | [] | 870,152 | 870,153 | u354336886 | cpp |
p03055 | #include "bits/stdc++.h"
#define in std::cin
#define out std::cout
#define rep(i, N) for (LL i = 0; i < N; ++i)
typedef long long int LL;
std::vector<std::vector<LL>> G;
std::vector<LL> dist;
void dfs(LL v, LL d, LL p) {
dist[v] = d;
for (LL u : G[v]) {
if (u != p)
dfs(u, d + 1, v);
}
}
int main() {
... | #include "bits/stdc++.h"
#define in std::cin
#define out std::cout
#define rep(i, N) for (LL i = 0; i < N; ++i)
typedef long long int LL;
std::vector<std::vector<LL>> G;
std::vector<LL> dist;
void dfs(LL v, LL d, LL p) {
dist[v] = d;
for (LL u : G[v]) {
if (u != p)
dfs(u, d + 1, v);
}
}
int main() {
... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"literal.string.change"
] | 870,158 | 870,159 | u660613376 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define vvi vector<vector<int>>
#define vec vector
#define pq priority_queue
#define all(v) (v).begin(), (v).end()
#define uniqueV(x) \
sort(x.begin(), x.end()); ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define vvi vector<vector<int>>
#define vec vector
#define pq priority_queue
#define all(v) (v).begin(), (v).end()
#define uniqueV(x) \
sort(x.begin(), x.end()); ... | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change",
"literal.string.change"
] | 870,162 | 870,163 | u219873012 | cpp |
p03055 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define vvi vector<vector<int>>
#define vec vector
#define pq priority_queue
#define all(v) (v).begin(), (v).end()
#define uniqueV(x) \
sort(x.begin(), x.end()); ... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define vvi vector<vector<int>>
#define vec vector
#define pq priority_queue
#define all(v) (v).begin(), (v).end()
#define uniqueV(x) \
sort(x.begin(), x.end()); ... | [
"expression.unary.arithmetic.add",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 870,162 | 870,164 | u219873012 | cpp |
p03055 | #define DEBUG 0
/**
* File : C2.cpp
* Author : Kazune Takahashi
* Created : 2019-5-21 22:20:49
* Powered by Visual Studio Code
*/
#include <algorithm> // do { } while ( next_permutation(A, A+xxx) ) ;
#include <chrono> // std::chrono::system_clock::time_point start_time, end_time;
#include <complex>
#include ... | #define DEBUG 0
/**
* File : C2.cpp
* Author : Kazune Takahashi
* Created : 2019-5-21 22:20:49
* Powered by Visual Studio Code
*/
#include <algorithm> // do { } while ( next_permutation(A, A+xxx) ) ;
#include <chrono> // std::chrono::system_clock::time_point start_time, end_time;
#include <complex>
#include ... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"io.output.change"
] | 870,165 | 870,166 | u521272340 | cpp |
p03055 |
#if 1
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long lo... |
#if 1
#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define int long lo... | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"io.output.change"
] | 870,169 | 870,170 | u154068540 | cpp |
p03055 | #include <bits/stdc++.h>
const char nl = '\n';
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> pt;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int N = 2e5 + 10;
vector<int> adj[N];
bool vis[N];
int d[N];
void dfs(int u) {
vis[u] = 1;
for (int v : adj[u]) {
... | #include <bits/stdc++.h>
const char nl = '\n';
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> pt;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int N = 2e5 + 10;
vector<int> adj[N];
bool vis[N];
int d[N];
void dfs(int u) {
vis[u] = 1;
for (int v : adj[u]) {
... | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 870,174 | 870,175 | u404421571 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.