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 |
|---|---|---|---|---|---|---|---|
p03048 | #include <bits/stdc++.h>
using namespace std;
map<int, int> memo[3];
int sai(int r, int g, int b, int n, int sum, int q) {
int ans = 0, es = 0;
if (q == 0) {
if (memo[0].find(sum) != memo[0].end()) {
ans += memo[0][sum];
} else if (sum + r == n) {
ans++;
} else if (sum + r < n) {
ans += sai(r, g, b, n, sum + r, 0);
}
memo[0][sum] = ans;
}
es = ans;
if (q <= 1) {
if (memo[1].find(sum) != memo[1].end()) {
ans += memo[1][sum];
} else if (sum + g == n) {
ans++;
} else if (sum + g < n) {
ans += sai(r, g, b, n, sum + g, 1);
}
memo[1][sum] += ans - es;
}
es = ans;
if (memo[1].find(sum) != memo[2].end()) {
ans += memo[1][sum];
} else if (sum + b == n) {
ans++;
} else if (sum + b < n) {
ans += sai(r, g, b, n, sum + b, 2);
}
memo[2][sum] = ans - es;
return (ans);
}
int main() {
int r, g, b, n;
cin >> r >> g >> b >> n;
cout << sai(r, g, b, n, 0, 0) << endl;
return (0);
} | #include <bits/stdc++.h>
using namespace std;
map<int, int> memo[3];
int sai(int r, int g, int b, int n, int sum, int q) {
int ans = 0, es = 0;
if (q == 0) {
if (memo[0].find(sum) != memo[0].end()) {
ans += memo[0][sum];
} else if (sum + r == n) {
ans++;
} else if (sum + r < n) {
ans += sai(r, g, b, n, sum + r, 0);
}
memo[0][sum] = ans;
}
es = ans;
if (q <= 1) {
if (memo[1].find(sum) != memo[1].end()) {
ans += memo[1][sum];
} else if (sum + g == n) {
ans++;
} else if (sum + g < n) {
ans += sai(r, g, b, n, sum + g, 1);
}
memo[1][sum] += ans - es;
}
es = ans;
if (memo[2].find(sum) != memo[2].end()) {
ans += memo[2][sum];
} else if (sum + b == n) {
ans++;
} else if (sum + b < n) {
ans += sai(r, g, b, n, sum + b, 2);
}
memo[2][sum] = ans - es;
return (ans);
}
int main() {
int r, g, b, n;
cin >> r >> g >> b >> n;
cout << sai(r, g, b, n, 0, 0) << endl;
return (0);
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.value.change"
] | 865,139 | 865,140 | u320853829 | cpp |
p03048 | /* ****TCIITB**** */
#include <bits/stdc++.h>
#define io \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pb push_back
#define endl '\n'
#define pii pair<ll int, ll int>
#define vi vector<ll int>
#define all(a) (a).begin(), (a).end()
#define F first
#define S second
#define sz(x) (ll int)x.size()
#define hell 1000000007
#define rep(i, a, b) for (ll int i = a; i < b; i++)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define mp make_pair
#define time \
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
using namespace std;
#define N 100005
int main() {
io ll r, g, b, n;
cin >> r >> g >> b >> n;
ll ans = 0;
rep(i, 0, n + 1) {
rep(j, 0, n + 1) {
ll rem = (n - (r * i + g * j));
if (rem <= b && rem >= 0 && !(rem % b)) {
ans++;
}
}
}
cout << ans;
} | /* ****TCIITB**** */
#include <bits/stdc++.h>
#define io \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pb push_back
#define endl '\n'
#define pii pair<ll int, ll int>
#define vi vector<ll int>
#define all(a) (a).begin(), (a).end()
#define F first
#define S second
#define sz(x) (ll int)x.size()
#define hell 1000000007
#define rep(i, a, b) for (ll int i = a; i < b; i++)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define mp make_pair
#define time \
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
using namespace std;
#define N 100005
int main() {
io ll r, g, b, n;
cin >> r >> g >> b >> n;
ll ans = 0;
rep(i, 0, n + 1) {
rep(j, 0, n + 1) {
ll rem = (n - (r * i + g * j));
if (rem >= 0 && !(rem % b)) {
ans++;
}
}
}
cout << ans;
} | [
"expression.operation.binary.remove"
] | 865,157 | 865,158 | u930865369 | cpp |
p03048 | #include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int R, G, B, N;
int cnt = 0;
cin >> R;
cin >> G;
cin >> B;
cin >> N;
for (int i = 0; i * R < N + 1; i++) {
for (int j = 0; i * R + j * G < N; j++) {
if ((N - i * R - j * G) % B == 0)
cnt++;
}
}
printf("%d", cnt);
return 0;
}
| #include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int R, G, B, N;
int cnt = 0;
cin >> R;
cin >> G;
cin >> B;
cin >> N;
for (int i = 0; i * R < N + 1; i++) {
for (int j = 0; i * R + j * G < N + 1; j++) {
if ((N - i * R - j * G) % B == 0)
cnt++;
}
}
printf("%d", cnt);
return 0;
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 865,161 | 865,162 | u969617556 | cpp |
p03048 | #include <bits/stdc++.h>
typedef long long ll;
#define REP(i, a) for (int i = 0; i < (a); i++)
using namespace std;
int main() {
int r, g, b, n;
cin >> r >> g >> b >> n;
int cnt = 0;
for (int i = 0; i <= n / r; i++) {
for (int j = 0; i * r + j * g <= n; j++) {
if ((n - i * r + j * g) % b == 0) {
cnt++;
}
}
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
typedef long long ll;
#define REP(i, a) for (int i = 0; i < (a); i++)
using namespace std;
int main() {
int r, g, b, n;
cin >> r >> g >> b >> n;
int cnt = 0;
for (int i = 0; i <= n / r; i++) {
for (int j = 0; i * r + j * g <= n; j++) {
if ((n - i * r - j * g) % b == 0) {
cnt++;
}
}
}
cout << cnt << endl;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 865,165 | 865,166 | u366398972 | cpp |
p03048 | //#include <bits/stdc++.h>
#include <iostream>
//#include <cmath>
//#include <vector>
using namespace std;
int main() {
int R, G, B, N;
int sum, count;
count = 0;
cin >> R >> G >> B >> N;
for (int i = 0; i < N / R + 1; i++) {
for (int j = 0; j < N / G + 1; j++) {
if ((N - R * i - G * j) % B == 0) {
count++;
continue;
}
}
}
cout << count << endl;
return 0;
} | //#include <bits/stdc++.h>
#include <iostream>
//#include <cmath>
//#include <vector>
using namespace std;
int main() {
int R, G, B, N;
int sum, count;
count = 0;
cin >> R >> G >> B >> N;
for (int i = 0; i < N / R + 1; i++) {
for (int j = 0; j < (N - R * i) / G + 1; j++) {
if ((N - R * i - G * j) % B == 0) {
count++;
continue;
}
}
}
cout << count << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 865,177 | 865,178 | u516521873 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n;
cin >> r >> g >> b >> n;
int a;
if (b > g) {
a = b;
b = g;
g = a;
}
if (g > r) {
a = g;
g = r;
r = a;
}
if (b > g) {
a = b;
b = g;
g = a;
}
int count = 0;
for (int i = 0; i < (n + r - 1) / r; i++) {
for (int j = 0; j < (n - r * i + g - 1) / g; j++) {
if ((n - r * i - g * j) % b == 0 && (n - r * i - g * j) / b >= 0)
count++;
}
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n;
cin >> r >> g >> b >> n;
int a;
if (b > g) {
a = b;
b = g;
g = a;
}
if (g > r) {
a = g;
g = r;
r = a;
}
if (b > g) {
a = b;
b = g;
g = a;
}
int count = 0;
for (int i = 0; i <= (n + r - 1) / r; i++) {
for (int j = 0; j <= (n - r * i + g - 1) / g; j++) {
if ((n - r * i - g * j) % b == 0 && (n - r * i - g * j) / b >= 0)
count++;
}
}
cout << count << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 865,179 | 865,180 | u953110527 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n;
cin >> r >> g >> b >> n;
int a;
if (b > g) {
a = b;
b = g;
g = a;
}
if (g > r) {
a = g;
g = r;
r = a;
}
if (b > g) {
a = b;
b = g;
g = a;
}
int count = 0;
for (int i = 0; i < (n + r - 1) / r; i++) {
for (int j = 0; j < (n - r * i + b - 1) / b; j++) {
if ((n - r * i - g * j) % b == 0 && (n - r * i - g * j) / b >= 0)
count++;
}
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n;
cin >> r >> g >> b >> n;
int a;
if (b > g) {
a = b;
b = g;
g = a;
}
if (g > r) {
a = g;
g = r;
r = a;
}
if (b > g) {
a = b;
b = g;
g = a;
}
int count = 0;
for (int i = 0; i <= (n + r - 1) / r; i++) {
for (int j = 0; j <= (n - r * i + g - 1) / g; j++) {
if ((n - r * i - g * j) % b == 0 && (n - r * i - g * j) / b >= 0)
count++;
}
}
cout << count << endl;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"identifier.change"
] | 865,181 | 865,180 | u953110527 | cpp |
p03048 | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
template <class T> using V = vector<T>;
template <class S, class T> using P = pair<S, T>;
template <class... T> using TP = tuple<T...>;
using ll = long long;
using db = double;
using ldb = long db;
using str = string;
using vll = V<ll>;
using vvll = V<V<ll>>;
using pll = P<ll, ll>;
using tpll = TP<ll, ll, ll>;
using vpll = V<pll>;
using vst = V<str>;
using vch = V<char>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); i++)
#define rFOR(i, a, b) for (ll i = (b); i > (ll)(a); i--)
#define oFOR(i, a, b) for (ll i = (a); i < (ll)(b); i += 2)
#define bgn begin()
#define en end()
#define SORT(a) sort((a).bgn, (a).en)
#define REV(a) reverse((a).bgn, (a).en)
#define fi first
#define se second
#define sz size()
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) __lcm(a, b)
#define co(a) cout << a << endl
#define pb(a) push_back(a)
#define pob pop_back()
#define mp make_pair
#define mt make_tuple
#define pbmp(a, b) push_back(mp(a, b))
#define subs(a, b) substr(a, b)
#define INF 1e16
#define mod 1e9 + 7
int main() {
ll R, G, B, n;
cin >> R >> G >> B >> n;
ll x, d = 0, u = mod, count = 0;
for (ll i = 0;; i++) {
for (ll j = 0;; j++) {
x = n - R * i - G * j;
if (x % B == 0) {
count++;
}
/* for(ll k=0;k<30;k++){
if(x<B*((d+u)/2)){
u=B*((d+u)/2);
}
if(x>B*((d+u)/2)){
d=B*((d+u)/2);
}
else{
count++;
break;
}
}*/
if (R * i + G * j > n)
break;
}
if (R * i > n)
break;
}
co(count);
}
| #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
template <class T> using V = vector<T>;
template <class S, class T> using P = pair<S, T>;
template <class... T> using TP = tuple<T...>;
using ll = long long;
using db = double;
using ldb = long db;
using str = string;
using vll = V<ll>;
using vvll = V<V<ll>>;
using pll = P<ll, ll>;
using tpll = TP<ll, ll, ll>;
using vpll = V<pll>;
using vst = V<str>;
using vch = V<char>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); i++)
#define rFOR(i, a, b) for (ll i = (b); i > (ll)(a); i--)
#define oFOR(i, a, b) for (ll i = (a); i < (ll)(b); i += 2)
#define bgn begin()
#define en end()
#define SORT(a) sort((a).bgn, (a).en)
#define REV(a) reverse((a).bgn, (a).en)
#define fi first
#define se second
#define sz size()
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) __lcm(a, b)
#define co(a) cout << a << endl
#define pb(a) push_back(a)
#define pob pop_back()
#define mp make_pair
#define mt make_tuple
#define pbmp(a, b) push_back(mp(a, b))
#define subs(a, b) substr(a, b)
#define INF 1e16
#define mod 1e9 + 7
int main() {
ll R, G, B, n;
cin >> R >> G >> B >> n;
ll x, d = 0, u = mod, count = 0;
for (ll i = 0;; i++) {
for (ll j = 0;; j++) {
x = n - R * i - G * j;
if (x % B == 0 && x >= 0) {
count++;
}
/* for(ll k=0;k<30;k++){
if(x<B*((d+u)/2)){
u=B*((d+u)/2);
}
if(x>B*((d+u)/2)){
d=B*((d+u)/2);
}
else{
count++;
break;
}
}*/
if (R * i + G * j > n)
break;
}
if (R * i > n)
break;
}
co(count);
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 865,184 | 865,185 | u177143886 | cpp |
p03048 | #include <algorithm>
#include <complex>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
int cnt = 0;
for (int i = 0; R * i <= N; i++) {
for (int j = 0; R * i + B * j <= N; j++) {
int remain = N - R * i + B * j;
if (remain % G == 0) {
cnt++;
}
}
}
cout << cnt << endl;
return 0;
} | #include <algorithm>
#include <complex>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
int cnt = 0;
for (int i = 0; R * i <= N; i++) {
for (int j = 0; R * i + B * j <= N; j++) {
int remain = N - (R * i + B * j);
if (remain % G == 0) {
cnt++;
}
}
}
cout << cnt << endl;
return 0;
} | [] | 865,188 | 865,189 | u545206239 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n, p = 0;
cin >> r >> g >> b >> n;
int n1, n2, n3;
if (r == max(r, max(g, b))) {
n1 = r;
if (g > b) {
n2 = g;
n3 = b;
} else {
n2 = b;
n3 = g;
}
} else if (g > b) {
n1 = g;
if (r > b) {
n2 = r;
n3 = b;
} else {
n2 = b;
n3 = r;
}
} else {
n1 = b;
if (r > g) {
n2 = r;
n3 = g;
} else {
n2 = g;
n3 = r;
}
}
int tmp1, tmp2, tmp3;
for (int i = n / n1; i >= 0; i--) {
tmp1 = n - i * n1;
for (int j = tmp1 / n2; j >= 0; j--) {
tmp2 = tmp1 - j * n2;
if (tmp2 % n2 == 0)
p++;
}
}
cout << p << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n, p = 0;
cin >> r >> g >> b >> n;
int n1, n2, n3;
if (r == max(r, max(g, b))) {
n1 = r;
if (g > b) {
n2 = g;
n3 = b;
} else {
n2 = b;
n3 = g;
}
} else if (g > b) {
n1 = g;
if (r > b) {
n2 = r;
n3 = b;
} else {
n2 = b;
n3 = r;
}
} else {
n1 = b;
if (r > g) {
n2 = r;
n3 = g;
} else {
n2 = g;
n3 = r;
}
}
int tmp1, tmp2, tmp3;
for (int i = n / n1; i >= 0; i--) {
tmp1 = n - i * n1;
for (int j = tmp1 / n2; j >= 0; j--) {
tmp2 = tmp1 - j * n2;
if (tmp2 % n3 == 0)
p++;
}
}
cout << p << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 865,199 | 865,200 | u038652983 | cpp |
p03048 | #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
int count = 0;
int r = 0;
while (R * r <= N) {
int g = 0;
while (g * G + R * r <= N) {
if ((N - r * R - g * G) % B == 0) {
int b = (N - r * R - g * G) / B;
if (0 <= b) {
count += 1;
}
else {
break;
}
}
g += 1;
r += 1;
}
}
cout << count << endl;
return 0;
}
| #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
int count = 0;
int r = 0;
while (R * r <= N) {
int g = 0;
while (g * G + R * r <= N) {
if ((N - r * R - g * G) % B == 0) {
int b = (N - r * R - g * G) / B;
if (0 <= b) {
count += 1;
}
else {
break;
}
}
g += 1;
}
r += 1;
}
cout << count << endl;
return 0;
}
| [] | 865,201 | 865,202 | u514299323 | cpp |
p03048 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
int main() {
int g, a, b, c, n, count = 0;
cin >> a;
cin >> b;
cin >> c;
cin >> n;
if (a < b) {
g = b;
b = a;
a = g;
}
if (b < c) {
g = c;
c = b;
b = g;
}
if (a < b) {
g = b;
b = a;
a = g;
}
for (int i = 0; i * a <= n; i++) {
for (int j = 0; j * b + i * a <= n; j++) {
if ((n - j * b + a * i) % c == 0) {
count++;
}
}
}
printf("%d\n", count);
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
int main() {
int g, a, b, c, n, count = 0;
cin >> a;
cin >> b;
cin >> c;
cin >> n;
if (a < b) {
g = b;
b = a;
a = g;
}
if (b < c) {
g = c;
c = b;
b = g;
}
if (a < b) {
g = b;
b = a;
a = g;
}
for (int i = 0; i * a <= n; i++) {
for (int j = 0; j * b + i * a <= n; j++) {
if ((n - j * b - a * i) % c == 0) {
count++;
}
}
}
printf("%d\n", count);
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 865,203 | 865,204 | u756776234 | cpp |
p03048 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
int main() {
int g, a, b, c, n, count = 0;
cin >> a;
cin >> b;
cin >> c;
cin >> n;
if (a < b) {
g = b;
b = a;
a = g;
}
if (b < c) {
g = c;
c = b;
b = g;
}
if (a < b) {
g = b;
b = a;
a = g;
}
for (int i = 0; i * a <= n; i++) {
for (int j = 0; j * b + i * a <= n; i++) {
if ((n - j * b + a * i) % c == 0)
count++;
}
}
printf("%d\n", count);
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
int main() {
int g, a, b, c, n, count = 0;
cin >> a;
cin >> b;
cin >> c;
cin >> n;
if (a < b) {
g = b;
b = a;
a = g;
}
if (b < c) {
g = c;
c = b;
b = g;
}
if (a < b) {
g = b;
b = a;
a = g;
}
for (int i = 0; i * a <= n; i++) {
for (int j = 0; j * b + i * a <= n; j++) {
if ((n - j * b - a * i) % c == 0) {
count++;
}
}
}
printf("%d\n", count);
return 0;
} | [
"identifier.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 865,205 | 865,204 | u756776234 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n, i, j, c = 0;
cin >> r >> g >> b >> n;
for (i = 0; i <= n / r; i++) {
for (j = 0; j <= (n - r * i) / g; j++) {
if ((n - r * i - g + j) >= 0 && (n - r * i - g + j) % b == 0) {
c++;
}
}
}
cout << c;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n, i, j, c = 0;
cin >> r >> g >> b >> n;
for (i = 0; i <= n / r; i++) {
for (j = 0; j <= (n - r * i) / g; j++) {
if ((n - r * i - g * j) >= 0 && (n - r * i - g * j) % b == 0) {
c++;
}
}
}
cout << c;
return 0;
} | [
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 865,208 | 865,209 | u058348416 | cpp |
p03048 | #include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long int llint;
typedef pair<int, int> pint;
typedef vector<int> vint;
typedef vector<llint> vllint;
typedef vector<pair<int, int>> vpint;
typedef vector<pair<llint, llint>> vpllint;
#define rep(i, n) for (int i = 0; i < n; i++)
#define drep(i, n) for (int i = n - 1; 0 <= i; i--)
#define yes(ans) \
if (ans) \
cout << "yes" << endl; \
else \
cout << "no" << endl;
#define Yes(ans) \
if (ans) \
cout << "Yes" << endl; \
else \
cout << "No" << endl;
#define YES(ans) \
if (ans) \
cout << "YES" << endl; \
else \
cout << "NO" << endl;
#define POSSIBLE(ans) \
if (ans) \
cout << "POSSIBLE" << endl; \
else \
cout << "IMPOSSIBLE" << endl;
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
// aとbの最大公約数を求めるよ
long long GCD(long long a, long long b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
// 返り値: a と b の最大公約数
// ax + by = gcd(a, b) を満たす (x, y) が格納される
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
bool check(int a, int b) { return a > b; }
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
llint ans = 0;
rep(i, 3000) {
rep(j, 3000) {
if (i * a + j * b <= d && (d - i * a - b * j) % c == 0) {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <string.h>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long int llint;
typedef pair<int, int> pint;
typedef vector<int> vint;
typedef vector<llint> vllint;
typedef vector<pair<int, int>> vpint;
typedef vector<pair<llint, llint>> vpllint;
#define rep(i, n) for (int i = 0; i < n; i++)
#define drep(i, n) for (int i = n - 1; 0 <= i; i--)
#define yes(ans) \
if (ans) \
cout << "yes" << endl; \
else \
cout << "no" << endl;
#define Yes(ans) \
if (ans) \
cout << "Yes" << endl; \
else \
cout << "No" << endl;
#define YES(ans) \
if (ans) \
cout << "YES" << endl; \
else \
cout << "NO" << endl;
#define POSSIBLE(ans) \
if (ans) \
cout << "POSSIBLE" << endl; \
else \
cout << "IMPOSSIBLE" << endl;
class UnionFind {
public:
//親の番号を格納する。親だった場合は-(その集合のサイズ)
vector<int> Parent;
//作るときはParentの値を全て-1にする
//こうすると全てバラバラになる
UnionFind(int N) { Parent = vector<int>(N, -1); }
// Aがどのグループに属しているか調べる
int root(int A) {
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
//自分のいるグループの頂点数を調べる
int size(int A) {
return -Parent[root(A)]; //親をとってきたい
}
// AとBをくっ付ける
bool connect(int A, int B) {
// AとBを直接つなぐのではなく、root(A)にroot(B)をくっつける
A = root(A);
B = root(B);
if (A == B) {
//すでにくっついてるからくっ付けない
return false;
}
//大きい方(A)に小さいほう(B)をくっ付けたい
//大小が逆だったらひっくり返しちゃう。
if (size(A) < size(B))
swap(A, B);
// Aのサイズを更新する
Parent[A] += Parent[B];
// Bの親をAに変更する
Parent[B] = A;
return true;
}
};
// aとbの最大公約数を求めるよ
long long GCD(long long a, long long b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
// 返り値: a と b の最大公約数
// ax + by = gcd(a, b) を満たす (x, y) が格納される
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
bool check(int a, int b) { return a > b; }
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
llint ans = 0;
rep(i, 3001) {
rep(j, 3001) {
if (i * a + j * b <= d && (d - i * a - b * j) % c == 0) {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 865,210 | 865,211 | u376082984 | cpp |
p03048 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 1e9 + 7
#define rep(i, n) for (int i = 0; i < n; i++)
#define NO cout << "NO" << endl;
#define YES cout << "YES" << endl;
#define No cout << "No" << endl;
#define Yes cout << "Yes" << endl;
#define all(a) a.begin(), a.end()
#define P pair<int, int>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
//(int)'a'は97 (int)'A'は65 (int)'1'は49
//おまじない
int main() {
int r, g, b, n;
int ans = 0;
cin >> r >> g >> b >> n;
for (int i = 0; r * i <= n; i++) {
for (int j = 0; g * j <= g; j++) {
if (n - r * i - g * j >= 0 && (n - r * i - g * j) % b == 0)
ans++;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 1e9 + 7
#define rep(i, n) for (int i = 0; i < n; i++)
#define NO cout << "NO" << endl;
#define YES cout << "YES" << endl;
#define No cout << "No" << endl;
#define Yes cout << "Yes" << endl;
#define all(a) a.begin(), a.end()
#define P pair<int, int>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
//(int)'a'は97 (int)'A'は65 (int)'1'は49
//おまじない
int main() {
int r, g, b, n;
int ans = 0;
cin >> r >> g >> b >> n;
for (int i = 0; r * i <= n; i++) {
for (int j = 0; g * j <= n; j++) {
if (n - r * i - g * j >= 0 && (n - r * i - g * j) % b == 0)
ans++;
}
}
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 865,214 | 865,215 | u297203024 | cpp |
p03048 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 1e9 + 7
#define rep(i, n) for (int i = 0; i < n; i++)
#define NO cout << "NO" << endl;
#define YES cout << "YES" << endl;
#define No cout << "No" << endl;
#define Yes cout << "Yes" << endl;
#define all(a) a.begin(), a.end()
#define P pair<int, int>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
//(int)'a'は97 (int)'A'は65 (int)'1'は49
//おまじない
int main() {
int r, g, b, n;
int ans = 0;
cin >> r >> g >> b >> n;
for (int i = 0; i <= r; i++) {
for (int j = 0; j <= g; j++) {
if (n - r * i - g * j >= 0 && (n - r * i - g * j) % b == 0)
ans++;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 1e9 + 7
#define rep(i, n) for (int i = 0; i < n; i++)
#define NO cout << "NO" << endl;
#define YES cout << "YES" << endl;
#define No cout << "No" << endl;
#define Yes cout << "Yes" << endl;
#define all(a) a.begin(), a.end()
#define P pair<int, int>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
//(int)'a'は97 (int)'A'は65 (int)'1'は49
//おまじない
int main() {
int r, g, b, n;
int ans = 0;
cin >> r >> g >> b >> n;
for (int i = 0; r * i <= n; i++) {
for (int j = 0; g * j <= n; j++) {
if (n - r * i - g * j >= 0 && (n - r * i - g * j) % b == 0)
ans++;
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"identifier.change",
"expression.operation.binary.change"
] | 865,216 | 865,215 | u297203024 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int maxn = 3e3 + 5;
int rd[maxn], bl[maxn], gr[maxn];
int32_t main() {
ios::sync_with_stdio(0);
int r, g, b, n;
cin >> r >> g >> b >> n;
int ways = 0;
for (int i = r; i <= n; i += r) {
for (int j = g; i + j <= n; j += g) {
if ((n - i - j) % b == 0)
ways++;
}
}
cout << ways;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int maxn = 3e3 + 5;
int rd[maxn], bl[maxn], gr[maxn];
int32_t main() {
ios::sync_with_stdio(0);
int r, g, b, n;
cin >> r >> g >> b >> n;
int ways = 0;
for (int i = 0; i <= n; i += r) {
for (int j = 0; i + j <= n; j += g) {
if ((n - i - j) % b == 0)
ways++;
}
}
cout << ways;
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.remove",
"literal.replace.add",
"control_flow.loop.for.initializer.change"
] | 865,219 | 865,220 | u150150862 | cpp |
p03048 | #include <iostream>
using namespace std;
int main() {
int r = 0, g = 0, b = 0, n = 0;
cin >> r >> g >> b >> n;
int res = 0;
for (int i = 0; i * r <= n; ++i) {
for (int j = 0; j * g <= n; ++j) {
int rem = n - i * r + j * g;
if (rem % b == 0) {
res += 1;
}
}
}
cout << res << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int r = 0, g = 0, b = 0, n = 0;
cin >> r >> g >> b >> n;
int res = 0;
for (int i = 0; i * r <= n; ++i) {
for (int j = 0; j * g <= n; ++j) {
int rem = n - i * r - j * g;
if (rem >= 0 && rem % b == 0) {
res += 1;
}
}
}
cout << res << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 865,225 | 865,226 | u725232444 | cpp |
p03048 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define INF 10e17 // 4倍しても(4回足しても)long longを溢れない
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep_r(i, n, m) for (int i = m; i < n; i++)
#define END cout << endl
#define MOD 1000000007
#define pb push_back
#define sorti(x) sort(x.begin(), x.end())
#define sortd(x) sort(x.begin(), x.end(), std::greater<int>())
#define debug(x) std::cerr << (x) << std::endl;
#define roll(x) \
for (auto itr : x) { \
debug(itr); \
}
int main() {
int r, g, b, n;
cin >> r >> g >> b >> n;
int rmax = n / r;
// cout << rmax << endl;
ll ans = 0;
for (int i = 0; i <= rmax; ++i) {
int rem = n - i * r;
int gmax = (rem / g) + 1;
for (int j = 0; j <= gmax; ++j) {
int remain = rem - j * g;
if (remain % b == 0)
ans += 1;
}
}
cout << ans << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define INF 10e17 // 4倍しても(4回足しても)long longを溢れない
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep_r(i, n, m) for (int i = m; i < n; i++)
#define END cout << endl
#define MOD 1000000007
#define pb push_back
#define sorti(x) sort(x.begin(), x.end())
#define sortd(x) sort(x.begin(), x.end(), std::greater<int>())
#define debug(x) std::cerr << (x) << std::endl;
#define roll(x) \
for (auto itr : x) { \
debug(itr); \
}
int main() {
int r, g, b, n;
cin >> r >> g >> b >> n;
int rmax = n / r;
// cout << rmax << endl;
ll ans = 0;
for (int i = 0; i <= rmax; ++i) {
int rem = n - i * r;
int gmax = (rem / g) + 1;
for (int j = 0; j <= gmax; ++j) {
int remain = rem - j * g;
if (remain >= 0 and remain % b == 0)
ans += 1;
}
}
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 865,227 | 865,228 | u898749314 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5;
int r, g, b, n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> r >> g >> b >> n;
ll ans = 0;
for (int i = 0;; i++) {
if (i * r > n)
break;
for (int j = 0;; j++) {
if (i * r + j * g > n)
break;
int tot = i * r + j * g;
if (tot % b == 0)
ans++;
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5;
int r, g, b, n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> r >> g >> b >> n;
ll ans = 0;
for (int i = 0;; i++) {
if (i * r > n)
break;
for (int j = 0;; j++) {
if (i * r + j * g > n)
break;
int tot = n - i * r - j * g;
if (tot % b == 0)
ans++;
}
}
cout << ans;
return 0;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"expression.operation.binary.change"
] | 865,231 | 865,232 | u651116403 | cpp |
p03048 | #include <bits/stdc++.h>
#define Rint register int
using namespace std;
int r, g, b, n, ans;
int main() {
scanf("%d%d%d%d", &r, &g, &b, &n);
for (Rint i = 0; i <= n / r; i++)
for (Rint j = 0; j <= n - i * r; j++)
if ((n - r * i - g * j) % b == 0)
++ans;
printf("%d", ans);
} | #include <bits/stdc++.h>
#define Rint register int
using namespace std;
int r, g, b, n, ans;
int main() {
scanf("%d%d%d%d", &r, &g, &b, &n);
for (Rint i = 0; i <= n / r; i++)
for (Rint j = 0; j <= (n - i * r) / g; j++)
if ((n - r * i - g * j) % b == 0)
++ans;
printf("%d", ans);
} | [
"control_flow.loop.for.condition.change"
] | 865,239 | 865,240 | u680164084 | cpp |
p03048 | #include <iostream>
using namespace std;
int main(int argc, char const *argv[]) {
int R, G, B, N;
cin >> R >> G >> B >> N;
int cnt = 0;
for (int r = 0; r * R <= N; r++) {
for (int g = 0; r * R + g * G <= N; g++) {
if ((N - r * R - g * G) % B == 0) {
}
}
}
cout << cnt << endl;
return 0;
} | #include <iostream>
using namespace std;
int main(int argc, char const *argv[]) {
int R, G, B, N;
cin >> R >> G >> B >> N;
int cnt = 0;
for (int r = 0; r * R <= N; r++) {
for (int g = 0; r * R + g * G <= N; g++) {
if ((N - r * R - g * G) % B == 0) {
cnt++;
}
}
}
cout << cnt << endl;
return 0;
} | [
"expression.unary.arithmetic.add"
] | 865,399 | 865,400 | u735008991 | cpp |
p03048 | #include <iostream>
using namespace std;
int main(int argc, char const *argv[]) {
int R, G, B, N;
cin >> R >> G >> B >> N;
int cnt = 0;
for (int r = 0; r * R <= N; r++) {
for (int g = 0; r * R + g * G <= N; g++) {
if ((N - r * R + g * G) % B == 0)
cnt++;
}
}
cout << cnt << endl;
return 0;
} | #include <iostream>
using namespace std;
int main(int argc, char const *argv[]) {
int R, G, B, N;
cin >> R >> G >> B >> N;
int cnt = 0;
for (int r = 0; r * R <= N; r++) {
for (int g = 0; r * R + g * G <= N; g++) {
if ((N - r * R - g * G) % B == 0) {
cnt++;
}
}
}
cout << cnt << endl;
return 0;
} | [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 865,401 | 865,400 | u735008991 | cpp |
p03048 | #include <iostream>
using namespace std;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
int ans = 0;
for (int i = 0; i <= 3000; i++) {
for (int j = 0; j <= 3000 - i; j++) {
int A = R * i + G * j;
int n = N - A;
if (n > 0 && n % B == 0)
ans++;
}
}
cout << ans << endl;
}
| #include <iostream>
using namespace std;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
int ans = 0;
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= N; j++) {
int A = R * i + G * j;
int n = N - A;
// cout << n << endl;
if (n >= 0 && n % B == 0)
ans++;
}
}
cout << ans << endl;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 865,404 | 865,405 | u058186113 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n, count;
cin >> r >> g >> b >> n;
count = 0;
for (int i = 0; i < 1 + n / r; i++) {
for (int j = 0; j < n / g; j++) {
if ((n - r * i + g * j) / b >= 0) {
if ((n - r * i + g * j) % b == 0)
count++;
}
}
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n, count;
cin >> r >> g >> b >> n;
count = 0;
for (int i = 0; i < 1 + n / r; i++) {
for (int j = 0; j < 1 + n / g; j++) {
if ((n - r * i - g * j) / b >= 0) {
if ((n - r * i - g * j) % b == 0) {
count++;
}
}
}
}
cout << count << endl;
} | [
"control_flow.loop.for.condition.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 865,417 | 865,418 | u478462004 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
#define INF 100000000
#define ll long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, m, n) for (int i = m; i < n; i++)
#define de cout << "debug" << endl;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
int cnt = 0;
REP(i, N / R + 1) {
REP(j, N / G + 1) {
if (i * R + j * G > N)
break;
if (N - (i * R + j * G) % B == 0) {
cnt++;
}
}
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define INF 100000000
#define ll long long
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPP(i, m, n) for (int i = m; i < n; i++)
#define de cout << "debug" << endl;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
int cnt = 0;
REP(i, N / R + 1) {
REP(j, N / G + 1) {
if (i * R + j * G > N)
break;
if ((N - (i * R + j * G)) % B == 0) {
cnt++;
}
}
}
cout << cnt << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 865,428 | 865,429 | u901397311 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
/**
彡(ﾟ)(ﾟ)
彡 と
＿ ／ ）
..,.,.,....., ぅ／
/ // |━ ┗| ノ
,/ /' ＼ / ＿＿＿＿＿ ,.／ ／/ |
（＿＿＿＿＿二二二二) ﾉ （ |
^^^' ヽ, | | ,..,......＼',冫｡
ｿ / 冫｡ | ━ | ´'´,.ゝ'
ノ / ') >kkk<
／ ノ/ / |!I!I!I!I!I!|
*/
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
long long ans = 0;
int MAX = N + 1;
for (int i = 0; i < MAX / R; ++i) {
int r = i * R;
if (r > N) {
break;
}
for (int j = 0; j < MAX / G; ++j) {
if (i * R + j * G > N) {
break;
}
long long balls = i * R + j * G;
if ((N - balls) % B == 0 && (N - balls) / B >= 0) {
ans++;
}
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
long long ans = 0;
int MAX = N + 1;
for (int i = 0; i <= N / R; ++i) {
int r = i * R;
if (r > N) {
break;
}
for (int j = 0; j <= N / G; ++j) {
if (i * R + j * G > N) {
break;
}
long long balls = i * R + j * G;
if ((N - balls) % B == 0 && (N - balls) / B >= 0) {
ans++;
}
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change"
] | 865,449 | 865,450 | u307834890 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
long long ans = 0;
int MAX = N + 1;
for (int i = 0; i < MAX / R; ++i) {
int r = i * R;
if (r > N) {
break;
}
for (int j = 0; j < MAX / G; ++j) {
if (i * R + j * G > N) {
break;
}
long long balls = i * R + j * G;
if ((N - balls) % B == 0 && (N - balls) / B >= 0) {
ans++;
}
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
long long ans = 0;
int MAX = N + 1;
for (int i = 0; i <= N / R; ++i) {
int r = i * R;
if (r > N) {
break;
}
for (int j = 0; j <= N / G; ++j) {
if (i * R + j * G > N) {
break;
}
long long balls = i * R + j * G;
if ((N - balls) % B == 0 && (N - balls) / B >= 0) {
ans++;
}
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change"
] | 865,451 | 865,450 | u307834890 | cpp |
p03048 | #include <bits/stdc++.h>
#include <vector>
using namespace std;
int main(void) {
int r, g, b, n, i, j, k, count, rr, g2, b2;
cin >> r >> g >> b >> n;
if (g > r) {
swap(r, g);
}
if (b > g) {
swap(b, g);
}
count = 0;
g2 = g;
b2 = b;
rr = g2 % b2;
while (rr != 0) {
g2 = b2;
b2 = rr;
rr = g2 % b2;
}
for (i = 0; r * i <= n; i++) {
if (n < r * i) {
break;
} else if (n == r * i) {
count += 1;
break;
}
if ((n - r * i) % b2 != 0) {
continue;
}
for (j = 0; r * i + g * j <= n; j++) {
if (n == r * i + g * j) {
count += 1;
break;
} else if ((n - r * i + g * j) % b == 0) {
count += 1;
}
}
}
cout << count;
return 0;
} | #include <bits/stdc++.h>
#include <vector>
using namespace std;
int main(void) {
int r, g, b, n, i, j, k, count, rr, g2, b2;
cin >> r >> g >> b >> n;
if (g > r) {
swap(r, g);
}
if (b > g) {
swap(b, g);
}
count = 0;
g2 = g;
b2 = b;
rr = g2 % b2;
while (rr != 0) {
g2 = b2;
b2 = rr;
rr = g2 % b2;
}
for (i = 0; r * i <= n; i++) {
if (n < r * i) {
break;
} else if (n == r * i) {
count += 1;
break;
}
if ((n - r * i) % b2 != 0) {
continue;
}
for (j = 0; r * i + g * j <= n; j++) {
if (n == r * i + g * j) {
count += 1;
break;
} else if ((n - (r * i + g * j)) % b == 0) {
count += 1;
}
}
}
cout << count;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 865,491 | 865,492 | u894950682 | cpp |
p03048 | #include <iostream>
using namespace std;
int main() {
int r, g, b, n;
int cnt = 0;
cin >> r >> g >> b >> n;
if (g > r && g > b) {
int tmp = g;
g = r;
r = tmp;
}
if (b > g && b > r) {
int tmp = b;
b = r;
r = tmp;
}
for (int i = 0; i <= n / r; i++) {
for (int j = 0; j <= n / g; j++) {
if (r * i + g * j > n) {
break;
}
if ((r * i + g * j) % b == 0) {
cnt++;
}
}
}
cout << cnt << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int r, g, b, n;
int cnt = 0;
cin >> r >> g >> b >> n;
if (g > r && g > b) {
int tmp = g;
g = r;
r = tmp;
}
if (b > g && b > r) {
int tmp = b;
b = r;
r = tmp;
}
for (int i = 0; i <= n / r; i++) {
for (int j = 0; j <= n / g; j++) {
if (r * i + g * j > n) {
break;
}
if ((n - (r * i + g * j)) % b == 0) {
cnt++;
}
}
}
cout << cnt << endl;
return 0;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 865,496 | 865,497 | u388485543 | cpp |
p03048 | #include <iostream>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int R, G, B, N;
cin >> R >> G >> B >> N;
long long ans = 0LL;
for (int r = 0; r <= 3000; r++) {
for (int g = 0; g <= 3000; g++) {
if ((r * R + g + G == N) ||
(r * R + g * G < N && (N - r * R - g * G) % B == 0)) {
ans++;
}
}
}
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int R, G, B, N;
cin >> R >> G >> B >> N;
long long ans = 0LL;
for (int r = 0; r <= 3000; r++) {
for (int g = 0; g <= 3000; g++) {
if ((r * R + g * G == N) ||
(r * R + g * G < N && (N - r * R - g * G) % B == 0)) {
ans++;
}
}
}
cout << ans << endl;
return 0;
} | [
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 865,502 | 865,503 | u341347211 | cpp |
p03048 | #include <iostream>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int R, G, B, N;
cin >> R >> G >> B >> N;
int ans = 0;
for (int r = 0; r <= 3000; r++) {
for (int g = 0; g <= 3000; g++) {
if ((r * R + g + G == N) ||
(r * R + g * G < N && (N - r * R - g * G) % B == 0)) {
ans++;
}
}
}
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int R, G, B, N;
cin >> R >> G >> B >> N;
long long ans = 0LL;
for (int r = 0; r <= 3000; r++) {
for (int g = 0; g <= 3000; g++) {
if ((r * R + g * G == N) ||
(r * R + g * G < N && (N - r * R - g * G) % B == 0)) {
ans++;
}
}
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.type.widen.change",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 865,504 | 865,503 | u341347211 | cpp |
p03048 | #include <bits/stdc++.h>
using ll = long long;
using Pii = std::pair<int, int>;
using Pll = std::pair<ll, ll>;
const ll INF = (ll)1e11;
using namespace std;
int main() {
ios::sync_with_stdio(false);
int R, G, B, N;
cin >> R >> G >> B >> N;
int ans = 0;
for (int r = 0; r <= N / R + 1; ++r) {
for (int g = 0; g <= (N - r * R) / G + 1; ++g) {
if (r * R + g * G > N)
break;
if ((r * R + g * G) % B == 0)
++ans;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using ll = long long;
using Pii = std::pair<int, int>;
using Pll = std::pair<ll, ll>;
const ll INF = (ll)1e11;
using namespace std;
int main() {
ios::sync_with_stdio(false);
int R, G, B, N;
cin >> R >> G >> B >> N;
int ans = 0;
for (int r = 0; r <= N / R + 1; ++r) {
for (int g = 0; g <= (N - r * R) / G + 1; ++g) {
if (r * R + g * G > N)
break;
if ((N - r * R - g * G) % B == 0)
++ans;
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.opposites",
"expression.operator.arithmetic.change"
] | 865,505 | 865,506 | u479592231 | cpp |
p03048 | #include <bits/stdc++.h>
//#define int long long
using namespace std;
signed main() {
long long ans = 0;
int r, g, b;
int n;
cin >> r >> g >> b >> n;
for (int i = 0; i < 3000; ++i) {
for (int j = 0; j < 3000; ++j) {
int res = n - (r * i + g * j);
if (res >= 0 && res % b == 0)
++ans;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
//#define int long long
using namespace std;
signed main() {
long long ans = 0;
int r, g, b;
int n;
cin >> r >> g >> b >> n;
for (int i = 0; i < 3001; ++i) {
for (int j = 0; j < 3001; ++j) {
int res = n - (r * i + g * j);
if (res >= 0 && res % b == 0)
++ans;
}
}
cout << ans << endl;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 865,507 | 865,508 | u698760125 | cpp |
p03048 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
long ans = 0;
for (int r = 0; r * R <= N; r++) {
for (int g = 0; r * R + g * G <= N; g++) {
if (N - (r * R + g * G) % B == 0)
ans++;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <unordered_map>
#include <vector>
using namespace std;
int main() {
int R, G, B, N;
cin >> R >> G >> B >> N;
long ans = 0;
for (int r = 0; r * R <= N; r++) {
for (int g = 0; r * R + g * G <= N; g++) {
if ((N - (r * R + g * G)) % B == 0)
ans++;
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 865,513 | 865,514 | u500092662 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
long long cnt = 0;
for (int i = 0; i * a <= d; i++) {
int x = i * a;
for (int j = 0; j * b <= (d - x); j++) {
int y = j * a;
if ((d - x - y) % c == 0)
cnt++;
}
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
long long cnt = 0;
for (int i = 0; i * a <= d; i++) {
int x = i * a;
for (int j = 0; j * b <= (d - x); j++) {
int y = j * b;
if ((d - x - y) % c == 0) {
cnt++;
// cout<<i<<" "<<j<<" "<<(d-x-y)/c<<endl;
}
}
}
cout << cnt << endl;
} | [
"identifier.change",
"expression.operation.binary.change"
] | 865,515 | 865,516 | u269278772 | cpp |
p03048 | #include "bits/stdc++.h"
using namespace std;
#define sp(x) cout << setprecision(x);
#define FOR(i, a, b) for (lint i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(a) (a).begin(), (a).end()
#define inf 10000000
#define linf INT64_MAX * 0.99
#define print(s) cout << (s) << endl
#define lint long long
#define yes "Yes"
#define no "No"
typedef pair<int, int> P;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
vector<lint> a(3);
REP(i, 3) cin >> a[i];
lint n;
cin >> n;
sort(all(a), greater<int>());
lint ans = 0;
REP(i, 3000) {
REP(j, 3000) {
int ball = a[0] * i + a[1] * j;
if (ball > n)
continue;
if ((n - ball) % a[2] == 0)
ans++;
else
continue;
}
}
print(ans);
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#define sp(x) cout << setprecision(x);
#define FOR(i, a, b) for (lint i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(a) (a).begin(), (a).end()
#define inf 10000000
#define linf INT64_MAX * 0.99
#define print(s) cout << (s) << endl
#define lint long long
#define yes "Yes"
#define no "No"
typedef pair<int, int> P;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
vector<lint> a(3);
REP(i, 3) cin >> a[i];
lint n;
cin >> n;
sort(all(a), greater<int>());
lint ans = 0;
REP(i, 3001) {
REP(j, 3001) {
int ball = a[0] * i + a[1] * j;
if (ball > n)
continue;
if ((n - ball) % a[2] == 0)
ans++;
else
continue;
}
}
print(ans);
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 865,521 | 865,522 | u601825761 | cpp |
p03048 | #include "bits/stdc++.h"
using namespace std;
#define sp(x) cout << setprecision(x);
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(a) (a).begin(), (a).end()
#define inf 10000000
#define linf INT64_MAX * 0.99
#define print(s) cout << (s) << endl
#define lint long long
#define yes "Yes"
#define no "No"
typedef pair<int, int> P;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
vector<int> a(3);
REP(i, 3) cin >> a[i];
int n;
cin >> n;
sort(all(a), greater<int>());
int ans = 0;
REP(i, 3000) {
REP(j, 3000) {
int ball = a[0] * i + a[1] * j;
if (ball > n)
continue;
if ((n - ball) % a[2] == 0)
ans++;
else
continue;
}
}
print(ans);
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#define sp(x) cout << setprecision(x);
#define FOR(i, a, b) for (lint i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define all(a) (a).begin(), (a).end()
#define inf 10000000
#define linf INT64_MAX * 0.99
#define print(s) cout << (s) << endl
#define lint long long
#define yes "Yes"
#define no "No"
typedef pair<int, int> P;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
vector<lint> a(3);
REP(i, 3) cin >> a[i];
lint n;
cin >> n;
sort(all(a), greater<int>());
lint ans = 0;
REP(i, 3001) {
REP(j, 3001) {
int ball = a[0] * i + a[1] * j;
if (ball > n)
continue;
if ((n - ball) % a[2] == 0)
ans++;
else
continue;
}
}
print(ans);
return 0;
} | [
"preprocessor.define.value.change",
"variable_declaration.type.change",
"literal.number.change",
"call.arguments.change"
] | 865,523 | 865,522 | u601825761 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, b, g, n, ans = 0;
cin >> r >> b >> g >> n;
for (int i = 0; i <= n / r; i++) {
for (int j = 0; j <= n / b; j++) {
if ((n - r * i - b * j) % g == 0) {
ans++;
}
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, b, g, n, ans = 0;
cin >> r >> b >> g >> n;
for (int i = 0; i <= n / r; i++) {
for (int j = 0; j <= (n - r * i) / b; j++) {
if ((n - r * i - b * j) % g == 0) {
ans++;
}
}
}
cout << ans << endl;
}
| [
"control_flow.loop.for.condition.change"
] | 865,524 | 865,525 | u952865396 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int r, g, b, n;
cin >> r >> g >> b >> n;
int cnt = 0;
for (int i = 0; r * i <= n; i++) {
for (int j = 0; b * j <= n - r * i; j++) {
int k = n - r * j - b * j;
if (k % g == 0)
cnt++;
}
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int r, g, b, n;
cin >> r >> g >> b >> n;
int cnt = 0;
for (int i = 0; r * i <= n; i++) {
for (int j = 0; b * j <= n - r * i; j++) {
int k = n - r * i - b * j;
if (k % g == 0) {
cnt++;
}
}
}
cout << cnt << endl;
} | [
"identifier.change",
"expression.operation.binary.change"
] | 865,528 | 865,529 | u210718367 | cpp |
p03048 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n;
scanf("%d%d%d%d", &r, &g, &b, &n);
int ans = 0;
for (int i = 0; i * r <= n; ++i) {
for (int j = 0; j * b + i * r <= n; ++j) {
if ((n - j * b + i * r) % g == 0)
++ans;
}
}
printf("%d\n", ans);
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int r, g, b, n;
scanf("%d%d%d%d", &r, &g, &b, &n);
int ans = 0;
for (int i = 0; i * r <= n; ++i) {
for (int j = 0; j * b + i * r <= n; ++j) {
if ((n - j * b - i * r) % g == 0)
++ans;
}
}
printf("%d\n", ans);
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"control_flow.branch.if.condition.change"
] | 865,534 | 865,535 | u394891853 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i < b; i++)
#define out(x) cout << x << endl
#define EPS (1e-7)
#define gearup \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<bool>> vvb;
typedef vector<vector<double>> vvd;
typedef vector<vector<string>> vvs;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<vector<vector<ll>>> vvvl;
ll MOD = 1000000007;
const long long L_INF = 1LL << 60;
const int INF = 2147483647; // 2^31-1
const double PI = acos(-1);
// cout<<fixed<<setprecision(10);
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> void debug(T v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
//以降 cin の入力元が 'input.txt' になる
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
signed main() {
gearup;
ll n;
cin >> n;
// ABを作る
//末尾A、先頭Bを集める
// AかつBをCと定義
ll A, B, C;
A = B = C = 0;
ll res = 0;
rep(i, n) {
string s;
cin >> s;
ll m = s.size();
rep(j, m - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
res++;
}
if (s[0] == 'B' && s[m - 1] == 'A')
C++;
else if (s[0] == 'B')
B++;
else if (s[m - 1])
A++;
}
if (A + B == 0)
res += max(0LL, C - 1);
else
res += C + min(A, B);
out(res);
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i < b; i++)
#define out(x) cout << x << endl
#define EPS (1e-7)
#define gearup \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<bool>> vvb;
typedef vector<vector<double>> vvd;
typedef vector<vector<string>> vvs;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<vector<vector<ll>>> vvvl;
ll MOD = 1000000007;
const long long L_INF = 1LL << 60;
const int INF = 2147483647; // 2^31-1
const double PI = acos(-1);
// cout<<fixed<<setprecision(10);
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> void debug(T v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
//以降 cin の入力元が 'input.txt' になる
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
signed main() {
gearup;
ll n;
cin >> n;
// ABを作る
//末尾A、先頭Bを集める
// AかつBをCと定義
ll A, B, C;
A = B = C = 0;
ll res = 0;
rep(i, n) {
string s;
cin >> s;
ll m = s.size();
rep(j, m - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
res++;
}
if (s[0] == 'B' && s[m - 1] == 'A')
C++;
else if (s[0] == 'B')
B++;
else if (s[m - 1] == 'A')
A++;
}
if (A + B == 0)
res += max(0LL, C - 1);
else
res += C + min(A, B);
out(res);
} | [
"control_flow.branch.if.condition.change"
] | 865,536 | 865,537 | u929582923 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, n, j) for (int i = (j); i < (n); ++i)
#define ssort(n) sort((n).begin(), (n).end())
#define rsort(n) sort((n).begin(), (n).end(), greater<int>())
#define mp make_pair
using ll = long long;
using ld = long double;
typedef pair<int, int> P;
typedef pair<P, int> COST;
#define repl(i, n) for (ll i = 0; i < (n); ++i)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define YES cout << "YES" << endl
#define NO cout << "NO" << endl
using Graf = vector<vector<int>>;
#define MAX 1000000007
int main() {
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
int count = 0;
int a_b_exist = 0;
int a, b;
a = b = 0;
rep(i, n) {
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
a_b_exist++;
}
if (s[i][0] == 'B') {
b++;
}
if (s[i][s[i].size() - 1] == 'A') {
a++;
}
}
count = min(a, b);
if (a == b && b == a_b_exist) {
count--;
}
rep(i, n) {
rep(j, s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
count++;
}
}
}
cout << count << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, n, j) for (int i = (j); i < (n); ++i)
#define ssort(n) sort((n).begin(), (n).end())
#define rsort(n) sort((n).begin(), (n).end(), greater<int>())
#define mp make_pair
using ll = long long;
using ld = long double;
typedef pair<int, int> P;
typedef pair<P, int> COST;
#define repl(i, n) for (ll i = 0; i < (n); ++i)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define YES cout << "YES" << endl
#define NO cout << "NO" << endl
using Graf = vector<vector<int>>;
#define MAX 1000000007
int main() {
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
int count = 0;
int a_b_exist = 0;
int a, b;
a = b = 0;
rep(i, n) {
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
a_b_exist++;
}
if (s[i][0] == 'B') {
b++;
}
if (s[i][s[i].size() - 1] == 'A') {
a++;
}
}
count = min(a, b);
if (a == b && b == a_b_exist && count > 0) {
count--;
}
rep(i, n) {
rep(j, s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
count++;
}
}
}
cout << count << endl;
} | [
"control_flow.branch.if.condition.change"
] | 865,538 | 865,539 | u149757670 | cpp |
p03049 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(ri, n) for (int ri = (int)(n - 1); ri >= 0; ri--)
#define rep2(i, x, n) for (int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri, x, n) for (int ri = (int)(n - 1); ri >= (int)(x); ri--)
#define repit(itr, x) for (auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr, x) for (auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
int fc(string &s) {
int res = 0;
rep(i, s.size() - 1) {
if (s.at(i) == 'A' && s.at(i + 1) == 'B')
res++;
}
return res;
}
int main() {
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s.at(i);
int ans = 0, ac = 0, bc = 0, abc = 0;
rep(i, n) {
if (s.at(i).front() == 'B')
bc++;
if (s.at(i).back() == 'A')
ac++;
if (s.at(i).back() == 'A' && s.at(i).front() == 'B')
abc++;
ans += fc(s.at(i));
}
ans += min(ac, bc);
if (ac == abc && bc == abc)
ans--;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(ri, n) for (int ri = (int)(n - 1); ri >= 0; ri--)
#define rep2(i, x, n) for (int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri, x, n) for (int ri = (int)(n - 1); ri >= (int)(x); ri--)
#define repit(itr, x) for (auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr, x) for (auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
int fc(string &s) {
int res = 0;
rep(i, s.size() - 1) {
if (s.at(i) == 'A' && s.at(i + 1) == 'B')
res++;
}
return res;
}
int main() {
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s.at(i);
int ans = 0, ac = 0, bc = 0, abc = 0;
rep(i, n) {
if (s.at(i).front() == 'B')
bc++;
if (s.at(i).back() == 'A')
ac++;
if (s.at(i).back() == 'A' && s.at(i).front() == 'B')
abc++;
ans += fc(s.at(i));
}
ans += min(ac, bc);
if (ac == abc && bc == abc && abc != 0)
ans--;
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 865,543 | 865,544 | u617826263 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n; i >= 0; --i)
const int inf = 1e9 + 7;
const ll mod = 1e9 + 7;
const ll mod1 = 998244353;
const ll big = 1e18;
const double PI = 2 * asin(1);
int main() {
int N;
cin >> N;
string S[N];
for (int i = 0; i < N; ++i)
cin >> S[i];
int ans = 0;
int anum = 0, bnum = 0, abnum = 0;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < S[i].size() - 1; ++j) {
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
ans++;
}
if (S[i][0] == 'B' && S[i][S[i].size() - 1] == 'A')
abnum++;
else if (S[i][S[i].size() - 1] == 'A')
anum++;
else if (S[i][0] == 'B')
bnum++;
}
if (anum > 0 || bnum > 0) {
ans += min(abnum + anum, abnum + bnum);
} else
ans += abnum - 1;
cout << ans << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = n; i >= 0; --i)
const int inf = 1e9 + 7;
const ll mod = 1e9 + 7;
const ll mod1 = 998244353;
const ll big = 1e18;
const double PI = 2 * asin(1);
int main() {
int N;
cin >> N;
string S[N];
for (int i = 0; i < N; ++i)
cin >> S[i];
int ans = 0;
int anum = 0, bnum = 0, abnum = 0;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < S[i].size() - 1; ++j) {
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
ans++;
}
if (S[i][0] == 'B' && S[i][S[i].size() - 1] == 'A')
abnum++;
else if (S[i][S[i].size() - 1] == 'A')
anum++;
else if (S[i][0] == 'B')
bnum++;
}
if (anum > 0 || bnum > 0) {
ans += min(abnum + anum, abnum + bnum);
} else if (abnum > 0)
ans += abnum - 1;
cout << ans << endl;
}
| [
"control_flow.branch.if.add"
] | 865,545 | 865,546 | u860546679 | cpp |
p03049 | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
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;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int ans = 0, a = 0, b = 0, ba = 0;
rep(i, n) {
string s;
cin >> s;
rep(j, s.size() - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
++ans;
}
if (s[0] == 'B' && s.back() == 'A')
++ba;
else if (s[0] == 'B')
++b;
else if (s.back() == 'A')
++a;
}
if (a > 0) {
ans += ba;
ba = 0;
} else {
ans += ba - 1;
ba = 0;
++a;
}
ans += min(a, b);
cout << ans << endl;
return 0;
} | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
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;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int ans = 0, a = 0, b = 0, ba = 0;
rep(i, n) {
string s;
cin >> s;
rep(j, s.size() - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
++ans;
}
if (s[0] == 'B' && s.back() == 'A')
++ba;
else if (s[0] == 'B')
++b;
else if (s.back() == 'A')
++a;
}
if (a > 0) {
ans += ba;
ba = 0;
} else if (ba > 0) {
ans += ba - 1;
ba = 0;
++a;
}
ans += min(a, b);
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.add"
] | 865,547 | 865,548 | u415325136 | cpp |
p03049 | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define N 233
typedef long long ll;
inline ll read() {
ll x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n, A, B, ans;
int flag;
char s[N];
int main() {
flag = false;
n = read();
for (int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
int len = strlen(s + 1);
A += s[len] == 'A';
B += s[1] == 'B';
flag += s[1] == 'B' && s[len] == 'A';
for (int j = 1; j < len; ++j) {
if (s[j] == 'A' && s[j + 1] == 'B')
++ans;
}
}
ans += min(A, B);
if (A == B && flag == A)
--ans;
printf("%d\n", ans);
return 0;
}
| #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define N 233
typedef long long ll;
inline ll read() {
ll x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n, A, B, ans;
int flag;
char s[N];
int main() {
flag = false;
n = read();
for (int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
int len = strlen(s + 1);
A += s[len] == 'A';
B += s[1] == 'B';
flag += s[1] == 'B' && s[len] == 'A';
for (int j = 1; j < len; ++j) {
if (s[j] == 'A' && s[j + 1] == 'B')
++ans;
}
}
ans += min(A, B);
if (A == B && flag == A && A)
--ans;
printf("%d\n", ans);
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 865,552 | 865,553 | u979500307 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int cntA, cntB, cntAB;
char s[15];
signed main() {
int n, len, ans = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> (s + 1);
len = strlen(s + 1);
for (int j = 1; j < len; ++j)
ans += (s[j] == 'A' && s[j + 1] == 'B');
if (s[1] == 'B' && s[len] == 'A')
++cntAB;
else if (s[1] == 'B')
++cntB;
else if (s[len] == 'A')
++cntA;
}
ans += cntAB - 1 + (cntA > 0) + (cntB > 0);
if (cntA > 0)
--cntA;
if (cntB > 0)
--cntB;
ans += min(cntA, cntB);
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int cntA, cntB, cntAB;
char s[15];
signed main() {
int n, len, ans = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> (s + 1);
len = strlen(s + 1);
for (int j = 1; j < len; ++j)
ans += (s[j] == 'A' && s[j + 1] == 'B');
if (s[1] == 'B' && s[len] == 'A')
++cntAB;
else if (s[1] == 'B')
++cntB;
else if (s[len] == 'A')
++cntA;
}
if (cntAB) {
ans += cntAB - 1 + (cntA > 0) + (cntB > 0);
if (cntA > 0)
--cntA;
if (cntB > 0)
--cntB;
}
ans += min(cntA, cntB);
cout << ans;
return 0;
} | [
"control_flow.branch.if.add"
] | 865,554 | 865,555 | u762214354 | cpp |
p03049 | #pragma region header
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for (int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
/* ----------------よく使う数字や配列----------------- */
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
constexpr ll mod = 1e9 + 7;
constexpr int inf = INT32_MAX / 2;
constexpr ll INF = LLONG_MAX / 2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
/* ----------------------end----------------------- */
/* --------------------テンプレート------------------ */
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/* ----------------------end----------------------- */
/* --------------------ライブラリ-------------------- */
ll fact(int i) { //階乗
if (i == 0)
return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) { //最大公約数
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { //最小公倍数
return a / gcd(a, b) * b;
}
int keta(ll n) { //桁数を求める
if (n == 0)
return 1;
int count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) { //各桁の和
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
bool isprime(int n) { //素数判定
if (n == 1)
return false;
if (n == 2)
return true;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return false;
}
return true;
}
/* ----------------------end----------------------- */
#pragma endregion
signed main() {
int n;
cin >> n;
int back = 0, front = 0;
int count = 0;
int chohuku = 0;
rep(i, n) {
string s;
cin >> s;
if (s[0] == 'B')
front++;
if (s.back() == 'A')
back++;
if (s[0] == 'B' && s.back() == 'A')
chohuku++;
rep(j, s.size() - 1) if (s.substr(j, 2) == "AB") count++;
}
bool ok = false;
if (chohuku == front && front == back)
ok = true;
cout << count + min(min(front, back) - ok, n - 1) << endl;
return 0;
}
/*
2
BAA
BBA
*/ | #pragma region header
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for (int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
/* ----------------よく使う数字や配列----------------- */
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
constexpr ll mod = 1e9 + 7;
constexpr int inf = INT32_MAX / 2;
constexpr ll INF = LLONG_MAX / 2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
/* ----------------------end----------------------- */
/* --------------------テンプレート------------------ */
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/* ----------------------end----------------------- */
/* --------------------ライブラリ-------------------- */
ll fact(int i) { //階乗
if (i == 0)
return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) { //最大公約数
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { //最小公倍数
return a / gcd(a, b) * b;
}
int keta(ll n) { //桁数を求める
if (n == 0)
return 1;
int count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) { //各桁の和
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
bool isprime(int n) { //素数判定
if (n == 1)
return false;
if (n == 2)
return true;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return false;
}
return true;
}
/* ----------------------end----------------------- */
#pragma endregion
signed main() {
int n;
cin >> n;
int back = 0, front = 0;
int count = 0;
int chohuku = 0;
rep(i, n) {
string s;
cin >> s;
if (s[0] == 'B')
front++;
if (s.back() == 'A')
back++;
if (s[0] == 'B' && s.back() == 'A')
chohuku++;
rep(j, s.size() - 1) if (s.substr(j, 2) == "AB") count++;
}
bool ok = false;
if (chohuku == front && front == back && chohuku)
ok = true;
cout << count + min(min(front, back) - ok, n - 1) << endl;
return 0;
}
/*
2
BAA
BBA
*/ | [
"control_flow.branch.if.condition.change"
] | 865,556 | 865,557 | u608773191 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
int count1 = 0, count2 = 0;
int kaage = 1;
for (int i = 0; i < N; i++) {
string S;
cin >> S;
bool a = false, b = false;
if (S.at(0) == 'B') {
a = true;
count1++;
}
if (S.at(S.size() - 1) == 'A') {
b = true;
count2++;
}
if (!a && !b)
kaage++;
for (int j = 0; j < S.size() - 1; j++) {
if (S.at(j) == 'A' && S.at(j + 1) == 'B')
ans++;
}
}
cout << ans + min(min(count1, count2), min(0, N - kaage)) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
int count1 = 0, count2 = 0;
int kaage = 1;
for (int i = 0; i < N; i++) {
string S;
cin >> S;
bool a = false, b = false;
if (S.at(0) == 'B') {
a = true;
count1++;
}
if (S.at(S.size() - 1) == 'A') {
b = true;
count2++;
}
if (!a && !b)
kaage++;
for (int j = 0; j < S.size() - 1; j++) {
if (S.at(j) == 'A' && S.at(j + 1) == 'B')
ans++;
}
}
cout << ans + min(min(count1, count2), max(0, N - kaage)) << endl;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change"
] | 865,558 | 865,559 | u991713078 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
int count1 = 0, count2 = 0;
int kaage = 1;
for (int i = 0; i < N; i++) {
string S;
cin >> S;
bool a = false, b = false;
if (S.at(0) == 'B') {
a = true;
count1++;
}
if (S.at(S.size() - 1) == 'A') {
b = true;
count2++;
}
if (!a && !b)
kaage++;
for (int j = 0; j < S.size() - 1; j++) {
if (S.at(j) == 'A' && S.at(j + 1) == 'B')
ans++;
}
}
cout << ans + min(min(count1, count2), N - kaage) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 0;
int count1 = 0, count2 = 0;
int kaage = 1;
for (int i = 0; i < N; i++) {
string S;
cin >> S;
bool a = false, b = false;
if (S.at(0) == 'B') {
a = true;
count1++;
}
if (S.at(S.size() - 1) == 'A') {
b = true;
count2++;
}
if (!a && !b)
kaage++;
for (int j = 0; j < S.size() - 1; j++) {
if (S.at(j) == 'A' && S.at(j + 1) == 'B')
ans++;
}
}
cout << ans + min(min(count1, count2), max(0, N - kaage)) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 865,560 | 865,559 | u991713078 | cpp |
p03049 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int N;
cin >> N;
vector<string> s(N);
rep(i, N) cin >> s[i];
int cntA = 0, cntB = 0, cntAB = 0, cntBA = 0;
rep(i, N) {
int M = s[i].size();
if (s[i][0] == 'B')
++cntB;
if (s[i][M - 1] == 'A')
++cntA;
if (s[i][0] == 'B' && s[i][M - 1] == 'A')
++cntBA;
rep(j, M) {
if (s[i][j] == 'A') {
if (j + 1 < M && s[i][j + 1] == 'B')
++cntAB;
}
}
}
ll ans = cntAB + min(cntA, cntB);
if (max(cntA, cntB) == cntBA)
--ans;
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int N;
cin >> N;
vector<string> s(N);
rep(i, N) cin >> s[i];
int cntA = 0, cntB = 0, cntAB = 0, cntBA = 0;
rep(i, N) {
int M = s[i].size();
if (s[i][0] == 'B')
++cntB;
if (s[i][M - 1] == 'A')
++cntA;
if (s[i][0] == 'B' && s[i][M - 1] == 'A')
++cntBA;
rep(j, M) {
if (s[i][j] == 'A') {
if (j + 1 < M && s[i][j + 1] == 'B')
++cntAB;
}
}
}
ll ans = cntAB + min(cntA, cntB);
if (cntBA != 0 && max(cntA, cntB) == cntBA)
--ans;
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change"
] | 865,563 | 865,564 | u097161601 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
/* エイリアス */
#define ll long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vpi vector<pii>
#define vpll vector<pll>
#define endl '\n'
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define em emplace
#define mp make_pair
/* 関数マクロ */
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; ++i)
#define rep3(i, n, m) for (ll i = n; i >= m; --i)
#define all(v) v.begin(), v.end()
#define si(v) int(v.size())
#define UNIQUE(v) sort(all(v)), v.erase(unique(all(v)), v.end())
/* 定数 */
const ll mod = 1e9 + 7;
const ll infll = (1LL << 62) - 1;
const ll inf = (1LL << 30) - 1;
/* その他 */
template <class S, class T> inline bool chmax(S &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class S, class T> inline bool chmin(S &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> using pq = priority_queue<T>;
template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
int a = 0, b = 0, c = 0;
rep(i, n) {
if (s[i].front() == 'B' && s[i].back() == 'A')
++c;
else if (s[i].front() == 'B')
++b;
else if (s[i].back() == 'A')
++a;
}
int ans = 0;
rep(i, n) rep(j, si(s) - 1) if (s[i][j] == 'A' && s[i][j + 1] == 'B')++ ans;
if (a > 0 && c > 0) {
--a;
++ans;
}
if (b > 0 && c > 0) {
--b;
++ans;
}
ans += max(0, c - 1);
ans += min(a, b);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
/* エイリアス */
#define ll long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vpi vector<pii>
#define vpll vector<pll>
#define endl '\n'
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define em emplace
#define mp make_pair
/* 関数マクロ */
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rep2(i, n, m) for (ll i = n; i <= m; ++i)
#define rep3(i, n, m) for (ll i = n; i >= m; --i)
#define all(v) v.begin(), v.end()
#define si(v) int(v.size())
#define UNIQUE(v) sort(all(v)), v.erase(unique(all(v)), v.end())
/* 定数 */
const ll mod = 1e9 + 7;
const ll infll = (1LL << 62) - 1;
const ll inf = (1LL << 30) - 1;
/* その他 */
template <class S, class T> inline bool chmax(S &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class S, class T> inline bool chmin(S &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> using pq = priority_queue<T>;
template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
int a = 0, b = 0, c = 0;
rep(i, n) {
if (s[i].front() == 'B' && s[i].back() == 'A')
++c;
else if (s[i].front() == 'B')
++b;
else if (s[i].back() == 'A')
++a;
}
int ans = 0;
rep(i, n)
rep(j, si(s[i]) - 1) if (s[i][j] == 'A' && s[i][j + 1] == 'B')++ ans;
if (a > 0 && c > 0) {
--a;
++ans;
}
if (b > 0 && c > 0) {
--b;
++ans;
}
ans += max(0, c - 1);
ans += min(a, b);
cout << ans << endl;
}
| [] | 865,567 | 865,568 | u790949059 | cpp |
p03049 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define FOR(i, start, end) for (int i = start; i <= end; i++)
const int INF = 1001001001;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
typedef long long ll;
const ll MOD = 1000000007;
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;
}
template <class T> auto MAX(const T &a) {
return *max_element(a.begin(), a.end());
}
template <class T> auto MIN(const T &a) {
return *min_element(a.begin(), a.end());
}
template <class T, class U> U SUM(const T &a, const U &v) {
return accumulate(a.begin(), a.end(), v);
}
template <class T, class U> U COUNT(const T &a, const U &v) {
return count(a.begin(), a.end(), v);
}
template <class T, class U> int LOWER(const T &a, const U &v) {
return lower_bound(a.begin(), a.end(), v) - a.begin();
}
template <class T, class U> int UPPER(const T &a, const U &v) {
return upper_bound(a.begin(), a.end(), v) - a.begin();
}
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) {
int g = GCD(a, b);
return a / g * b;
}
typedef long double ld;
typedef unsigned long long int ull;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<pair<ll, ll>> vpll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vc> vvc;
typedef vector<vs> vvs;
typedef vector<vll> vvll;
typedef map<int, int> mii;
typedef set<int> si;
//---------------------------------------------------------------------------------------------------
int main(void) {
// Your code here!
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
int c1 = 0;
int c2 = 0;
int c3 = 0;
rep(i, n) {
int l = s[i].size();
if (s[i][0] == 'B' && s[i][l - 1] == 'A')
c1++;
else if (s[i][0] == 'B')
c2++;
else if (s[i][l - 1] == 'A')
c3++;
}
int ans = 0;
rep(i, n) {
int l = s[i].size();
rep(j, l - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
if (c2 == 0 && c3 == 0) {
cout << max(0, ans + c1 - 1) << endl;
return 0;
}
cout << ans + c1 + min(c2, c3) << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define FOR(i, start, end) for (int i = start; i <= end; i++)
const int INF = 1001001001;
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
typedef long long ll;
const ll MOD = 1000000007;
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;
}
template <class T> auto MAX(const T &a) {
return *max_element(a.begin(), a.end());
}
template <class T> auto MIN(const T &a) {
return *min_element(a.begin(), a.end());
}
template <class T, class U> U SUM(const T &a, const U &v) {
return accumulate(a.begin(), a.end(), v);
}
template <class T, class U> U COUNT(const T &a, const U &v) {
return count(a.begin(), a.end(), v);
}
template <class T, class U> int LOWER(const T &a, const U &v) {
return lower_bound(a.begin(), a.end(), v) - a.begin();
}
template <class T, class U> int UPPER(const T &a, const U &v) {
return upper_bound(a.begin(), a.end(), v) - a.begin();
}
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) {
int g = GCD(a, b);
return a / g * b;
}
typedef long double ld;
typedef unsigned long long int ull;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<pair<ll, ll>> vpll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<vc> vvc;
typedef vector<vs> vvs;
typedef vector<vll> vvll;
typedef map<int, int> mii;
typedef set<int> si;
//---------------------------------------------------------------------------------------------------
int main(void) {
// Your code here!
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
int c1 = 0;
int c2 = 0;
int c3 = 0;
rep(i, n) {
int l = s[i].size();
if (s[i][0] == 'B' && s[i][l - 1] == 'A')
c1++;
else if (s[i][0] == 'B')
c2++;
else if (s[i][l - 1] == 'A')
c3++;
}
int ans = 0;
rep(i, n) {
int l = s[i].size();
rep(j, l - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
if (c1 > 0 && c2 == 0 && c3 == 0) {
cout << max(0, ans + c1 - 1) << endl;
return 0;
}
cout << ans + c1 + min(c2, c3) << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 865,571 | 865,572 | u852862907 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int countAB = 0;
int count_A = 0;
int countB_ = 0;
int countB_A = 0;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
int M = s.size();
if (s.at(0) == 'B' && s.at(M - 1) == 'A') {
countB_A++;
} else if (s.at(M - 1) == 'A') {
count_A++;
} else if (s.at(0) == 'B') {
countB_++;
}
for (int j = 0; j < M - 1; j++) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
countAB++;
}
}
}
if (count_A == 0 && countB_ == 0) {
cout << countAB + countB_A - 1 << endl;
} else {
cout << countAB + countB_A + min(countB_, count_A) << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int countAB = 0;
int count_A = 0;
int countB_ = 0;
int countB_A = 0;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
int M = s.size();
if (s.at(0) == 'B' && s.at(M - 1) == 'A') {
countB_A++;
} else if (s.at(M - 1) == 'A') {
count_A++;
} else if (s.at(0) == 'B') {
countB_++;
}
for (int j = 0; j < M - 1; j++) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
countAB++;
}
}
}
if (count_A == 0 && countB_ == 0) {
cout << countAB + max(countB_A - 1, 0) << endl;
} else {
cout << countAB + countB_A + min(countB_, count_A) << endl;
}
}
| [
"call.add",
"call.arguments.add"
] | 865,573 | 865,574 | u710877960 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
ll n;
cin >> n;
string s[n];
ll counta = 0, countb = 0, countab = 0, count = 0;
for (ll i = 0; i < n; i++) {
cin >> s[i];
if (s[i][0] == 'B')
countb++;
if (s[i][s[i].size() - 1] == 'A')
counta++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
countab++;
for (ll j = 0; j < (ll)s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
count++;
}
}
if (countab == counta && countab == countb)
cout << count + counta - 1 << endl;
else
cout << count + min({counta, countb, n - 1}) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
ll n;
cin >> n;
string s[n];
ll counta = 0, countb = 0, countab = 0, count = 0;
for (ll i = 0; i < n; i++) {
cin >> s[i];
if (s[i][0] == 'B')
countb++;
if (s[i][s[i].size() - 1] == 'A')
counta++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
countab++;
for (ll j = 0; j < (ll)s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
count++;
}
}
if (countab > 0 && countab == counta && countab == countb)
cout << count + counta - 1 << endl;
else
cout << count + min({counta, countb, n - 1}) << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 865,579 | 865,580 | u955282280 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
#define INF 1LL << 30
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(), (x).end()
int main() {
ll n;
cin >> n;
ll ans = 0, x = 0, y = 0, z = 0;
rep(i, n) {
string s;
cin >> s;
rep(i, n - 1) {
if (s[i] == 'A' && s[i + 1] == 'B')
ans++;
}
if (s[0] == 'B' && s.back() == 'A')
x++;
else if (s[0] == 'B')
y++;
else if (s.back() == 'A')
z++;
}
if (y == 0 && z == 0) {
ans += max(x - 1, 0LL);
} else if (y == z) {
ans += x + y;
} else if (y > z) {
ans += x + min(y, z);
} else if (y < z)
ans += x + min(y, z);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
#define INF 1LL << 30
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(), (x).end()
int main() {
ll n;
cin >> n;
ll ans = 0, x = 0, y = 0, z = 0;
rep(i, n) {
string s;
cin >> s;
rep(i, s.size()) {
if (s[i] == 'A' && s[i + 1] == 'B')
ans++;
}
if (s[0] == 'B' && s.back() == 'A')
x++;
else if (s[0] == 'B')
y++;
else if (s.back() == 'A')
z++;
}
if (y == 0 && z == 0) {
ans += max(x - 1, 0LL);
} else if (y == z) {
ans += x + y;
} else if (y > z) {
ans += x + min(y, z);
} else if (y < z)
ans += x + min(y, z);
cout << ans << endl;
}
| [
"call.add"
] | 865,581 | 865,582 | u633967774 | cpp |
p03049 | #include <bits/stdc++.h>
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define len(x) ((long long)(x).size())
#define lcm(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using vc = vector<char>;
using pll = pair<ll, ll>;
template <class T> void print1d(T x, ll n = -1) {
if (n == -1)
n = x.size();
rep(i, 0, n) { cout << x[i] << ' '; }
cout << '\n';
}
template <class T> void print2d(T x, ll r = -1, ll c = -1) {
if (r == -1)
r = x.size();
if (c == -1)
c = x[0].size();
rep(i, 0, r) print1d(x[i], c);
}
template <class T, class U> bool haskey(T mp, U key) {
return mp.find(key) != mp.end();
}
template <class T, class U> bool isin(T el, U container) {
return find(all(container), el) != container.end();
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> bool even(T n) { return !(n & 1); }
template <class T> bool odd(T n) { return n & 1; }
template <class T> ll rup(T a, T b) { return a % b ? a / b + 1 : a / b; }
template <class T> ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template <class T> ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
const long double pi = M_PI;
const long long big = 1LL << 50;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;
ll intpow(ll a, ll n, ll _mod = numeric_limits<ll>::max()) {
ll p = 1;
while (n) {
if (n & 1)
p = p * a % _mod;
a = a * a % _mod;
n >>= 1;
}
return p;
}
ll modc(ll a, char op, ll b, ll _mod = mod) {
a %= _mod;
b %= _mod;
ll res = 1;
switch (op) {
case '+':
res = (a + b) % _mod;
break;
case '-':
res = (a - b) % _mod;
break;
case '*':
res = a * b % _mod;
break;
case '/':
res = modc(a, '*', modc(b, '^', _mod - 2, _mod), _mod);
break;
case '^':
res = intpow(a, b, _mod);
break;
case 'P':
rep(i, a - b + 1, a + 1) res = modc(res, '*', i, _mod);
break;
case 'C':
res = modc(modc(a, 'P', b, _mod), '/', modc(b, 'P', b, _mod));
break;
}
if (res < 0)
res += _mod;
return res;
}
int main() {
ll N;
cin >> N;
ll ra = 0, lb = 0;
ll ans = 0;
// ll tmp = 0;
vector<string> s(N);
ll both = 0;
rep(i, 0, N) {
string x;
cin >> x;
s[i] = x;
rep(j, 0, len(x) - 1) {
if (x[j] == 'A' and x[j + 1] == 'B')
++ans;
}
if (x[0] == 'B' and x[len(x) - 1] == 'A') {
++both;
}
if (x[0] == 'B')
++lb;
if (x[len(x) - 1] == 'A')
++ra;
// ll ac, bc = 0;
// rep(j, 0, len(x)) {
// if (x[j] == 'A') ++ac;
// if (x[j] == 'B') ++bc;
// }
// if (ac >= 1 and bc >= 1) ans += min(ac, bc);
// if (ac > bc) acnt += ac;
// else bcnt += bc;
}
// cout << ra << ' ' << lb << endl;
if (both == 0) {
cout << ans + min(lb, ra) << endl;
// return 0;
} else if (lb + ra > 0) {
cout << ans + min(lb, ra) << endl;
} else {
cout << ans + both - 1 << endl;
}
// ans += min(min(ra, lb), N-1);
// cout << ans << endl;
}
| #include <bits/stdc++.h>
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define len(x) ((long long)(x).size())
#define lcm(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using vc = vector<char>;
using pll = pair<ll, ll>;
template <class T> void print1d(T x, ll n = -1) {
if (n == -1)
n = x.size();
rep(i, 0, n) { cout << x[i] << ' '; }
cout << '\n';
}
template <class T> void print2d(T x, ll r = -1, ll c = -1) {
if (r == -1)
r = x.size();
if (c == -1)
c = x[0].size();
rep(i, 0, r) print1d(x[i], c);
}
template <class T, class U> bool haskey(T mp, U key) {
return mp.find(key) != mp.end();
}
template <class T, class U> bool isin(T el, U container) {
return find(all(container), el) != container.end();
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> bool even(T n) { return !(n & 1); }
template <class T> bool odd(T n) { return n & 1; }
template <class T> ll rup(T a, T b) { return a % b ? a / b + 1 : a / b; }
template <class T> ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template <class T> ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
const long double pi = M_PI;
const long long big = 1LL << 50;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;
ll intpow(ll a, ll n, ll _mod = numeric_limits<ll>::max()) {
ll p = 1;
while (n) {
if (n & 1)
p = p * a % _mod;
a = a * a % _mod;
n >>= 1;
}
return p;
}
ll modc(ll a, char op, ll b, ll _mod = mod) {
a %= _mod;
b %= _mod;
ll res = 1;
switch (op) {
case '+':
res = (a + b) % _mod;
break;
case '-':
res = (a - b) % _mod;
break;
case '*':
res = a * b % _mod;
break;
case '/':
res = modc(a, '*', modc(b, '^', _mod - 2, _mod), _mod);
break;
case '^':
res = intpow(a, b, _mod);
break;
case 'P':
rep(i, a - b + 1, a + 1) res = modc(res, '*', i, _mod);
break;
case 'C':
res = modc(modc(a, 'P', b, _mod), '/', modc(b, 'P', b, _mod));
break;
}
if (res < 0)
res += _mod;
return res;
}
int main() {
ll N;
cin >> N;
ll ra = 0, lb = 0;
ll ans = 0;
// ll tmp = 0;
vector<string> s(N);
ll both = 0;
rep(i, 0, N) {
string x;
cin >> x;
s[i] = x;
rep(j, 0, len(x) - 1) {
if (x[j] == 'A' and x[j + 1] == 'B')
++ans;
}
if (x[0] == 'B' and x[len(x) - 1] == 'A') {
++both;
} else if (x[0] == 'B')
++lb;
else if (x[len(x) - 1] == 'A')
++ra;
// ll ac, bc = 0;
// rep(j, 0, len(x)) {
// if (x[j] == 'A') ++ac;
// if (x[j] == 'B') ++bc;
// }
// if (ac >= 1 and bc >= 1) ans += min(ac, bc);
// if (ac > bc) acnt += ac;
// else bcnt += bc;
}
// cout << both << ' ' << ra << ' ' << lb << endl;
if (both == 0) {
cout << ans + min(lb, ra) << endl;
// return 0;
} else if (lb + ra > 0) {
cout << ans + both + min(lb, ra) << endl;
} else {
cout << ans + both - 1 << endl;
}
// ans += min(min(ra, lb), N-1);
// cout << ans << endl;
}
| [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 865,585 | 865,586 | u976940619 | cpp |
p03049 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
long long T = 0, c1 = 0, c2 = 0, c3 = 0;
for (int i = 0; i < N; ++i) {
string S;
cin >> S;
for (int j = 0; j + 1 < S.size(); ++j) {
if (S[j] == 'A' && S[j + 1] == 'B')
++T;
}
if (S[0] == 'B' && S.back() == 'A')
++c1;
else if (S.back() == 'A')
++c2;
else if (S[0] == 'B')
++c3;
}
if (c2 == 0 && c3 == 0)
cout << T + c1 - 1 << endl;
else
cout << T + c1 + min(c2, c3) << endl;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
long long T = 0, c1 = 0, c2 = 0, c3 = 0;
for (int i = 0; i < N; ++i) {
string S;
cin >> S;
for (int j = 0; j + 1 < S.size(); ++j) {
if (S[j] == 'A' && S[j + 1] == 'B')
++T;
}
if (S[0] == 'B' && S.back() == 'A')
++c1;
else if (S.back() == 'A')
++c2;
else if (S[0] == 'B')
++c3;
}
if (c2 == 0 && c3 == 0)
cout << T + max(c1 - 1, 0LL) << endl;
else
cout << T + c1 + min(c2, c3) << endl;
} | [
"call.add",
"call.arguments.add"
] | 865,593 | 865,594 | u692336506 | cpp |
p03049 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
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;
}
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template <class T, class V>
typename enable_if<is_class<T>::value == 0>::type fill(T &t, const V &v) {
t = v;
}
template <class T, class V>
typename enable_if<is_class<T>::value != 0>::type fill(T &t, const V &v) {
for (auto &e : t)
fill(e, v);
}
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
template <class T1, class T2> ostream &operator<<(ostream &s, pair<T1, T2> P) {
return s << '<' << P.first << ", " << P.second << '>';
}
template <class T> ostream &operator<<(ostream &s, vector<T> P) {
for (int i = 0; i < P.size(); ++i) {
if (i > 0) {
s << " ";
}
s << P[i];
}
return s;
}
template <class T> ostream &operator<<(ostream &s, vector<vector<T>> P) {
for (int i = 0; i < P.size(); ++i) {
s << endl << P[i];
}
return s << endl;
}
#define EACH(i, s) \
for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
template <class T> ostream &operator<<(ostream &s, set<T> P) {
EACH(it, P) { s << "<" << *it << "> "; }
return s << endl;
}
template <class T1, class T2> ostream &operator<<(ostream &s, map<T1, T2> P) {
EACH(it, P) { s << "<" << it->first << "->" << it->second << "> "; }
return s << endl;
}
int count(const string &S) {
int res = 0;
for (int i = 0; i + 1 < S.size(); ++i) {
if (S[i] == 'A' && S[i + 1] == 'B')
++res;
}
return res;
}
int N;
vector<string> S;
long long solve() {
long long res = 0;
for (int i = 0; i < N; ++i)
res += count(S[i]);
int a = 0, b = 0, c = 0;
for (int i = 0; i < N; ++i) {
if (S[i][0] == 'B' && S[i].back() == 'A')
++a;
else if (S[i].back() == 'A')
++b;
else if (S[i][0] == 'B')
++c;
}
long long add = 0;
if (b + c == 0)
add = a - 1;
else
add = a + min(b, c);
// COUT(a); COUT(b); COUT(c); COUT(add);
res += add;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
while (cin >> N) {
S.resize(N);
for (int i = 0; i < N; ++i)
cin >> S[i];
cout << solve() << endl;
}
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
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;
}
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template <class T, class V>
typename enable_if<is_class<T>::value == 0>::type fill(T &t, const V &v) {
t = v;
}
template <class T, class V>
typename enable_if<is_class<T>::value != 0>::type fill(T &t, const V &v) {
for (auto &e : t)
fill(e, v);
}
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
template <class T1, class T2> ostream &operator<<(ostream &s, pair<T1, T2> P) {
return s << '<' << P.first << ", " << P.second << '>';
}
template <class T> ostream &operator<<(ostream &s, vector<T> P) {
for (int i = 0; i < P.size(); ++i) {
if (i > 0) {
s << " ";
}
s << P[i];
}
return s;
}
template <class T> ostream &operator<<(ostream &s, vector<vector<T>> P) {
for (int i = 0; i < P.size(); ++i) {
s << endl << P[i];
}
return s << endl;
}
#define EACH(i, s) \
for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
template <class T> ostream &operator<<(ostream &s, set<T> P) {
EACH(it, P) { s << "<" << *it << "> "; }
return s << endl;
}
template <class T1, class T2> ostream &operator<<(ostream &s, map<T1, T2> P) {
EACH(it, P) { s << "<" << it->first << "->" << it->second << "> "; }
return s << endl;
}
int count(const string &S) {
int res = 0;
for (int i = 0; i + 1 < S.size(); ++i) {
if (S[i] == 'A' && S[i + 1] == 'B')
++res;
}
return res;
}
int N;
vector<string> S;
long long solve() {
long long res = 0;
for (int i = 0; i < N; ++i)
res += count(S[i]);
int a = 0, b = 0, c = 0;
for (int i = 0; i < N; ++i) {
if (S[i][0] == 'B' && S[i].back() == 'A')
++a;
else if (S[i].back() == 'A')
++b;
else if (S[i][0] == 'B')
++c;
}
long long add = 0;
if (b + c == 0)
add = max(0, a - 1);
else
add = a + min(b, c);
// COUT(a); COUT(b); COUT(c); COUT(add);
res += add;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
while (cin >> N) {
S.resize(N);
for (int i = 0; i < N; ++i)
cin >> S[i];
cout << solve() << endl;
}
}
| [
"call.add",
"call.arguments.change"
] | 865,595 | 865,596 | u692336506 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int hmAB(string s) {
int c = 0;
for (int i = 0; i < s.size() - 1; i++) {
if (s.at(i) == 'A' && s.at(i + 1) == 'B')
c++;
}
return c;
}
int main() {
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++)
cin >> s.at(i);
int Bxx = 0, xxA = 0, BxA = 0;
for (int i = 0; i < N; i++) {
if (s.at(i).at(0) == 'B') {
if (s.at(i).at(s.at(i).size() - 1) == 'A')
BxA++;
else
Bxx++;
} else if (s.at(i).at(s.at(i).size() - 1) == 'A')
xxA++;
}
int ans = 0;
for (int i = 0; i < N; i++)
ans += hmAB(s.at(i));
if (xxA > 0)
while (BxA > 0) {
ans++;
BxA--;
}
else if (Bxx > 0)
while (BxA > 0) {
ans++;
BxA--;
}
else {
ans += BxA - 1;
}
ans += min(xxA, Bxx);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int hmAB(string s) {
int c = 0;
for (int i = 0; i < s.size() - 1; i++) {
if (s.at(i) == 'A' && s.at(i + 1) == 'B')
c++;
}
return c;
}
int main() {
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++)
cin >> s.at(i);
int Bxx = 0, xxA = 0, BxA = 0;
for (int i = 0; i < N; i++) {
if (s.at(i).at(0) == 'B') {
if (s.at(i).at(s.at(i).size() - 1) == 'A')
BxA++;
else
Bxx++;
} else if (s.at(i).at(s.at(i).size() - 1) == 'A')
xxA++;
}
int ans = 0;
for (int i = 0; i < N; i++)
ans += hmAB(s.at(i));
if (xxA > 0)
while (BxA > 0) {
ans++;
BxA--;
}
else if (Bxx > 0)
while (BxA > 0) {
ans++;
BxA--;
}
else if (BxA > 0) {
ans += BxA - 1;
}
ans += min(xxA, Bxx);
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.add"
] | 865,597 | 865,598 | u714642046 | cpp |
p03049 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define FORR(i, a, b) for (int i = b - 1; i >= a; --i)
#define SORT(v) sort(v.begin(), v.end())
#define SORTR(v) sort(v.rbegin(), v.rend())
#define REV(v) reverse(v.begin(), v.end())
#define ITER(itr, v) for (auto itr = v.begin(); itr != v.end(); ++itr)
#define LB(v, x) (lower_bound(v.begin(), v.end(), x) - v.begin())
#define UB(v, x) (upper_bound(v.begin(), v.end(), x) - v.begin())
#define SZ(v) (int)v.size()
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<string> S(N);
int res = 0;
int front = 0, back = 0, front_back = 0;
REP(i, N) {
cin >> S[i];
REP(j, S[i].size() - 1) { res += S[i].substr(j, 2) == "AB"; }
if (S[i].front() == 'B') {
if (S[i].back() == 'A') {
++front_back;
} else {
++front;
}
} else if (S[i].back() == 'A') {
++back;
}
}
if (front_back > 0) {
if (front + back == 0) {
res += front_back - 1;
} else {
res += front_back + min(front, back);
}
} else {
res = min(front, back);
}
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define FORR(i, a, b) for (int i = b - 1; i >= a; --i)
#define SORT(v) sort(v.begin(), v.end())
#define SORTR(v) sort(v.rbegin(), v.rend())
#define REV(v) reverse(v.begin(), v.end())
#define ITER(itr, v) for (auto itr = v.begin(); itr != v.end(); ++itr)
#define LB(v, x) (lower_bound(v.begin(), v.end(), x) - v.begin())
#define UB(v, x) (upper_bound(v.begin(), v.end(), x) - v.begin())
#define SZ(v) (int)v.size()
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<string> S(N);
int res = 0;
int front = 0, back = 0, front_back = 0;
REP(i, N) {
cin >> S[i];
REP(j, S[i].size() - 1) { res += S[i].substr(j, 2) == "AB"; }
if (S[i].front() == 'B') {
if (S[i].back() == 'A') {
++front_back;
} else {
++front;
}
} else if (S[i].back() == 'A') {
++back;
}
}
if (front_back > 0) {
if (front + back == 0) {
res += front_back - 1;
} else {
res += front_back + min(front, back);
}
} else {
res += min(front, back);
}
cout << res << endl;
return 0;
}
| [
"assignment.value.change"
] | 865,601 | 865,602 | u285991898 | cpp |
p03049 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
string s[N];
for (int i = 0; i < N; i++) {
cin >> s[i];
}
int ans = 0, acount = 0, bcount = 0, abcount = 0;
for (int i = 0; i < N; i++) {
if (s[i][0] == 'B') {
bcount++;
}
if (s[i][s[i].size() - 1] == 'A') {
acount++;
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
abcount++;
}
while (s[i].find("AB") != string::npos) {
int p = s[i].find("AB");
s[i] = s[i].substr(p + 2);
ans++;
}
}
if (acount < bcount) {
ans += acount;
} else {
if (abcount == bcount && abcount == acount) {
ans += bcount - 1;
} else {
ans += bcount;
}
}
printf("%d\n", ans);
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
string s[N];
for (int i = 0; i < N; i++) {
cin >> s[i];
}
int ans = 0, acount = 0, bcount = 0, abcount = 0;
for (int i = 0; i < N; i++) {
if (s[i][0] == 'B') {
bcount++;
}
if (s[i][s[i].size() - 1] == 'A') {
acount++;
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
abcount++;
}
while (s[i].find("AB") != string::npos) {
int p = s[i].find("AB");
s[i] = s[i].substr(p + 2);
ans++;
}
}
if (acount < bcount) {
ans += acount;
} else {
if (abcount != 0 && abcount == bcount && abcount == acount) {
ans += bcount - 1;
} else {
ans += bcount;
}
}
printf("%d\n", ans);
}
| [
"control_flow.branch.if.condition.change"
] | 865,603 | 865,604 | u154904553 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
vector<string> s(N);
int output = 0;
int a = 0;
int b = 0;
int both = 0;
for (int i = 0; i < N; i++) {
cin >> s[i];
for (int j = 0; j < s[i].length() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
output++;
}
if (s[i][0] == 'B')
b++;
if (s[i][s[i].length() - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][s[i].length() - 1] == 'A')
both++;
}
if (a == both && b == both) {
a--;
}
cout << output + min(a, b) << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
vector<string> s(N);
int output = 0;
int a = 0;
int b = 0;
int both = 0;
for (int i = 0; i < N; i++) {
cin >> s[i];
for (int j = 0; j < s[i].length() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
output++;
}
if (s[i][0] == 'B')
b++;
if (s[i][s[i].length() - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][s[i].length() - 1] == 'A')
both++;
}
if (a == both && b == both && both != 0) {
a--;
}
cout << output + min(a, b) << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 865,605 | 865,606 | u412408615 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<int, int>;
int main() {
int n, b = 0, a = 0, ba = 0;
cin >> n;
int ans = 0;
rep(i, n) {
string s;
cin >> s;
for (int i = 0; i < n - 1; ++i) {
if (s[i] == 'A' && s[i + 1] == 'B')
ans++;
}
if (s[0] == 'B' && s[s.size() - 1] == 'A')
ba++;
else if (s[s.size() - 1] == 'A')
a++;
else if (s[0] == 'B')
b++;
}
ans += min(a + ba, b + ba);
if (a == 0 && b == 0 && ba > 0)
ans--;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<int, int>;
int main() {
int n, b = 0, a = 0, ba = 0;
cin >> n;
int ans = 0;
rep(i, n) {
string s;
cin >> s;
for (int i = 0; i < s.size() - 1; ++i) {
if (s[i] == 'A' && s[i + 1] == 'B')
ans++;
}
if (s[0] == 'B' && s[s.size() - 1] == 'A')
ba++;
else if (s[s.size() - 1] == 'A')
a++;
else if (s[0] == 'B')
b++;
}
ans += min(a + ba, b + ba);
if (a == 0 && b == 0 && ba > 0)
ans--;
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"call.add"
] | 865,610 | 865,611 | u074488832 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<long long, long long> P;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define agewari(a, b) ((ll)a + ((ll)b - 1)) / b
const int MOD = 1000000007;
const long long INF = 1LL << 60;
int main() {
ll n;
cin >> n;
ll xa = 0;
ll bx = 0;
ll bxa = 0;
ll ab = 0;
rep(i, n) {
string s;
cin >> s;
ll l = s.length();
if (s[0] == 'B' && s[l - 1] == 'A')
bxa++;
else if (s[l - 1] == 'A')
xa++;
else if (s[0] == 'B')
bx++;
for (int j = 0; j <= l - 2; j++) {
string tmp;
tmp = s.substr(j, 2);
if (tmp == "AB")
ab++;
}
}
if (xa + bx == 0)
cout << ab + bxa - 1 << endl;
else
cout << ab + min(xa, bx) + bxa << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<long long, long long> P;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define agewari(a, b) ((ll)a + ((ll)b - 1)) / b
const int MOD = 1000000007;
const long long INF = 1LL << 60;
int main() {
ll n;
cin >> n;
ll xa = 0;
ll bx = 0;
ll bxa = 0;
ll ab = 0;
rep(i, n) {
string s;
cin >> s;
ll l = s.length();
if (s[0] == 'B' && s[l - 1] == 'A')
bxa++;
else if (s[l - 1] == 'A')
xa++;
else if (s[0] == 'B')
bx++;
for (int j = 0; j <= l - 2; j++) {
string tmp;
tmp = s.substr(j, 2);
if (tmp == "AB")
ab++;
}
}
if (xa + bx == 0 && bxa != 0)
cout << ab + bxa - 1 << endl;
else
cout << ab + min(xa, bx) + bxa << endl;
} | [
"control_flow.branch.if.condition.change"
] | 865,614 | 865,615 | u650236619 | cpp |
p03049 | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespace std;
using ll = long long;
typedef pair<ll, ll> p;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const long long mod = 1e9 + 7;
ll gcd(ll a, ll b);
ll lcm(ll a, ll b);
int main() {
ll N;
cin >> N;
string S;
ll cnt = 0, cnt1 = 0, cnt2 = 0, ans = 0;
rep(i, N) {
cin >> S;
if (S[0] == 'B' && S[S.size() - 1] == 'A')
cnt++;
else if (S[S.size() - 1] == 'A')
cnt1++;
else if (S[0] == 'B')
cnt2++;
rep(i, S.size() - 1) {
if (S[i] == 'A' && S[i + 1] == 'B') {
ans++;
}
}
}
if (cnt1 + cnt2 > 0)
ans += cnt + min(cnt1, cnt2);
else
ans += min(cnt - 1, cnt * 0);
cout << max(ans, ans * 0);
return 0;
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); } | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespace std;
using ll = long long;
typedef pair<ll, ll> p;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const long long mod = 1e9 + 7;
ll gcd(ll a, ll b);
ll lcm(ll a, ll b);
int main() {
ll N;
cin >> N;
string S;
ll cnt = 0, cnt1 = 0, cnt2 = 0, ans = 0;
rep(i, N) {
cin >> S;
if (S[0] == 'B' && S[S.size() - 1] == 'A')
cnt++;
else if (S[S.size() - 1] == 'A')
cnt1++;
else if (S[0] == 'B')
cnt2++;
rep(i, S.size() - 1) {
if (S[i] == 'A' && S[i + 1] == 'B') {
ans++;
}
}
}
if (cnt1 + cnt2 > 0)
ans += cnt + min(cnt1, cnt2);
else
ans += max(cnt - 1, cnt * 0);
cout << max(ans, ans * 0);
return 0;
}
ll gcd(ll a, ll b) {
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); } | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 865,616 | 865,617 | u401139594 | cpp |
p03049 | #include "bits/stdc++.h"
#include "math.h"
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vin;
typedef pair<ll, ll> P;
typedef vector<P> vp;
#define rep(i, a, b) for (ll i = (a); i < (b); ++i)
#define drep(i, a, b) for (ll i = (a); i >= (b); --i)
#define SIZE(a) ll((a).size())
#define out(a) cout << (a) << endl;
const int inf = INT_MAX;
const int MAX = 510000;
const ll MOD = 998244353;
int main() {
ll n;
cin >> n;
ll ans = 0, a = 0, b = 0, both = 0;
rep(i, 0, n) {
string s;
cin >> s;
rep(j, 0, s.size() - 1) {
if (s.size() == 1)
break;
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
if (s[0] == 'B' && s[s.size() - 1] == 'A')
both++;
else if (s[s.size() - 1] == 'A')
a++;
else if (s[0] == 'B')
b++;
}
if (a == 0 && b == 0) {
cout << ans + both - 1 << endl;
return 0;
}
cout << ans + min(n - 1, both + min(a, b)) << endl;
}
| #include "bits/stdc++.h"
#include "math.h"
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vin;
typedef pair<ll, ll> P;
typedef vector<P> vp;
#define rep(i, a, b) for (ll i = (a); i < (b); ++i)
#define drep(i, a, b) for (ll i = (a); i >= (b); --i)
#define SIZE(a) ll((a).size())
#define out(a) cout << (a) << endl;
const int inf = INT_MAX;
const int MAX = 510000;
const ll MOD = 998244353;
int main() {
ll n;
cin >> n;
ll ans = 0, a = 0, b = 0, both = 0;
rep(i, 0, n) {
string s;
cin >> s;
rep(j, 0, s.size() - 1) {
if (s.size() == 1)
break;
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
if (s[0] == 'B' && s[s.size() - 1] == 'A')
both++;
else if (s[s.size() - 1] == 'A')
a++;
else if (s[0] == 'B')
b++;
}
if (a == 0 && b == 0 && both != 0) {
cout << ans + both - 1 << endl;
return 0;
}
cout << ans + min(n - 1, both + min(a, b)) << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 865,620 | 865,621 | u476488060 | cpp |
p03049 | #include <bits/stdc++.h>
#define ll long long
#define MODV 1000000007
#define INFLL LLONG_MAX // 9223372036854775807
#define EPS 1e-9
#define rep(i, n) for (ll i = 0, i##_len = (ll)(n); i < i##_len; i++)
#define repf(i, n) for (ll i = 1, i##_len = (ll)(n + 1); i < i##_len; i++)
#define all(v) v.begin(), v.end()
#define endl "\n"
#define vi vector<ll>
#define vvi vector<vector<ll>>
#define Yes() cout << "Yes" << endl
#define YES() cout << "YES" << endl
#define No() cout << "No" << endl
#define NO() cout << "NO" << endl
#define Init() \
std::ios::sync_with_stdio(false); \
std::cin.tie(0); \
std::cout << fixed << setprecision(15);
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using namespace std;
int main() {
Init();
ll n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
// 各文字列に含まれる"AB"の数を数える
vector<ll> cnt(n);
rep(i, n) {
for (ll pos = 0; pos < s[i].size() - 1; pos++) {
if (s[i][pos] == 'A' && s[i][pos + 1] == 'B')
cnt[i]++, pos++;
}
}
ll ans = 0;
ll bCnt = 0, aCnt = 0, abCnt = 0;
rep(i, n) {
ans += cnt[i];
if (s[i][0] == 'B')
(s[i][s[i].size() - 1] == 'A') ? abCnt++ : bCnt++;
else if (s[i][s[i].size() - 1] == 'A')
abCnt++;
}
cout << ans + (aCnt + bCnt == 0 && abCnt > 0 ? abCnt - 1
: abCnt + min(aCnt, bCnt))
<< endl;
} | #include <bits/stdc++.h>
#define ll long long
#define MODV 1000000007
#define INFLL LLONG_MAX // 9223372036854775807
#define EPS 1e-9
#define rep(i, n) for (ll i = 0, i##_len = (ll)(n); i < i##_len; i++)
#define repf(i, n) for (ll i = 1, i##_len = (ll)(n + 1); i < i##_len; i++)
#define all(v) v.begin(), v.end()
#define endl "\n"
#define vi vector<ll>
#define vvi vector<vector<ll>>
#define Yes() cout << "Yes" << endl
#define YES() cout << "YES" << endl
#define No() cout << "No" << endl
#define NO() cout << "NO" << endl
#define Init() \
std::ios::sync_with_stdio(false); \
std::cin.tie(0); \
std::cout << fixed << setprecision(15);
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using namespace std;
int main() {
Init();
ll n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
// 各文字列に含まれる"AB"の数を数える
vector<ll> cnt(n);
rep(i, n) {
for (ll pos = 0; pos < s[i].size() - 1; pos++) {
if (s[i][pos] == 'A' && s[i][pos + 1] == 'B')
cnt[i]++, pos++;
}
}
ll ans = 0;
ll bCnt = 0, aCnt = 0, abCnt = 0;
rep(i, n) {
ans += cnt[i];
if (s[i][0] == 'B')
(s[i][s[i].size() - 1] == 'A') ? abCnt++ : bCnt++;
else if (s[i][s[i].size() - 1] == 'A')
aCnt++;
}
cout << ans + (aCnt + bCnt == 0 && abCnt > 0 ? abCnt - 1
: abCnt + min(aCnt, bCnt))
<< endl;
} | [
"identifier.change"
] | 865,622 | 865,623 | u548791035 | cpp |
p03049 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e18;
const ll MAX_N = 201010;
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
char notes[110][10];
// long longしか使わない
//素数は1より大きい
// lower_boundは指定したkey以上の要素の一番左のイテレータをかえす
// upper_boundは指定したkeyより大きい要素の一番左のイテレータをかえす
int main() {
ll n;
cin >> n;
vector<string> s(n);
ll ans = 0;
ll a = 0, b = 0, c = 0;
rep(i, n) {
cin >> s[i];
ll k = s[i].length();
rep(j, k - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
if (s[i][0] == 'B')
b++;
if (s[i][k - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][k - 1] == 'A')
c++;
}
if (a == b && b == c)
a--;
ans += min(a, b);
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e18;
const ll MAX_N = 201010;
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
char notes[110][10];
// long longしか使わない
//素数は1より大きい
// lower_boundは指定したkey以上の要素の一番左のイテレータをかえす
// upper_boundは指定したkeyより大きい要素の一番左のイテレータをかえす
int main() {
ll n;
cin >> n;
vector<string> s(n);
ll ans = 0;
ll a = 0, b = 0, c = 0;
rep(i, n) {
cin >> s[i];
ll k = s[i].length();
rep(j, k - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
if (s[i][0] == 'B')
b++;
if (s[i][k - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][k - 1] == 'A')
c++;
}
if (a == b && b == c && a != 0)
a--;
ans += min(a, b);
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 865,626 | 865,627 | u631558039 | cpp |
p03049 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e10;
const ll MAX_N = 1010;
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
ll dp[201010][2];
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
// long longしか使わない
//素数は1より大きい
int main() {
ll n;
cin >> n;
vector<string> s(n);
ll ans = 0;
ll b = 0;
ll a = 0;
ll c = 0;
rep(i, n) {
cin >> s[i];
ll k = s[i].length();
rep(j, k - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
if (s[i][0] == 'B')
b++;
if (s[i][k - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][k - 1] == 'A')
c++;
}
ll res = min(a, b);
ans += res;
if (a == b && b == c)
ans--;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.10f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e10;
const ll MAX_N = 1010;
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
ll dp[201010][2];
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
// long longしか使わない
//素数は1より大きい
int main() {
ll n;
cin >> n;
vector<string> s(n);
ll ans = 0;
ll b = 0;
ll a = 0;
ll c = 0;
rep(i, n) {
cin >> s[i];
ll k = s[i].length();
rep(j, k - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
if (s[i][0] == 'B')
b++;
if (s[i][k - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][k - 1] == 'A')
c++;
}
ll res = min(a, b);
ans += res;
if (a == b && b == c && a != 0)
ans--;
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 865,628 | 865,629 | u631558039 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> s(N + 10);
int Acnt = 0;
int Bcnt = 0;
int both = 0;
for (int i = 0; i < N; i++) {
cin >> s[i];
int l = s[i].size() - 1;
if (s[i][l] == 'A' && s[i][0] == 'B')
both++;
else {
if (s[i][l] == 'A')
Acnt++;
if (s[i][0] == 'B')
Bcnt++;
}
}
int ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < (int)s[i].size(); j++) {
string tmp = "";
for (int k = j; (k < j + 2 && k < (int)s[i].size()); k++)
tmp += s[i][k];
if (tmp == "AB")
ans++;
}
}
if (Acnt == 0 && Bcnt == 0)
ans = max(both - 1, 0);
else
ans = both + min(Acnt, Bcnt);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> s(N + 10);
int Acnt = 0;
int Bcnt = 0;
int both = 0;
for (int i = 0; i < N; i++) {
cin >> s[i];
int l = s[i].size() - 1;
if (s[i][l] == 'A' && s[i][0] == 'B')
both++;
else {
if (s[i][l] == 'A')
Acnt++;
if (s[i][0] == 'B')
Bcnt++;
}
}
int ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < (int)s[i].size(); j++) {
string tmp = "";
for (int k = j; (k < j + 2 && k < (int)s[i].size()); k++)
tmp += s[i][k];
if (tmp == "AB")
ans++;
}
}
if (Acnt == 0 && Bcnt == 0)
ans += max(both - 1, 0);
else
ans += both + min(Acnt, Bcnt);
cout << ans << endl;
return 0;
} | [
"assignment.value.change"
] | 865,632 | 865,633 | u843292252 | cpp |
p03049 | // {{{ by unolight
#include <bits/stdc++.h>
#include <unistd.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
#define SZ(x) ((int)(x).size())
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define REP1(i, a, b) for (int i = (a); i <= int(b); i++)
#define MP make_pair
#define PB push_back
using namespace std;
typedef int64_t LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
namespace {
namespace unolight {
// Read Input
template <class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%" PRId64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U> void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
// Write Output
template <class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%" PRId64, x); }
void _W(const double &x) { printf("%.16f\n", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T> void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin())
putchar(' ');
}
void W() {}
template <class T, class... U> void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
#ifdef UNOLIGHT
#include "dump.hpp"
#else
#define dump(...)
#endif
template <class T> inline bool chmax(T &a, const T &b) {
return b > a ? a = b, true : false;
}
template <class T> inline bool chmin(T &a, const T &b) {
return b < a ? a = b, true : false;
}
template <class T> using MaxHeap = priority_queue<T>;
template <class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template <class T, class F = less<T>> void sort_uniq(vector<T> &v, F f = F()) {
sort(begin(v), end(v), f);
v.resize(unique(begin(v), end(v)) - begin(v));
}
// }}}
void main() {
int n, ans = 0, a = 0, b = 0, ab = 0;
R(n);
string s;
REP(i, n) {
cin >> s;
REP(j, SZ(s) - 1) if (s[j] == 'A' && s[j + 1] == 'B') ans++;
if (s[0] == 'B' && s.back() == 'A')
ab++;
else if (s[0] == 'B')
b++;
else if (s.back() == 'A')
a++;
}
if (a || b)
ans = ab + min(a, b);
else
ans = max(ab - 1, 0);
W(ans);
}
} // namespace unolight
} // namespace
int main() {
unolight::main();
return 0;
}
// }}} | // {{{ by unolight
#include <bits/stdc++.h>
#include <unistd.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
#define SZ(x) ((int)(x).size())
#define ALL(x) begin(x), end(x)
#define RALL(x) rbegin(x), rend(x)
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define REP1(i, a, b) for (int i = (a); i <= int(b); i++)
#define MP make_pair
#define PB push_back
using namespace std;
typedef int64_t LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
namespace {
namespace unolight {
// Read Input
template <class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%" PRId64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U> void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
// Write Output
template <class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%" PRId64, x); }
void _W(const double &x) { printf("%.16f\n", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T> void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin())
putchar(' ');
}
void W() {}
template <class T, class... U> void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
#ifdef UNOLIGHT
#include "dump.hpp"
#else
#define dump(...)
#endif
template <class T> inline bool chmax(T &a, const T &b) {
return b > a ? a = b, true : false;
}
template <class T> inline bool chmin(T &a, const T &b) {
return b < a ? a = b, true : false;
}
template <class T> using MaxHeap = priority_queue<T>;
template <class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template <class T, class F = less<T>> void sort_uniq(vector<T> &v, F f = F()) {
sort(begin(v), end(v), f);
v.resize(unique(begin(v), end(v)) - begin(v));
}
// }}}
void main() {
int n, ans = 0, a = 0, b = 0, ab = 0;
R(n);
string s;
REP(i, n) {
cin >> s;
REP(j, SZ(s) - 1) if (s[j] == 'A' && s[j + 1] == 'B') ans++;
if (s[0] == 'B' && s.back() == 'A')
ab++;
else if (s[0] == 'B')
b++;
else if (s.back() == 'A')
a++;
}
if (a || b)
ans += ab + min(a, b);
else
ans += max(ab - 1, 0);
W(ans);
}
} // namespace unolight
} // namespace
int main() {
unolight::main();
return 0;
}
// }}} | [
"assignment.value.change"
] | 865,644 | 865,645 | u385825353 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#include <iomanip>
#include <math.h>
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;
}
vector<pair<int64_t, int64_t>> prime_factorize(int64_t x) {
vector<pair<int64_t, int64_t>> p;
for (int64_t i = 2; i * i <= x; i++) {
int cnt = 0;
if (x % i == 0) {
while (x % i == 0) {
cnt++;
x /= i;
}
p.push_back(make_pair(i, cnt));
}
}
if (x != 1) {
p.push_back(make_pair(x, 1));
}
return p;
}
const int INF = 1001001001;
int main() {
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++) {
cin >> s[i];
}
int cnt = 0, cntA = 0, cntB = 0, cntBA = 0;
for (int i = 0; i < N; i++) {
int ni = s[i].size();
if (s[i].back() == 'A' && s[i].front() == 'B') {
cntBA++;
} else if (s[i].back() == 'A') {
cntA++;
} else if (s[i].front() == 'B') {
cntB++;
}
for (int j = 0; j < ni; j++) {
if (s[i].substr(j, 2) == "AB") {
cnt++;
}
}
}
if (cntA == 0 && cntB == 0) {
cout << cnt + cntBA - 1 << endl;
} else {
cout << cnt + min(cntBA + cntA, cntBA + cntB) << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <iomanip>
#include <math.h>
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;
}
vector<pair<int64_t, int64_t>> prime_factorize(int64_t x) {
vector<pair<int64_t, int64_t>> p;
for (int64_t i = 2; i * i <= x; i++) {
int cnt = 0;
if (x % i == 0) {
while (x % i == 0) {
cnt++;
x /= i;
}
p.push_back(make_pair(i, cnt));
}
}
if (x != 1) {
p.push_back(make_pair(x, 1));
}
return p;
}
const int INF = 1001001001;
int main() {
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++) {
cin >> s[i];
}
int cnt = 0, cntA = 0, cntB = 0, cntBA = 0;
for (int i = 0; i < N; i++) {
int ni = s[i].size();
if (s[i].back() == 'A' && s[i].front() == 'B') {
cntBA++;
} else if (s[i].back() == 'A') {
cntA++;
} else if (s[i].front() == 'B') {
cntB++;
}
for (int j = 0; j < ni; j++) {
if (s[i].substr(j, 2) == "AB") {
cnt++;
}
}
}
if (cntA == 0 && cntB == 0 && cntBA > 0) {
cout << cnt + cntBA - 1 << endl;
} else {
cout << cnt + min(cntBA + cntA, cntBA + cntB) << endl;
}
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 865,650 | 865,651 | u209457657 | cpp |
p03045 | #include "bits/stdc++.h"
using namespace std;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0);
#define LLINF ((long long)1e18) // 1234567890987654321
#define INF 1234567890ll
#define pb emplace_back
#define ins insert
#define f first
#define s second
#define db 0
#define EPS (1e-7) // 0.0000001 the value
#define PI (acos(-1))
#define MAXN (300006)
#define MAXK 26
#define MAXX 15000006
#define ll long long int
#define ld long double
mt19937
rng(chrono::steady_clock::now()
.time_since_epoch()
.count()); // can be used by calling rng() or shuffle(A, A+n, rng)
#define FOR(ii, ss, ee) for (ll ii = ss; ii < ee; ++ii)
#define space " "
#define cbr cerr << "hi\n"
#define mmst(x, v) memset((x), v, sizeof((x)))
#define siz(x) ((ll)x.size())
#define ph emplace
#define btinpct(x) __builtin_popcountll(x)
#define p2(x) (1LL << (x))
#define all(x) (x).begin(), (x).end()
#define lbd(x, y) lower_bound(all(x), y)
#define ubd(x, y) upper_bound(all(x), y)
typedef pair<ll, ll> pi;
typedef pair<ll, pi> spi;
typedef pair<pi, pi> dpi;
inline ll rand(ll x, ll y) {
++y;
return (rng() % (y - x)) + x;
} // inclusivesss
ll n, m;
ll X[MAXN], Y[MAXN], Z[MAXN];
vector<ll> v[MAXN];
bool vis[MAXN];
void dfs(ll x) {
if (vis[x])
return;
vis[x] = 1;
for (auto i : v[x]) {
dfs(i);
}
}
int main() {
FAST cin >> n >> m;
FOR(i, 0, m) {
cin >> X[i] >> Y[i] >> Z[i];
Z[i] %= 2;
ll a = X[i], b = Y[i];
v[a].pb(b);
v[b].pb(Z[i]);
}
ll ans = 0;
FOR(i, 1, n + 1) {
if (vis[i])
continue;
ans++;
dfs(i);
}
cout << ans;
}
| #include "bits/stdc++.h"
using namespace std;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0);
#define LLINF ((long long)1e18) // 1234567890987654321
#define INF 1234567890ll
#define pb emplace_back
#define ins insert
#define f first
#define s second
#define db 0
#define EPS (1e-7) // 0.0000001 the value
#define PI (acos(-1))
#define MAXN (300006)
#define MAXK 26
#define MAXX 15000006
#define ll long long int
#define ld long double
mt19937
rng(chrono::steady_clock::now()
.time_since_epoch()
.count()); // can be used by calling rng() or shuffle(A, A+n, rng)
#define FOR(ii, ss, ee) for (ll ii = ss; ii < ee; ++ii)
#define space " "
#define cbr cerr << "hi\n"
#define mmst(x, v) memset((x), v, sizeof((x)))
#define siz(x) ((ll)x.size())
#define ph emplace
#define btinpct(x) __builtin_popcountll(x)
#define p2(x) (1LL << (x))
#define all(x) (x).begin(), (x).end()
#define lbd(x, y) lower_bound(all(x), y)
#define ubd(x, y) upper_bound(all(x), y)
typedef pair<ll, ll> pi;
typedef pair<ll, pi> spi;
typedef pair<pi, pi> dpi;
inline ll rand(ll x, ll y) {
++y;
return (rng() % (y - x)) + x;
} // inclusivesss
ll n, m;
ll X[MAXN], Y[MAXN], Z[MAXN];
vector<ll> v[MAXN];
bool vis[MAXN];
void dfs(ll x) {
if (vis[x])
return;
vis[x] = 1;
for (auto i : v[x]) {
dfs(i);
}
}
int main() {
FAST cin >> n >> m;
FOR(i, 0, m) {
cin >> X[i] >> Y[i] >> Z[i];
Z[i] %= 2;
ll a = X[i], b = Y[i];
v[a].pb(b);
v[b].pb(a);
}
ll ans = 0;
FOR(i, 1, n + 1) {
if (vis[i])
continue;
ans++;
dfs(i);
}
cout << ans;
}
| [
"call.arguments.change"
] | 865,656 | 865,657 | u844961982 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int A[200001];
int root(int x) {
if (A[x] == x)
return x;
else
return A[x] = root(A[x]);
}
int unite(int x, int y) {
x = root(x), y = root(y);
if (x != y)
A[x] = y;
}
int main() {
int n, m, x, y, z, ans = 0;
cin >> n >> m;
rep(i, n) A[i + 1] = i + 1;
rep(i, n) cin >> x >> y >> z, unite(x, y);
rep(i, n) if (A[i + 1] == i + 1) ans++;
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int A[200001];
int root(int x) {
if (A[x] == x)
return x;
else
return A[x] = root(A[x]);
}
int unite(int x, int y) {
x = root(x), y = root(y);
if (x != y)
A[x] = y;
}
int main() {
int n, m, x, y, z, ans = 0;
cin >> n >> m;
rep(i, n) A[i + 1] = i + 1;
rep(i, m) cin >> x >> y >> z, unite(x, y);
rep(i, n) if (A[i + 1] == i + 1) ans++;
cout << ans;
} | [
"identifier.change",
"call.arguments.change"
] | 865,682 | 865,683 | u441296840 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
bool isEven(int x) {
if (x % 2 == 0)
return true;
else
return false;
}
class UnionFind {
public:
vector<int> parent;
UnionFind(int n) : parent(n) {
for (int i = 0; i < n; i++) {
parent[i] = i;
}
}
int root(int x) {
if (parent[x] == x)
return x;
return parent[x] = root(parent[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry)
return;
parent[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main() {
int n, m;
cin >> n >> m;
int x[n];
int y[n];
int z[n];
UnionFind card(n);
int ans = n;
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i] >> z[i];
if (card.same(x[i] - 1, y[i] - 1)) {
ans--;
}
card.unite(x[i] - 1, y[i] - 1);
}
/*
for(int i = 0; i < n; i++){
cout << card.root(i) << " ";
}*/
cout << ans << endl;
return 0;
}
/*
class node {
int number;
int parent;
node(int num) {
this.number = num;
this.parent = this;
}
void setNumber(int num) {
this.number = num;
}
void setParent(int par) {
this.parent =
}
int getParent() {
return this.parent;
}
};*/
| #include <bits/stdc++.h>
using namespace std;
bool isEven(int x) {
if (x % 2 == 0)
return true;
else
return false;
}
class UnionFind {
public:
vector<int> parent;
UnionFind(int n) : parent(n) {
for (int i = 0; i < n; i++) {
parent[i] = i;
}
}
int root(int x) {
if (parent[x] == x)
return x;
return parent[x] = root(parent[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry)
return;
parent[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main() {
int n, m;
cin >> n >> m;
int x[m];
int y[m];
int z[m];
UnionFind card(n);
int ans = n;
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i] >> z[i];
if (!card.same(x[i] - 1, y[i] - 1)) {
ans--;
}
card.unite(x[i] - 1, y[i] - 1);
/*for(int i = 0; i < n; i++){
cout << card.root(i) << " ";
}
cout << endl;*/
}
cout << ans << endl;
return 0;
}
/*
class node {
int number;
int parent;
node(int num) {
this.number = num;
this.parent = this;
}
void setNumber(int num) {
this.number = num;
}
void setParent(int par) {
this.parent =
}
int getParent() {
return this.parent;
}
};*/
| [
"identifier.change",
"variable_declaration.array_dimensions.change",
"expression.operation.unary.add",
"control_flow.branch.if.condition.change"
] | 865,688 | 865,687 | u321761416 | cpp |
p03045 | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
const ll MOD = 1000000007;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
///////////////////////////////////////////////
/*（๑•﹏•๑｀) */
struct UnionFind {
vector<int> data;
UnionFind(int size) : data(size, -1) {}
int root(int x) {
if (data[x] < 0)
return x;
else
return data[x] = root(data[x]);
}
int size(int x) { return -data[root(x)]; }
bool isConnect(int x, int y) { return root(x) == root(y); }
bool connect(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (data[x] > data[y]) {
x ^= y;
y ^= x;
x ^= y;
}
data[x] = data[x] + data[y]; // membersize++
data[y] = x;
return true;
}
};
UnionFind U(100002);
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N + 1);
vector<int> X(N);
vector<int> Y(N);
vector<int> Z(N);
REP(i, M) {
int x, y, z;
cin >> x >> y >> z;
z = z % 2;
X[i] = x;
Y[i] = y;
Z[i] = z;
U.connect(x, y);
}
ll ans = 0;
FORq(i, 1, N) {
if (U.root(i) >= i)
ans++;
}
cout << ans << "\n";
} | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPr(i, n) for (int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for (int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for (int i = (n); i >= (m); --i)
#define PB push_back
#define MP make_pair
#define DEBUG printf("%s\n", "debug")
#define fst first
#define snd second
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
const ll MOD = 1000000007;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
///////////////////////////////////////////////
/*（๑•﹏•๑｀) */
struct UnionFind {
vector<int> data;
UnionFind(int size) : data(size, -1) {}
int root(int x) {
if (data[x] < 0)
return x;
else
return data[x] = root(data[x]);
}
int size(int x) { return -data[root(x)]; }
bool isConnect(int x, int y) { return root(x) == root(y); }
bool connect(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (data[x] > data[y]) {
x ^= y;
y ^= x;
x ^= y;
}
data[x] = data[x] + data[y]; // membersize++
data[y] = x;
return true;
}
};
UnionFind U(100002);
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N + 1);
vector<int> X(M);
vector<int> Y(M);
vector<int> Z(M);
REP(i, M) {
int x, y, z;
cin >> x >> y >> z;
z = z % 2;
X[i] = x;
Y[i] = y;
Z[i] = z;
U.connect(x, y);
}
ll ans = 0;
FORq(i, 1, N) {
if (U.root(i) == i)
ans++;
}
cout << ans << "\n";
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 865,689 | 865,690 | u236433947 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
int main() {
int n, m;
cin >> n >> m;
vector<int> x(m), y(m), z(m);
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i] >> z[i];
x[i]--;
y[i]--;
}
UnionFind uf(n);
for (int i = 0; i < m; i++)
uf.merge(x[i], y[i]);
set<int> st;
for (int i = 0; i < m; i++)
st.insert(uf.root(i));
cout << st.size() << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0)
return x;
else
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
bool merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (par[x] > par[y])
swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) { return -par[root(x)]; }
};
int main() {
int n, m;
cin >> n >> m;
vector<int> x(m), y(m), z(m);
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i] >> z[i];
x[i]--;
y[i]--;
}
UnionFind uf(n);
for (int i = 0; i < m; i++)
uf.merge(x[i], y[i]);
set<int> st;
for (int i = 0; i < n; i++)
st.insert(uf.root(i));
cout << st.size() << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 865,703 | 865,704 | u754651673 | cpp |
p03045 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <istream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
int par[100000];
int r[100000];
void init(int n) {
for (int i = 0; i < n; i++) {
par[i] = i;
r[i] = 0;
}
}
int find(int x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (r[x] < r[y]) {
par[x] = y;
} else {
par[y] = x;
if (r[x] == r[y])
r[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
int main() {
int n, m;
cin >> n >> m;
int x[100000], y[100000], z[100000];
init(n);
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i] >> z[i];
unite(x[i] - 1, y[i] - 1);
}
set<int> s;
for (int i = 0; i < n; i++) {
s.insert(par[i]);
}
cout << s.size() << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <istream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
int par[100000];
int r[100000];
void init(int n) {
for (int i = 0; i < n; i++) {
par[i] = i;
r[i] = 0;
}
}
int find(int x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (r[x] < r[y]) {
par[x] = y;
} else {
par[y] = x;
if (r[x] == r[y])
r[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
int main() {
int n, m;
cin >> n >> m;
int x[100000], y[100000], z[100000];
init(n);
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i] >> z[i];
unite(x[i] - 1, y[i] - 1);
}
set<int> s;
for (int i = 0; i < n; i++) {
s.insert(find(i));
}
cout << s.size() << endl;
return 0;
} | [
"call.arguments.change"
] | 865,712 | 865,713 | u790614328 | cpp |
p03045 | #include "bits/stdc++.h"
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REP1(i, n) for (ll i = 1; i < n; i++)
#define REPR(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define pb(a) push_back(a)
int n, m;
vector<int> ki(100000);
vector<int> kz(100000, 1);
int root(int w) {
int ww = w;
vector<int> kidmy(100000);
int lfg = 0;
REP(ii, 100000) {
if (ki[ww] == ww) {
break;
} else {
kidmy[lfg] = ww;
lfg++;
ww = ki[ww];
}
}
REP(ii, lfg) { ki[kidmy[ii]] = ww; }
return ww;
}
int main() {
int ans = 0;
cin >> n >> m;
vector<int> x(m), y(m), z(m);
REP(i, n) cin >> x[i] >> y[i] >> z[i];
REP(i, n) ki[i] = i;
REP(i, m) { //結合させていく
int pidx = root(x[i] - 1);
int pidy = root(y[i] - 1);
if (pidx != pidy) {
if (kz[pidy] > kz[pidx]) {
ki[pidx] = pidy;
kz[pidy] += kz[pidx];
} else {
ki[pidy] = pidx;
kz[pidx] += kz[pidy];
}
}
}
REP(i, n) {
if (ki[i] == i)
ans++;
}
cout << ans << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REP1(i, n) for (ll i = 1; i < n; i++)
#define REPR(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define VSORT(v) sort(v.begin(), v.end())
#define VRSORT(v) sort(v.rbegin(), v.rend())
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define pb(a) push_back(a)
int n, m;
vector<int> ki(100000);
vector<int> kz(100000, 1);
int root(int w) {
int ww = w;
vector<int> kidmy(10);
int lfg = 0;
REP(ii, 10) {
if (ki[ww] == ww) {
break;
} else {
kidmy[lfg] = ww;
lfg++;
ww = ki[ww];
}
}
REP(ii, lfg) { ki[kidmy[ii]] = ww; }
// if (kz[ww]<lfg)kz[ww]=lfg;
return ww;
}
int main() {
int ans = 0;
cin >> n >> m;
vector<int> x(m), y(m), z(m);
REP(i, m) cin >> x[i] >> y[i] >> z[i];
REP(i, 100000) ki[i] = i;
REP(i, m) { //結合させていく
int pidx = root(x[i] - 1);
int pidy = root(y[i] - 1);
if (pidx != pidy) {
if (kz[pidy] > kz[pidx]) {
ki[pidx] = pidy;
kz[pidy] += kz[pidx];
} else {
ki[pidy] = pidx;
kz[pidx] += kz[pidy];
}
}
}
REP(i, n) {
if (ki[i] == i)
ans++;
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"identifier.change",
"assignment.variable.change",
"identifier.replace.remove",
"literal.replace.add"
] | 865,723 | 865,720 | u837951457 | cpp |
p03045 | #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;
// const ll MOD = 1000000007;
// const int INF = 2000000000;
struct uf_tree {
vector<int> par, sizes;
uf_tree(int n) : par(n), sizes(n, 1) {
for (int i = 0; i < n; i++) {
par[i] = i;
}
}
int find(int x) {
if (x == par[x]) {
return x;
}
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
if (sizes[x] < sizes[y]) {
swap(x, y);
}
par[y] = x;
sizes[x] += sizes[y];
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return sizes[find(x)]; }
};
int N, M;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
uf_tree uf(N);
for (int i = 0; i < M; i++) {
int xi, yi, zi;
cin >> xi >> yi >> zi;
xi--;
yi--;
uf.unite(xi, yi);
}
int ans = 0;
set<int> st;
for (int i = 0; i < N; i++) {
int v = uf.find(i);
if (st.find(v) == st.end()) {
ans++;
st.insert(i);
}
}
cout << ans << endl;
return 0;
} | #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;
// const ll MOD = 1000000007;
// const int INF = 2000000000;
struct uf_tree {
vector<int> par, sizes;
uf_tree(int n) : par(n), sizes(n, 1) {
for (int i = 0; i < n; i++) {
par[i] = i;
}
}
int find(int x) {
if (x == par[x]) {
return x;
}
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
if (sizes[x] < sizes[y]) {
swap(x, y);
}
par[y] = x;
sizes[x] += sizes[y];
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return sizes[find(x)]; }
};
int N, M;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
uf_tree uf(N);
for (int i = 0; i < M; i++) {
int xi, yi, zi;
cin >> xi >> yi >> zi;
xi--;
yi--;
uf.unite(xi, yi);
}
int ans = 0;
set<int> st;
for (int i = 0; i < N; i++) {
int v = uf.find(i);
if (st.find(v) == st.end()) {
ans++;
st.insert(v);
}
}
cout << ans << endl;
return 0;
} | [
"identifier.change",
"call.arguments.change"
] | 865,726 | 865,727 | u751964641 | cpp |
p03045 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
const int INF = 1145141919, MOD = 1e9 + 7;
const long long LINF = 8931145141919364364, LMOD = 998244353;
// const int dx[]={1,0,-1,0,1,1,-1,-1},dy[]={0,-1,0,1,1,-1,-1,1};
struct UnionFind {
// 頂点数(1-indexed)
const int V;
// par[x]:=xのroot
vector<int> par;
// sz[x]:=xを含む集合のサイズ
vector<int> sz;
UnionFind(const int V) : V(V) {
par.resize(V + 1);
for (int i = 0; i <= V; i++)
par[i] = i;
sz.resize(V + 1, 1);
}
bool unite(int x, int y) {
x = root(x), y = root(y);
if (same(x, y))
return false;
if (y < x)
swap(x, y);
par[y] = x;
sz[x] += sz[y];
return true;
}
int root(int x) {
if (par[x] == x)
return x; // xはroot
return (par[x] = root(par[x])); // xの親のroot
}
bool same(int x, int y) { return (root(x) == root(y)); }
int size(int x) { return sz[root(x)]; }
};
int main() {
int n, m;
cin >> n >> m;
UnionFind uf(n);
while (m--) {
int x, y, z;
cin >> x >> y >> z;
uf.unite(x, y);
}
set<int> s;
for (int i = 1; i <= n; i++) {
s.insert(uf.par[i]);
}
cout << s.size() << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
const int INF = 1145141919, MOD = 1e9 + 7;
const long long LINF = 8931145141919364364, LMOD = 998244353;
// const int dx[]={1,0,-1,0,1,1,-1,-1},dy[]={0,-1,0,1,1,-1,-1,1};
struct UnionFind {
// 頂点数(1-indexed)
const int V;
// par[x]:=xのroot
vector<int> par;
// sz[x]:=xを含む集合のサイズ
vector<int> sz;
UnionFind(const int V) : V(V) {
par.resize(V + 1);
for (int i = 0; i <= V; i++)
par[i] = i;
sz.resize(V + 1, 1);
}
bool unite(int x, int y) {
x = root(x), y = root(y);
if (same(x, y))
return false;
if (y < x)
swap(x, y);
par[y] = x;
sz[x] += sz[y];
return true;
}
int root(int x) {
if (par[x] == x)
return x; // xはroot
return (par[x] = root(par[x])); // xの親のroot
}
bool same(int x, int y) { return (root(x) == root(y)); }
int size(int x) { return sz[root(x)]; }
};
int main() {
int n, m;
cin >> n >> m;
UnionFind uf(n);
while (m--) {
int x, y, z;
cin >> x >> y >> z;
uf.unite(x, y);
}
set<int> s;
for (int i = 1; i <= n; i++) {
s.insert(uf.root(i));
}
cout << s.size() << endl;
return 0;
}
| [
"call.arguments.change"
] | 865,730 | 865,731 | u918753189 | cpp |
p03045 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll MOD = 1e9 + 7;
const double EPS = 1e-9;
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(int argc, const char *argv[]) {
int N, M;
cin >> N >> M;
vector<int> X(M), Y(M);
for (int i = 0; i < M; i++) {
int Z;
cin >> X[i] >> Y[i] >> Z;
}
UnionFind tree(N);
for (int i = 0; i < M; i++) {
tree.unite(X[i] - 1, Y[i] - 1);
}
set<int> parent;
for (int i = 0; i <= N; i++) {
parent.insert(tree.root(i));
}
cout << parent.size() << endl;
return 0;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll MOD = 1e9 + 7;
const double EPS = 1e-9;
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(int argc, const char *argv[]) {
int N, M;
cin >> N >> M;
vector<int> X(M), Y(M);
for (int i = 0; i < M; i++) {
int Z;
cin >> X[i] >> Y[i] >> Z;
}
UnionFind tree(N);
for (int i = 0; i < M; i++) {
tree.unite(X[i] - 1, Y[i] - 1);
}
set<int> parent;
for (int i = 0; i < N; i++) {
parent.insert(tree.root(i));
}
cout << parent.size() << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 865,732 | 865,733 | u320491590 | cpp |
p03045 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll MOD = 1e9 + 7;
const double EPS = 1e-9;
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(int argc, const char *argv[]) {
int N, M;
cin >> N >> M;
vector<int> X(M), Y(M);
for (int i = 0; i < M; i++) {
int Z;
cin >> X[i] >> Y[i] >> Z;
}
UnionFind tree(N);
for (int i = 0; i < M; i++) {
tree.unite(X[i], Y[i]);
}
set<int> parent;
for (int i = 0; i < N; i++) {
parent.insert(tree.root(i));
}
cout << parent.size() << endl;
return 0;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll MOD = 1e9 + 7;
const double EPS = 1e-9;
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(int argc, const char *argv[]) {
int N, M;
cin >> N >> M;
vector<int> X(M), Y(M);
for (int i = 0; i < M; i++) {
int Z;
cin >> X[i] >> Y[i] >> Z;
}
UnionFind tree(N);
for (int i = 0; i < M; i++) {
tree.unite(X[i] - 1, Y[i] - 1);
}
set<int> parent;
for (int i = 0; i < N; i++) {
parent.insert(tree.root(i));
}
cout << parent.size() << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 865,734 | 865,733 | u320491590 | cpp |
p03045 | #include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(void) {
int n, m;
std::cin >> n >> m;
UnionFind uft(n);
for (int i = 0; i < m; i++) {
int x, y, z;
std::cin >> x >> y >> z;
uft.unite(x, y);
}
std::set<int> s;
for (int i = 0; i < n; i++) {
s.insert(uft.root(i));
}
std::cout << s.size() << std::endl;
return 0;
}
| #include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
struct UnionFind {
vector<int> par;
UnionFind(int N) : par(N) {
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry)
return;
par[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(void) {
int n, m;
std::cin >> n >> m;
UnionFind uft(n);
for (int i = 0; i < m; i++) {
int x, y, z;
std::cin >> x >> y >> z;
uft.unite(x - 1, y - 1);
}
std::set<int> s;
for (int i = 0; i < n; i++) {
s.insert(uft.root(i));
}
std::cout << s.size() << std::endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 865,735 | 865,736 | u679906187 | cpp |
p03045 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
class UnionFind {
public:
vector<ll> uni;
UnionFind(ll s) : uni(s, -1) {}
ll root(ll a) {
if (uni[a] < 0)
return a;
return uni[a] = root(uni[a]);
}
bool connect(int a, int b) {
a = root(a);
b = root(b);
if (a == b)
return false;
if (uni[a] > uni[b]) {
a ^= b;
b ^= a;
a ^= b;
}
uni[a] = uni[a] + uni[b];
uni[b] = a;
return true;
}
bool isConnect(ll a, ll b) { return root(a) == root(b); }
ll size(ll a) { return -uni[root(a)]; }
};
int main() {
int n, m;
cin >> n >> m;
UnionFind cards(n);
int x, y;
bool z;
for (int i = 0; i < m; i++) {
cin >> x >> y >> z;
cards.connect(x - 1, y - 1);
}
int number[100005] = {0};
ll ans = 0;
for (int i = 0; i < n; i++) {
int num = cards.size(i);
if (number[num] == 0) {
number[num] = num - 1;
ans++;
} else {
number[num]--;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
class UnionFind {
public:
vector<ll> uni;
UnionFind(ll s) : uni(s, -1) {}
ll root(ll a) {
if (uni[a] < 0)
return a;
return uni[a] = root(uni[a]);
}
bool connect(int a, int b) {
a = root(a);
b = root(b);
if (a == b)
return false;
if (uni[a] > uni[b]) {
a ^= b;
b ^= a;
a ^= b;
}
uni[a] = uni[a] + uni[b];
uni[b] = a;
return true;
}
bool isConnect(ll a, ll b) { return root(a) == root(b); }
ll size(ll a) { return -uni[root(a)]; }
};
int main() {
int n, m;
cin >> n >> m;
UnionFind cards(n);
int x, y, z;
for (int i = 0; i < m; i++) {
cin >> x >> y >> z;
cards.connect(x - 1, y - 1);
}
int number[100005] = {0};
ll ans = 0;
for (int i = 0; i < n; i++) {
int num = cards.size(i);
if (number[num] == 0) {
number[num] = num - 1;
ans++;
} else {
number[num]--;
}
}
cout << ans << endl;
return 0;
} | [] | 865,737 | 865,738 | u036561304 | cpp |
p03049 | #include <iostream>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int N, ans, numA, numB, numBA;
int main() {
cin >> N;
string s;
rep(i, N) {
cin >> s;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
numBA++;
else if (s[0] == 'B')
numB++;
else if (s[s.size() - 1] == 'A')
numA++;
rep(j, s.size() - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
}
ans += numBA + min(numA, numB);
if (numA + numB == 0)
ans--;
cout << ans << endl;
} | #include <iostream>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int N, ans, numA, numB, numBA;
int main() {
cin >> N;
string s;
rep(i, N) {
cin >> s;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
numBA++;
else if (s[0] == 'B')
numB++;
else if (s[s.size() - 1] == 'A')
numA++;
rep(j, s.size() - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
}
ans += numBA + min(numA, numB);
if (numBA && numA + numB == 0)
ans--;
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change"
] | 865,743 | 865,744 | u658655325 | cpp |
p03049 | #pragma comment(linker, "/stack:247474112")
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define RANGE(i, x, n) for (ll i = x; i < n; ++i)
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
void accelerate() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int main() {
accelerate();
int n;
cin >> n;
vector<string> s(n);
ll ans = 0;
REP(i, n) {
cin >> s[i];
REP(j, s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
++ans;
}
}
int cnt_a = 0, cnt_b = 0;
int flg = 0;
REP(i, n) {
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
cnt_a++;
cnt_b++;
} else if (s[i][0] == 'B') {
cnt_b++;
flg = 1;
} else if (s[i][s[i].size() - 1] == 'A') {
cnt_a++;
flg = 1;
}
}
if (flg) {
ans += min(cnt_a, cnt_b);
} else {
ans += cnt_a - 1;
}
cout << ans << endl;
}
| #pragma comment(linker, "/stack:247474112")
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define RANGE(i, x, n) for (ll i = x; i < n; ++i)
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
void accelerate() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int main() {
accelerate();
int n;
cin >> n;
vector<string> s(n);
ll ans = 0;
REP(i, n) {
cin >> s[i];
REP(j, s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
++ans;
}
}
int cnt_a = 0, cnt_b = 0;
int flg = 0;
REP(i, n) {
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
cnt_a++;
cnt_b++;
} else if (s[i][0] == 'B') {
cnt_b++;
flg = 1;
} else if (s[i][s[i].size() - 1] == 'A') {
cnt_a++;
flg = 1;
}
}
if (flg) {
ans += min(cnt_a, cnt_b);
} else {
ans += max(cnt_a - 1, 0);
}
cout << ans << endl;
}
| [
"call.add",
"call.arguments.add"
] | 865,745 | 865,746 | u050809017 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
// freopen("in.txt","r",stdin);
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a = 0, b = 0, d = 0;
string s;
int ans = 0;
while (n--) {
cin >> s;
int len = (int)s.size();
for (int i = 1; i < len; ++i) {
if (s[i] == 'B' && s[i - 1] == 'A')
ans++;
}
if (s[0] == 'B' && s[len - 1] == 'A')
d++;
else {
if (s[0] == 'B')
b++;
else if (s[len - 1] == 'A')
a++;
}
}
// cout<<ans<<" "<<a<<" "<<b<<" "<<d<<endl;
if (a == 0 && b == 0)
ans += (d - 1);
else if (a == 0 || b == 0)
ans += d;
else {
if (d > 0) {
ans += d - 1;
ans++;
a--;
ans++;
b--;
ans += min(a, b);
} else {
ans += min(a, b);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
// freopen("in.txt","r",stdin);
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a = 0, b = 0, d = 0;
string s;
int ans = 0;
while (n--) {
cin >> s;
int len = (int)s.size();
for (int i = 1; i < len; ++i) {
if (s[i] == 'B' && s[i - 1] == 'A')
ans++;
}
if (s[0] == 'B' && s[len - 1] == 'A')
d++;
else {
if (s[0] == 'B')
b++;
else if (s[len - 1] == 'A')
a++;
}
}
// cout<<ans<<" "<<a<<" "<<b<<" "<<d<<endl;
if (a == 0 && b == 0)
ans += d ? (d - 1) : 0;
else if (a == 0 || b == 0)
ans += d;
else {
if (d > 0) {
ans += d - 1;
ans++;
a--;
ans++;
b--;
ans += min(a, b);
} else {
ans += min(a, b);
}
}
cout << ans << endl;
return 0;
} | [] | 865,757 | 865,758 | u781659997 | cpp |
p03049 | #include <iostream>
using namespace std;
string a[10005];
int cnt;
int cnta, cntb;
int cntab;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 0; j < a[i].length() - 1; j++) {
if (a[i][j] == 'A' && a[i][j + 1] == 'B') {
cnt++;
}
}
if (a[i][0] == 'B') {
cntb++;
// cout<<"B"<<endl;
}
if (a[i][a[i].length() - 1] == 'A') {
cnta++;
}
if (a[i][0] == 'B' && a[i][a[i].length() - 1] == 'A') {
cntab++;
}
}
cnt += min(cnta, cntb);
if (cntab == cnta && cntab == cntb) {
cnt--;
}
cout << cnt;
return 0;
} | #include <iostream>
using namespace std;
string a[10005];
int cnt;
int cnta, cntb;
int cntab;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 0; j < a[i].length() - 1; j++) {
if (a[i][j] == 'A' && a[i][j + 1] == 'B') {
cnt++;
}
}
if (a[i][0] == 'B') {
cntb++;
// cout<<"B"<<endl;
}
if (a[i][a[i].length() - 1] == 'A') {
cnta++;
}
if (a[i][0] == 'B' && a[i][a[i].length() - 1] == 'A') {
cntab++;
}
}
cnt += min(cnta, cntb);
if (cntab == cnta && cntab == cntb && cntab != 0) {
cnt--;
}
cout << cnt;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 865,759 | 865,760 | u261868146 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int c = 0;
int pa = 0, pb = 0;
int c2 = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < s.length() - 1; j++)
if (s[j] == 'A' && s[j + 1] == 'B')
c++;
if (s[0] == 'B' && s[s.length() - 1] == 'A') {
pb++;
pa++;
c2++;
} else if (s[0] == 'B') {
pb++;
c2++;
} else if (s[s.length() - 1] == 'A') {
pa++;
c2++;
}
}
int p = min(pa, pb);
if (p == c2)
p--;
cout << c + p << endl;
// system("pause");
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int c = 0;
int pa = 0, pb = 0;
int c2 = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < s.length() - 1; j++)
if (s[j] == 'A' && s[j + 1] == 'B')
c++;
if (s[0] == 'B' && s[s.length() - 1] == 'A') {
pb++;
pa++;
c2++;
} else if (s[0] == 'B') {
pb++;
c2++;
} else if (s[s.length() - 1] == 'A') {
pa++;
c2++;
}
}
int p = min(pa, pb);
if (p == c2 && c2 != 0)
p--;
cout << c + p << endl;
// system("pause");
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 865,764 | 865,765 | u007149573 | cpp |
p03049 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
long long int n, i, j, ans = 0, bstart = 0, aend = 0, min = 0, aa = -1,
bb = -1, ba = 0;
scanf("%lld", &n);
char s[n][15];
for (i = 0; i < n; i++) {
memset(s[i], '\0', 15);
scanf("%s", s[i]);
}
for (i = 0; i < n; i++) {
for (j = 0; s[i][j] != '\0'; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
if (j == 0 && s[i][j] == 'B') {
bstart++;
bb = i;
}
if (s[i][j] == 'A' && s[i][j + 1] == '\0') {
aend++;
aa = i;
}
}
if (aa == i && bb == i)
ba++;
}
min = bstart;
if (min > aend)
min = aend;
if (ba == aend && ba == bstart)
ans--;
printf("%lld", ans + min);
} | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
long long int n, i, j, ans = 0, bstart = 0, aend = 0, min = 0, aa = -1,
bb = -1, ba = 0;
scanf("%lld", &n);
char s[n][15];
for (i = 0; i < n; i++) {
memset(s[i], '\0', 15);
scanf("%s", s[i]);
}
for (i = 0; i < n; i++) {
for (j = 0; s[i][j] != '\0'; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
if (j == 0 && s[i][j] == 'B') {
bstart++;
bb = i;
}
if (s[i][j] == 'A' && s[i][j + 1] == '\0') {
aend++;
aa = i;
}
}
if (aa == i && bb == i)
ba++;
}
min = bstart;
if (min > aend)
min = aend;
if (ba == aend && ba == bstart && ba != 0)
ans--;
printf("%lld", ans + min);
} | [
"control_flow.branch.if.condition.change"
] | 865,777 | 865,778 | u356991267 | cpp |
p03049 | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int ctoi(char c) {
switch (c) {
case '0':
return 0;
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
default:
return 0;
}
}
int main() {
long long N;
cin >> N;
long long i, j;
long long ans = 0;
long long A = 0;
long long B = 0;
long long BA = 0;
vector<string> S;
for (i = 0; i < N; i++) {
string s;
cin >> s;
S.push_back(s);
for (j = 0; j < s.size() - 1; j++) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
ans++;
}
}
long long flag = 0;
if (s.at(0) == 'B') {
B++;
flag++;
}
if (s.at(s.size() - 1) == 'A') {
A++;
flag++;
}
if (flag == 2) {
BA++;
}
}
ans += min(A, B);
if (BA == A && BA == B) {
cout << ans - 1;
} else {
cout << ans;
}
} | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int ctoi(char c) {
switch (c) {
case '0':
return 0;
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
default:
return 0;
}
}
int main() {
long long N;
cin >> N;
long long i, j;
long long ans = 0;
long long A = 0;
long long B = 0;
long long BA = 0;
vector<string> S;
for (i = 0; i < N; i++) {
string s;
cin >> s;
S.push_back(s);
for (j = 0; j < s.size() - 1; j++) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
ans++;
}
}
long long flag = 0;
if (s.at(0) == 'B') {
B++;
flag++;
}
if (s.at(s.size() - 1) == 'A') {
A++;
flag++;
}
if (flag == 2) {
BA++;
}
}
ans += min(A, B);
if (BA == A && BA == B && BA >= 1) {
cout << ans - 1;
} else {
cout << ans;
}
} | [
"control_flow.branch.if.condition.change"
] | 865,783 | 865,784 | u916974091 | cpp |
p03049 | #include <algorithm>
#include <bits/stdc++.h>
#include <stdint.h>
#include <vector>
using namespace std;
int main() {
int N;
string s;
cin >> N;
int ab = 0;
int endA = 0;
int beginB = 0;
int BandA = 0;
int flag = 0;
for (int i = 0; i < N; i++) {
flag = 0;
cin >> s;
for (int j = 0; j < s.size() - 1; j++) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
ab++;
}
}
if (s.at(0) == 'B') {
beginB++;
flag++;
}
if (s.at(s.size() - 1) == 'A') {
endA++;
if (flag > 0) {
BandA++;
}
}
// cout << "turn:" << i << ",ab:" << ab << ",endA:" << endA << ",beginB:" <<
// beginB << endl;
}
int ans = ab + min(endA, beginB);
if ((endA == N) && (beginB == N)) {
ans--;
} else if ((endA == BandA) && (beginB == BandA)) {
if (ans > 0)
ans--;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <stdint.h>
#include <vector>
using namespace std;
int main() {
int N;
string s;
cin >> N;
int ab = 0;
int endA = 0;
int beginB = 0;
int BandA = 0;
int flag = 0;
for (int i = 0; i < N; i++) {
flag = 0;
cin >> s;
for (int j = 0; j < s.size() - 1; j++) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
ab++;
}
}
if (s.at(0) == 'B') {
beginB++;
flag++;
}
if (s.at(s.size() - 1) == 'A') {
endA++;
if (flag > 0) {
BandA++;
}
}
// cout << "turn:" << i << ",ab:" << ab << ",endA:" << endA << ",beginB:"
//<< beginB << endl;
}
int ans = ab + min(endA, beginB);
if ((endA == N) && (beginB == N)) {
ans--;
} else if ((endA == BandA) && (beginB == BandA)) {
if (ans > 0 && BandA > 0)
ans--;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 865,785 | 865,786 | u641922479 | cpp |
p03049 | #include <iostream>
#include <math.h>
#include <string>
using namespace std;
int a, b, c, d, n, judg = 0, sub = 0, Ans = 0, i, j, k = 0;
int A[100];
string S[10000];
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> S[i];
if (S[i].front() == 'B')
judg += 1;
if (S[i].back() == 'A')
sub += 1;
if (S[i].front() == 'B' && S[i].back() == 'A')
k += 1;
for (j = 0; j < S[i].length() - 1; j++) {
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
Ans += 1;
}
}
if (k == judg && sub == k)
Ans -= 1;
if (judg <= sub)
cout << Ans + judg << endl;
else
cout << Ans + sub << endl;
return 0;
}
| #include <iostream>
#include <math.h>
#include <string>
using namespace std;
int a, b, c, d, n, judg = 0, sub = 0, Ans = 0, i, j, k = 0;
int A[100];
string S[10000];
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> S[i];
if (S[i].front() == 'B')
judg += 1;
if (S[i].back() == 'A')
sub += 1;
if (S[i].front() == 'B' && S[i].back() == 'A')
k += 1;
for (j = 0; j < S[i].length() - 1; j++) {
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
Ans += 1;
}
}
if (k == judg && sub == k && sub != 0)
Ans -= 1;
if (judg <= sub)
cout << Ans + judg << endl;
else
cout << Ans + sub << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 865,796 | 865,797 | u839537391 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int count_ab(string &s) {
int ans = 0;
for (int i = 0; i < s.length() - 1; i++) {
if (s[i] == 'A' && s[i + 1] == 'B')
ans++;
}
return ans;
}
int main() {
int N;
string tmp;
int ab = 0;
int bx = 0, xa = 0, bxa = 0;
bool tb, ta;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> tmp;
ab += count_ab(tmp);
tb = (tmp[0] == 'B');
ta = (tmp[tmp.length() - 1] == 'A');
bx += tb ? 1 : 0;
xa += ta ? 1 : 0;
bxa += ta && tb ? 1 : 0;
}
int a_ans = min(bx, xa);
int b_ans = ab;
if (a_ans >= N || (a_ans == bxa && a_ans != 0))
a_ans--;
// printf("bx: %d, xa: %d, bxa: %d, ab: %d\n", bx, xa, bxa, ab);
printf("%d\n", a_ans + b_ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int count_ab(string &s) {
int ans = 0;
for (int i = 0; i < s.length() - 1; i++) {
if (s[i] == 'A' && s[i + 1] == 'B')
ans++;
}
return ans;
}
int main() {
int N;
string tmp;
int ab = 0;
int bx = 0, xa = 0, bxa = 0;
bool tb, ta;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> tmp;
ab += count_ab(tmp);
tb = (tmp[0] == 'B');
ta = (tmp[tmp.length() - 1] == 'A');
bx += tb ? 1 : 0;
xa += ta ? 1 : 0;
bxa += ta && tb ? 1 : 0;
}
int a_ans = min(bx, xa);
int b_ans = ab;
if (a_ans >= N || (bx == bxa && xa == bxa && a_ans != 0))
a_ans--;
// printf("bx: %d, xa: %d, bxa: %d, a_ans: %d, b_ans:%d\n", bx, xa, bxa,
// a_ans, b_ans);
printf("%d\n", a_ans + b_ans);
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 865,805 | 865,806 | u784332273 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int tmp = 0, tmpA = 0, tmpB = 0, tmpBA = 0, ans;
char S[20000][20];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> S[i];
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < 11; j++) {
if (S[i][j + 1] == '\0') {
if (S[i][j] == 'A')
tmpA++;
if (S[i][0] == 'B')
tmpB++;
if (S[i][j] == 'A' && S[i][0] == 'B')
tmpBA++;
break;
}
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
tmp++;
}
}
ans = min(tmpA, tmpB);
if (ans == N || (tmpBA == tmpA && tmpBA == tmpB))
ans--;
cout << ans + tmp << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int tmp = 0, tmpA = 0, tmpB = 0, tmpBA = 0, ans;
char S[20000][20];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> S[i];
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < 11; j++) {
if (S[i][j + 1] == '\0') {
if (S[i][j] == 'A')
tmpA++;
if (S[i][0] == 'B')
tmpB++;
if (S[i][j] == 'A' && S[i][0] == 'B')
tmpBA++;
break;
}
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
tmp++;
}
}
ans = min(tmpA, tmpB);
if (ans == N || (tmpBA == tmpA && tmpBA == tmpB) && ans >= 1)
ans--;
cout << ans + tmp << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 865,808 | 865,809 | u074306398 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int tmp = 0, tmpA = 0, tmpB = 0, tmpBA = 0, ans;
char S[20000][20];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> S[i];
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < 11; j++) {
if (S[i][j + 1] == '\0') {
if (S[i][j] == 'A')
tmpA++;
if (S[i][0] == 'B')
tmpB++;
if (S[i][j] == 'A' && S[i][0] == 'B')
tmpBA++;
break;
}
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
tmp++;
}
}
ans = min(tmpA, tmpB);
if (tmpA == N || (tmpBA == tmpA && tmpBA == tmpB))
ans--;
cout << ans + tmp << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int tmp = 0, tmpA = 0, tmpB = 0, tmpBA = 0, ans;
char S[20000][20];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> S[i];
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < 11; j++) {
if (S[i][j + 1] == '\0') {
if (S[i][j] == 'A')
tmpA++;
if (S[i][0] == 'B')
tmpB++;
if (S[i][j] == 'A' && S[i][0] == 'B')
tmpBA++;
break;
}
if (S[i][j] == 'A' && S[i][j + 1] == 'B')
tmp++;
}
}
ans = min(tmpA, tmpB);
if (ans == N || (tmpBA == tmpA && tmpBA == tmpB) && ans >= 1)
ans--;
cout << ans + tmp << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 865,810 | 865,809 | u074306398 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.