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 |
|---|---|---|---|---|---|---|---|
p03049 | #include <bits/stdc++.h>
typedef long long ll;
#define INF 100000000
#define MOD 100000007
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, -1, 0, 1};
using namespace std;
int main(void) {
int n;
cin >> n;
vector<string> s(n);
ll ans = 0;
int p = 0, q = 0, r = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' and s[i][j + 1] == 'B')
ans++;
}
if (s[i][0] == 'B' and s[i][s[i].size() - 1] == 'A') {
r++;
} else if (s[i][0] == 'B') {
q++;
} else if (s[i][s[i].size() - 1] == 'A') {
p++;
}
}
// cout<<ans<<endl;
// cout<<p<<" "<<q<<" "<<r<<endl;
if (r > 1) {
ans += (r - 1);
r = 1;
}
if (p > q) {
if (p >= 1 and r) {
ans++;
r--;
}
} else {
if (q >= 1 and r) {
r--;
ans++;
}
}
ans += min(p + r, q + r);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
#define INF 100000000
#define MOD 100000007
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, -1, 0, 1};
using namespace std;
int main(void) {
int n;
cin >> n;
vector<string> s(n);
ll ans = 0;
int p = 0, q = 0, r = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' and s[i][j + 1] == 'B')
ans++;
}
if (s[i][0] == 'B' and s[i][s[i].size() - 1] == 'A') {
r++;
} else if (s[i][0] == 'B') {
q++;
} else if (s[i][s[i].size() - 1] == 'A') {
p++;
}
}
// cout<<ans<<endl;
// cout<<p<<" "<<q<<" "<<r<<endl;
if (r > 1) {
ans += (r - 1);
r = 1;
}
if (p > q) {
if (p >= 1 and r) {
ans++;
r--;
}
} else {
if (q >= 1 and r) {
r--;
ans++;
}
}
ans += min(p, q);
cout << ans << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 866,640 | 866,641 | u962206827 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++)
cin >> s[i];
ll tot = 0;
int enda = 0, firb = 0, bothn = 0;
for (int i = 0; i < n; i++) {
int len = s[i].length();
if (s[i][0] == 'B') {
firb += 1;
}
if (s[i][len - 1] == 'A') {
enda += 1;
}
if (s[i][0] == 'B' && s[i][len - 1] == 'A')
bothn += 1;
for (int j = 0; j < len - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
tot += 1;
}
}
}
if (bothn == enda && bothn == firb) {
tot += bothn - 1;
} else {
tot += min(firb, enda);
}
cout << tot;
}
| #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
string s[n];
for (int i = 0; i < n; i++)
cin >> s[i];
ll tot = 0;
int enda = 0, firb = 0, bothn = 0;
for (int i = 0; i < n; i++) {
int len = s[i].length();
if (s[i][0] == 'B') {
firb += 1;
}
if (s[i][len - 1] == 'A') {
enda += 1;
}
if (s[i][0] == 'B' && s[i][len - 1] == 'A')
bothn += 1;
for (int j = 0; j < len - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
tot += 1;
}
}
}
if (bothn == enda && bothn == firb && bothn > 0) {
tot += bothn - 1;
} else {
tot += min(firb, enda);
}
cout << tot;
} | [
"control_flow.branch.if.condition.change"
] | 866,647 | 866,648 | u337054478 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
long long GCD(long long a, long long b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
int main() {
int N;
cin >> N;
string S[N];
for (int i = 0; i < N; ++i)
cin >> S[i];
int sum = 0;
int head_B = 0;
int tail_A = 0;
int head_tail = 0;
for (int i = 0; i < N; ++i) {
string s = S[i];
if (s[0] == 'B')
++head_B;
if (s[s.size() - 1] == 'A')
++tail_A;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
++head_tail;
int count = 0;
for (int j = 0; j < s.size() - 1; ++j) {
if (s[j] == 'A' && s[j + 1] == 'B')
++count;
}
sum += count;
}
int tmp = max(0, min(head_B, tail_A));
if (tmp == N)
tmp -= 1;
if (tmp == head_tail && head_B == tail_A)
tmp -= 1;
sum += tmp;
cout << sum << endl;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
long long GCD(long long a, long long b) {
if (b == 0)
return a;
return GCD(b, a % b);
}
int main() {
int N;
cin >> N;
string S[N];
for (int i = 0; i < N; ++i)
cin >> S[i];
int sum = 0;
int head_B = 0;
int tail_A = 0;
int head_tail = 0;
for (int i = 0; i < N; ++i) {
string s = S[i];
if (s[0] == 'B')
++head_B;
if (s[s.size() - 1] == 'A')
++tail_A;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
++head_tail;
int count = 0;
for (int j = 0; j < s.size() - 1; ++j) {
if (s[j] == 'A' && s[j + 1] == 'B')
++count;
}
sum += count;
}
int tmp = max(0, min(head_B, tail_A));
if (tmp == N)
tmp -= 1;
if (tmp == head_tail && head_B == tail_A)
tmp -= 1;
if (tmp > 0)
sum += tmp;
cout << sum << endl;
}
| [
"control_flow.branch.if.add"
] | 866,653 | 866,654 | u600896094 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define printArr(harry, tam) range(tam) cout << harry[i] << " \n"[i == tam - 1];
#define range(n) for (int i = 0; i < n; i++)
#define forn(x, n) for (int x = 0; x < n; x++)
#define maxn "100000"
#define mod "1000000007"
#define md(x) ((((x) % mod) + mod) % mod)
#define sc scanf
#define pr printf
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define prt(x) cout << (#x) << " is " << (x) << endl
#define EPS 1e-9
#define INF INT_MAX
#define INFd 1e9
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef vector<int> vi;
// Trace dinamico
template <typename T> void trace(T a) { cout << a << "\n"; }
template <typename T, typename... Args> void trace(T a, Args... args) {
cout << a << " ";
trace(args...);
}
// DP debug
int recNum = 0;
void prTabs() { range(recNum) cout << " "; }
template <typename... Args> void recInit(Args... args) {
prTabs();
trace("rec(", args..., ")");
recNum++;
}
template <typename T> void recEnd(T a) {
prTabs();
trace("->", a);
recNum--;
}
int r, g, b, n;
// vector<int> g[maxn];
char ch = '0', ant = '0';
int main() {
sc("%d\n", &n);
int initb = 0, fima = 0, ab = 0;
int ba = 0, ca = 0, bc = 0, cc = 0;
for (int i = 0; i < n; i++) {
ant = ch;
ch = getchar();
char init = ch;
if (ch == 'B')
initb++;
while (ch != '\n') {
if (ch == 'B' && ant == 'A')
ab++;
ant = ch;
ch = getchar();
}
if (ant == 'A')
fima++;
if (init == 'B' && ant == 'A') {
ba++;
} else if (init == 'B') {
bc++;
} else if (ant == 'A') {
ca++;
}
}
int r = 0;
// trace(ba, ca, bc, cc);
if (ca == 0) {
r += max(ba - 1, 0);
if (bc)
r++;
} else if (bc == 0) {
r += ba;
} else {
r += min(ca, bc);
r += ba;
}
// trace("r:",r);
r += ab;
pr("%d\n", r);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define printArr(harry, tam) range(tam) cout << harry[i] << " \n"[i == tam - 1];
#define range(n) for (int i = 0; i < n; i++)
#define forn(x, n) for (int x = 0; x < n; x++)
#define maxn "100000"
#define mod "1000000007"
#define md(x) ((((x) % mod) + mod) % mod)
#define sc scanf
#define pr printf
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define prt(x) cout << (#x) << " is " << (x) << endl
#define EPS 1e-9
#define INF INT_MAX
#define INFd 1e9
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef vector<int> vi;
// Trace dinamico
template <typename T> void trace(T a) { cout << a << "\n"; }
template <typename T, typename... Args> void trace(T a, Args... args) {
cout << a << " ";
trace(args...);
}
// DP debug
int recNum = 0;
void prTabs() { range(recNum) cout << " "; }
template <typename... Args> void recInit(Args... args) {
prTabs();
trace("rec(", args..., ")");
recNum++;
}
template <typename T> void recEnd(T a) {
prTabs();
trace("->", a);
recNum--;
}
int r, g, b, n;
// vector<int> g[maxn];
char ch = '0', ant = '0';
int main() {
sc("%d\n", &n);
int initb = 0, fima = 0, ab = 0;
int ba = 0, ca = 0, bc = 0, cc = 0;
for (int i = 0; i < n; i++) {
ant = ch;
ch = getchar();
char init = ch;
if (ch == 'B')
initb++;
while (ch != '\n') {
if (ch == 'B' && ant == 'A')
ab++;
ant = ch;
ch = getchar();
}
if (ant == 'A')
fima++;
if (init == 'B' && ant == 'A') {
ba++;
} else if (init == 'B') {
bc++;
} else if (ant == 'A') {
ca++;
}
}
int r = 0;
// trace(ba, ca, bc, cc);
if (ca == 0) {
r += max(ba - 1, 0);
if (r && bc)
r++;
} else if (bc == 0) {
r += ba;
} else {
r += min(ca, bc);
r += ba;
}
// trace("r:",r);
r += ab;
pr("%d\n", r);
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 866,657 | 866,658 | u396427486 | 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; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define pb(a) push_back(a)
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<string> S(N);
int ans = 0;
int num_a = 0;
int num_b = 0;
int ab = 0;
REP(i, N) {
int a = 0, b = 0;
cin >> S.at(i);
REP(j, S.at(i).size() - 1) {
if (S.at(i).at(j) == 'A' && S.at(i).at(j + 1) == 'B')
ans++;
}
if (S.at(i).at(S.at(i).size() - 1) == 'A' && S.at(i).at(0) == 'B') {
num_a++;
num_b++;
ab++;
} else if (S.at(i).at(0) == 'B')
num_a += 1;
else if (S.at(i).at(S.at(i).size() - 1) == 'A')
num_b += 1;
}
if (num_a == num_b && num_a == ab)
ans += min(num_a, num_b) - 1;
else
ans += min(num_a, num_b);
cout << ans;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define pb(a) push_back(a)
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<string> S(N);
int ans = 0;
int num_a = 0;
int num_b = 0;
int ab = 0;
REP(i, N) {
int a = 0, b = 0;
cin >> S.at(i);
REP(j, S.at(i).size() - 1) {
if (S.at(i).at(j) == 'A' && S.at(i).at(j + 1) == 'B')
ans++;
}
if (S.at(i).at(S.at(i).size() - 1) == 'A' && S.at(i).at(0) == 'B') {
num_a++;
num_b++;
ab++;
} else if (S.at(i).at(0) == 'B')
num_a += 1;
else if (S.at(i).at(S.at(i).size() - 1) == 'A')
num_b += 1;
}
if (num_a == num_b && num_a == ab)
ans += max(min(num_a, num_b) - 1, 0);
else
ans += min(num_a, num_b);
cout << ans;
} | [
"call.add",
"call.arguments.add"
] | 866,661 | 866,662 | u346812984 | cpp |
p03049 | #include <iostream>
#include <queue>
#include <string>
using namespace std;
int main() {
int n;
string str[10001];
cin >> n;
int ans = 0, a_end = 0, b_start = 0, atob = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int len = (int)(s.length());
bool prev_a = false;
for (int j = 0; j < len; j++) {
if (prev_a && s[j] == 'B') {
ans++;
}
prev_a = false;
if (s[j] == 'A')
prev_a = true;
}
if (prev_a)
a_end++;
if (s[0] == 'B') {
b_start++;
if (prev_a)
atob++;
}
}
if (atob == a_end && atob == b_start)
ans--;
cout << ans + min(a_end, b_start) << endl;
return 0;
} | #include <iostream>
#include <queue>
#include <string>
using namespace std;
int main() {
int n;
string str[10010];
cin >> n;
int ans = 0, a_end = 0, b_start = 0, atob = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int len = (int)(s.length());
bool prev_a = false;
for (int j = 0; j < len; j++) {
if (prev_a && s[j] == 'B') {
ans++;
}
prev_a = false;
if (s[j] == 'A')
prev_a = true;
}
if (prev_a)
a_end++;
if (s[0] == 'B') {
b_start++;
if (prev_a)
atob++;
}
}
// cout << ans << a_end << b_start << atob << endl;
if (atob == a_end && atob == b_start && atob > 0)
ans--;
cout << ans + min(a_end, b_start) << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.branch.if.condition.change"
] | 866,671 | 866,672 | u911446944 | cpp |
p03049 | #include <iostream>
using namespace std;
int main(void) {
long long i, j, l, N, a, b, c, ans;
cin >> N;
string s;
a = 0;
b = 0;
c = 0;
ans = 0;
for (i = 0; i < N; i++) {
cin >> s;
l = s.length();
for (j = 0; j < l - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans++;
}
}
if (s[0] == 'B' && s[l - 1] == 'A') {
c++;
} else if (s[0] == 'B') {
b++;
} else if (s[l - 1] == 'A') {
a++;
}
}
if (a > 0) {
ans += c;
ans += min(a, b);
} else {
ans += c - 1;
if (b > 0) {
ans++;
}
}
cout << ans << endl;
} | #include <iostream>
using namespace std;
int main(void) {
long long i, j, l, N, a, b, c, ans;
cin >> N;
string s;
a = 0;
b = 0;
c = 0;
ans = 0;
for (i = 0; i < N; i++) {
cin >> s;
l = s.length();
for (j = 0; j < l - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans++;
}
}
if (s[0] == 'B' && s[l - 1] == 'A') {
c++;
} else if (s[0] == 'B') {
b++;
} else if (s[l - 1] == 'A') {
a++;
}
}
if (a > 0) {
ans += c;
ans += min(a, b);
} else if (c > 0) {
ans += c - 1;
if (b > 0) {
ans++;
}
}
cout << ans << endl;
}
| [
"control_flow.branch.if.add"
] | 866,681 | 866,682 | u965103758 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define MIN(a, b) (a > b ? b : a)
int main(void) {
int N;
cin >> N;
int c = 0, A = 0, B = 0, AB = 0;
for (int i = 0; i < N; i++) {
string si;
cin >> si;
for (int i = 0; i < si.length(); i++)
if (i < si.length() - 1 && si[i] == 'A' && si[i + 1] == 'B')
c++;
if (si.front() == 'B' && si.back() == 'A')
AB++;
else if (si.front() == 'B')
B++;
else if (si.back() == 'A')
A++;
}
if (AB == 0)
cout << c + MIN(A, B) << endl;
else {
if (A > 0) {
c++;
A--;
}
if (B > 0) {
c++;
B--;
}
if (A == B)
cout << c + AB - 1 + A << endl;
else
cout << c + AB - 1 + MIN(A, B) + 1 << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MIN(a, b) (a > b ? b : a)
int main(void) {
int N;
cin >> N;
int c = 0, A = 0, B = 0, AB = 0;
for (int i = 0; i < N; i++) {
string si;
cin >> si;
for (int i = 0; i < si.length(); i++)
if (i < si.length() - 1 && si[i] == 'A' && si[i + 1] == 'B')
c++;
if (si.front() == 'B' && si.back() == 'A')
AB++;
else if (si.front() == 'B')
B++;
else if (si.back() == 'A')
A++;
}
if (AB == 0)
cout << c + MIN(A, B) << endl;
else {
if (A > 0) {
c++;
A--;
}
if (B > 0) {
c++;
B--;
}
if (A == B)
cout << c + AB - 1 + A << endl;
else
cout << c + AB - 1 + MIN(A, B) << endl;
}
return 0;
}
| [
"expression.operation.binary.remove"
] | 866,683 | 866,684 | u166060166 | cpp |
p03049 | #include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
typedef uint_fast64_t u64;
typedef int_fast64_t i64;
typedef uint_least32_t u32;
typedef int_fast32_t i32;
typedef uint_least16_t u16;
typedef int_fast16_t i16;
typedef uint_least8_t u8;
typedef int_fast8_t i8;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
u64 n;
std::cin >> n;
std::vector<std::pair<bool, bool>> strs(n);
std::string s;
u64 cnt = 0, cb = 0, ca = 0, ct = 0, cn = 0;
for (u64 i = 0; i < n; ++i) {
std::cin >> s;
for (u64 i = 0; i < s.size() - 1; ++i)
if (s[i] == 'A' && s[i + 1] == 'B')
++cnt;
strs[i] = std::make_pair(s.back() == 'A', s[0] == 'B');
if (s.back() == 'A' && s[0] == 'B')
ct++;
else if (s.back() == 'A')
ca++;
else if (s[0] == 'B')
cb++;
else
cn++;
}
bool sta = false;
if (ca != 0) {
sta = true;
--ca;
} else if (cn != 0)
--cn;
else if (ct != 0) {
sta = true;
--ct;
} else
--cb;
while (ct != 0) {
if (sta)
++cnt;
--ct;
sta = true;
}
if (cb != 0) {
--cb;
++cnt;
}
while (cb != 0 && ca != 0) {
--cb;
--ca;
++cnt;
}
std::cout << cnt << std::endl;
return 0;
} | #include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
typedef uint_fast64_t u64;
typedef int_fast64_t i64;
typedef uint_least32_t u32;
typedef int_fast32_t i32;
typedef uint_least16_t u16;
typedef int_fast16_t i16;
typedef uint_least8_t u8;
typedef int_fast8_t i8;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
u64 n;
std::cin >> n;
std::vector<std::pair<bool, bool>> strs(n);
std::string s;
u64 cnt = 0, cb = 0, ca = 0, ct = 0, cn = 0;
for (u64 i = 0; i < n; ++i) {
std::cin >> s;
for (u64 i = 0; i < s.size() - 1; ++i)
if (s[i] == 'A' && s[i + 1] == 'B')
++cnt;
strs[i] = std::make_pair(s.back() == 'A', s[0] == 'B');
if (s.back() == 'A' && s[0] == 'B')
ct++;
else if (s.back() == 'A')
ca++;
else if (s[0] == 'B')
cb++;
else
cn++;
}
bool sta = false;
if (ca != 0) {
sta = true;
--ca;
} else if (cn != 0)
--cn;
else if (ct != 0) {
sta = true;
--ct;
} else
--cb;
while (ct != 0) {
if (sta)
++cnt;
--ct;
sta = true;
}
if (sta && cb != 0) {
--cb;
++cnt;
}
while (cb != 0 && ca != 0) {
--cb;
--ca;
++cnt;
}
std::cout << cnt << std::endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 866,689 | 866,690 | u937736903 | cpp |
p03049 | #include <bits/stdc++.h>
#define ll long long
#define PB push_back
#define MP make_pair
#define ff first
#define ss second
#define pri 1000000007
using namespace std;
void run() {
ll n;
cin >> n;
string s;
ll ans = 0;
ll se[3] = {0};
for (ll i = 0; i < n; i++) {
cin >> s;
ll x = s.length();
for (ll j = 0; j < x; j++) {
if (j != x - 1) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans++;
}
}
}
if (s[0] == 'B' && s[x - 1] == 'A')
se[2]++;
else if (s[0] == 'B')
se[0]++;
else if (s[x - 1] == 'A')
se[1]++;
}
ll sa = 0;
ll sw = 1;
if (se[1] == 0) {
if (se[2] != 0)
sa = se[2] - 1 + min(se[0], sw);
else {
sa = 0;
}
} else {
if (se[0] == 0)
sa = se[2];
else {
se[1]--;
se[0]--;
sa = se[2] + 1;
sa += min(se[1], se[2]);
}
}
cout << ans + sa;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t = 1;
// cin>>t;
for (ll i = 0; i < t; i++)
run();
// your code goes here
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define PB push_back
#define MP make_pair
#define ff first
#define ss second
#define pri 1000000007
using namespace std;
void run() {
ll n;
cin >> n;
string s;
ll ans = 0;
ll se[3] = {0};
for (ll i = 0; i < n; i++) {
cin >> s;
ll x = s.length();
for (ll j = 0; j < x; j++) {
if (j != x - 1) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans++;
}
}
}
if (s[0] == 'B' && s[x - 1] == 'A')
se[2]++;
else if (s[0] == 'B')
se[0]++;
else if (s[x - 1] == 'A')
se[1]++;
}
ll sa = 0;
ll sw = 1;
if (se[1] == 0) {
if (se[2] != 0) {
sa = se[2] - 1 + min(se[0], sw);
}
else {
sa = 0;
}
} else {
if (se[0] == 0)
sa = se[2];
else {
se[1]--;
se[0]--;
sa = se[2] + 1;
sa += min(se[1], se[0]);
}
}
cout << ans + sa;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t = 1;
// cin>>t;
for (ll i = 0; i < t; i++)
run();
// your code goes here
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 866,691 | 866,692 | u874786170 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll MOD = 1e9 + 7;
int main() {
int n;
int ans = 0;
string s[10000];
int fb = 0;
int la = 0;
int fbla = 0;
cin >> n;
for (int i = 0; i < n; i++)
cin >> s[i];
for (int i = 0; i < n; i++) {
if (s[i][s[i].size() - 1] == 'A' && s[i][0] == 'B')
fbla++;
else if (s[i][0] == 'B')
fb++;
else if (s[i][s[i].size() - 1] == 'A')
la++;
int j = 0;
while (j < s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
j++;
}
}
ans += min(fb, la);
fb -= min(fb, la);
la -= min(fb, la);
if (fb > 0 || la > 0)
ans += fbla;
else
ans += fbla - 1;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll MOD = 1e9 + 7;
int main() {
int n;
int ans = 0;
string s[10000];
int fb = 0;
int la = 0;
int fbla = 0;
cin >> n;
for (int i = 0; i < n; i++)
cin >> s[i];
for (int i = 0; i < n; i++) {
if (s[i][s[i].size() - 1] == 'A' && s[i][0] == 'B')
fbla++;
else if (s[i][0] == 'B')
fb++;
else if (s[i][s[i].size() - 1] == 'A')
la++;
int j = 0;
while (j < s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
j++;
}
}
ans += min(fb, la);
fb -= min(fb, la);
la -= min(fb, la);
if (fb > 0 || la > 0)
ans += fbla;
else if (fbla > 1)
ans += fbla - 1;
cout << ans << endl;
return 0;
} | [
"control_flow.branch.if.add"
] | 866,693 | 866,694 | u863507492 | cpp |
p03049 |
#include <bits/stdc++.h>
using namespace std;
#define inf 1000000000
#define INF 1000000000000000
#define ll long long
#define ull unsigned long long
#define M (int)(1e9 + 7)
#define P pair<int, int>
#define PLL pair<ll, ll>
#define FOR(i, m, n) for (int i = (int)m; i < (int)n; i++)
#define RFOR(i, m, n) for (int i = (int)m; i >= (int)n; i--)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) RFOR(i, n, 0)
#define all(a) a.begin(), a.end()
#define IN(a, n) \
rep(i, n) { cin >> a[i]; }
const int vx[4] = {0, 1, 0, -1};
const int vy[4] = {1, 0, -1, 0};
#define PI 3.14159265
#define F first
#define S second
#define PB push_back
#define EB emplace_back
#define int ll
void init() {
cin.tie(0);
ios::sync_with_stdio(false);
}
int n;
int ans = 0;
int a = 0, b = 0;
int ba = 0;
main() {
cin >> n;
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')
b++;
if (s[s.size() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
ba++;
}
// cout<<ans<<' '<<a<<' '<<b<<endl;
if (a > 0 && b > 0) {
ans += min(a, b);
}
if (ans > 0 && a == b && a == ba)
cout << ans - 1 << endl;
else
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define inf 1000000000
#define INF 1000000000000000
#define ll long long
#define ull unsigned long long
#define M (int)(1e9 + 7)
#define P pair<int, int>
#define PLL pair<ll, ll>
#define FOR(i, m, n) for (int i = (int)m; i < (int)n; i++)
#define RFOR(i, m, n) for (int i = (int)m; i >= (int)n; i--)
#define rep(i, n) FOR(i, 0, n)
#define rrep(i, n) RFOR(i, n, 0)
#define all(a) a.begin(), a.end()
#define IN(a, n) \
rep(i, n) { cin >> a[i]; }
const int vx[4] = {0, 1, 0, -1};
const int vy[4] = {1, 0, -1, 0};
#define PI 3.14159265
#define F first
#define S second
#define PB push_back
#define EB emplace_back
#define int ll
void init() {
cin.tie(0);
ios::sync_with_stdio(false);
}
int n;
int ans = 0;
int a = 0, b = 0;
int ba = 0;
main() {
cin >> n;
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')
b++;
if (s[s.size() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
ba++;
}
// cout<<ans<<' '<<a<<' '<<b<<endl;
if (a > 0 && b > 0) {
ans += min(a, b);
}
if (ans > 0 && a > 0 && a == b && a == ba)
cout << ans - 1 << endl;
else
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 866,697 | 866,698 | u229842440 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef vector<vector<long long>> vvll;
typedef vector<pair<int, int>> vpii;
typedef pair<int, int> pii;
typedef long long ll;
typedef pair<ll, ll> pll;
#define INF 1000000000LL
#define MOD 1000000007
#define EPSILON 0.00001
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define p_q priority_queue
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define RFOR(i, a, b) for (int i = (a); i >= b; i--)
#define MN 10005
int n;
string s[MN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int ae = 0, bs = 0, both = 0;
ll cnt = 0;
cin >> n;
F0R(i, n) {
cin >> s[i];
F0R(j, s[i].length() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
cnt++;
}
if (s[i][0] == 'B' && s[i][s[i].length() - 1] == 'A')
both++;
else if (s[i][0] == 'B')
bs++;
else if (s[i][s[i].length() - 1] == 'A')
ae++;
}
if (bs == 0 && ae == 0) {
cnt += both - 1;
} else {
cnt += min(n - 1, min(bs, ae) + both);
}
cout << cnt << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef vector<vector<long long>> vvll;
typedef vector<pair<int, int>> vpii;
typedef pair<int, int> pii;
typedef long long ll;
typedef pair<ll, ll> pll;
#define INF 1000000000LL
#define MOD 1000000007
#define EPSILON 0.00001
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define p_q priority_queue
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define RFOR(i, a, b) for (int i = (a); i >= b; i--)
#define MN 10005
int n;
string s[MN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int ae = 0, bs = 0, both = 0;
ll cnt = 0;
cin >> n;
F0R(i, n) {
cin >> s[i];
F0R(j, s[i].length() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
cnt++;
}
if (s[i][0] == 'B' && s[i][s[i].length() - 1] == 'A')
both++;
else if (s[i][0] == 'B')
bs++;
else if (s[i][s[i].length() - 1] == 'A')
ae++;
}
if (bs == 0 && ae == 0) {
cnt += max(0, both - 1);
} else {
cnt += min(n - 1, min(bs, ae) + both);
}
cout << cnt << "\n";
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 866,699 | 866,700 | u396284099 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define pb push_back
#define rep(i, s, n) for (int i = s; i < n; i++)
#define rrep(i, s, n) for (int i = (n)-1; i >= (s); i--)
#define all(a) a.begin(), a.end()
typedef pair<int, int> pint;
typedef vector<int> vint;
typedef vector<pint> vpint;
const long long MOD = 1000000007, INF = 1e17;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
//******************************************************************************
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
signed main() {
int N;
cin >> N;
string s[N];
rep(i, 0, N) { cin >> s[i]; }
int ans = 0;
int BA = 0, B = 0, A = 0;
rep(i, 0, N) {
rep(j, 0, s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j] == 'B')
ans++;
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
BA++;
if (s[i][0] == 'B')
B++;
if (s[i][s[i].size() - 1] == 'A')
A++;
}
int t = 0;
if (BA)
t = BA - 1;
if (BA) {
if (A) {
A--;
t++;
}
if (B) {
B--;
t++;
}
}
cout << ans + t + min(A, B) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define pb push_back
#define rep(i, s, n) for (int i = s; i < n; i++)
#define rrep(i, s, n) for (int i = (n)-1; i >= (s); i--)
#define all(a) a.begin(), a.end()
typedef pair<int, int> pint;
typedef vector<int> vint;
typedef vector<pint> vpint;
const long long MOD = 1000000007, INF = 1e17;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
//******************************************************************************
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
signed main() {
int N;
cin >> N;
string s[N];
rep(i, 0, N) { cin >> s[i]; }
int ans = 0;
int BA = 0, B = 0, A = 0;
rep(i, 0, N) {
rep(j, 0, s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
ans++;
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
BA++;
else if (s[i][0] == 'B')
B++;
else if (s[i][s[i].size() - 1] == 'A')
A++;
}
int t = 0;
if (BA)
t = BA - 1;
if (BA) {
if (A) {
A--;
t++;
}
if (B) {
B--;
t++;
}
}
cout << ans + t + min(A, B) << endl;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 866,701 | 866,702 | u693027786 | cpp |
p03049 | // Krzysztof Boryczka
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
#define FOR(i, b, e) for (int i = b; i <= e; i++)
#define FORD(i, b, e) for (int i = b; i >= e; i--)
#define SIZE(x) ((int)x.size())
#define pb push_back
#define st first
#define nd second
#define sp ' '
#define ent '\n'
// END OF TEMPLATE
int a, b, both, ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
string s;
cin >> n;
FOR(j, 1, n) {
cin >> s;
if (s[0] == 'B' && s[SIZE(s) - 1] == 'A')
both++;
else if (s[0] == 'B')
b++;
else if (s[SIZE(s) - 1] == 'A')
a++;
FOR(i, 0, SIZE(s) - 2) {
if (s[i] == 'A' && s[i + 1] == 'B')
ans++;
}
}
if (a == 0 && b == 0)
ans += min(both - 1, 0);
else
ans += both + min(a, b);
cout << ans << ent;
return 0;
}
| // Krzysztof Boryczka
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
const int inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3f;
#define FOR(i, b, e) for (int i = b; i <= e; i++)
#define FORD(i, b, e) for (int i = b; i >= e; i--)
#define SIZE(x) ((int)x.size())
#define pb push_back
#define st first
#define nd second
#define sp ' '
#define ent '\n'
// END OF TEMPLATE
int a, b, both, ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
string s;
cin >> n;
FOR(j, 1, n) {
cin >> s;
if (s[0] == 'B' && s[SIZE(s) - 1] == 'A')
both++;
else if (s[0] == 'B')
b++;
else if (s[SIZE(s) - 1] == 'A')
a++;
FOR(i, 0, SIZE(s) - 2) {
if (s[i] == 'A' && s[i + 1] == 'B')
ans++;
}
}
if (a == 0 && b == 0)
ans += max(both - 1, 0);
else
ans += both + min(a, b);
cout << ans << ent;
return 0;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 866,703 | 866,704 | u628218255 | cpp |
p03049 | #include <bits/stdc++.h>
#define CEIL(a, b) ((a) / (b) + ((a) % (b) == 0 ? 0 : 1))
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pcc = pair<char, char>;
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'000'000'001;
constexpr ll LLINF = 4'000'000'000'000'000'001;
// constexpr int INF = 2147483647; // 2 * 1e9
// constexpr ll LLINF = 9223372036854775807; // 9 * 1e18
const int dx[] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(10);
int n;
cin >> n;
vector<string> s(n);
int a = 0, b = 0, ab = 0, ans = 0;
for (int i = 0; i < n; ++i) {
cin >> s[i];
if (s[i].back() == 'A' && s[i][0] == 'B')
++ab;
else if (s[i].back() == 'A')
++a;
else if (s[i][0] == 'B')
++b;
for (int j = 0; j < s[i].size() - 1; ++j) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
++ans;
}
}
if (a > 0 && b > 0) {
ans += ab + 1 + min(a, b) - 1;
} else if (a > 0 || b > 0) {
ans += ab;
} else {
ans += ab - 1;
}
cout << ans << "\n";
return 0;
} | #include <bits/stdc++.h>
#define CEIL(a, b) ((a) / (b) + ((a) % (b) == 0 ? 0 : 1))
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pcc = pair<char, char>;
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'000'000'001;
constexpr ll LLINF = 4'000'000'000'000'000'001;
// constexpr int INF = 2147483647; // 2 * 1e9
// constexpr ll LLINF = 9223372036854775807; // 9 * 1e18
const int dx[] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(10);
int n;
cin >> n;
vector<string> s(n);
int a = 0, b = 0, ab = 0, ans = 0;
for (int i = 0; i < n; ++i) {
cin >> s[i];
if (s[i].back() == 'A' && s[i][0] == 'B')
++ab;
else if (s[i].back() == 'A')
++a;
else if (s[i][0] == 'B')
++b;
for (int j = 0; j < s[i].size() - 1; ++j) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
++ans;
}
}
if (a > 0 && b > 0) {
ans += ab + 1 + min(a, b) - 1;
} else if (a > 0 || b > 0) {
ans += ab;
} else {
ans += max(0, ab - 1);
}
cout << ans << "\n";
return 0;
} | [
"call.add",
"call.arguments.change"
] | 866,707 | 866,708 | u993640894 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, ans = 0, endA = 0, beginB = 0, same = 0;
cin >> N;
for (int i = 0; i < N; i++) {
string S;
cin >> S;
for (int j = 0; j < S.length() - 2; j++) {
if (S[j] == 'A' && S[j + 1] == 'B')
ans++;
}
if (S[0] == 'B')
beginB++;
if (S[S.length() - 1] == 'A')
endA++;
if (S[0] == 'B' && S[S.length() - 1] == 'A')
same++;
}
if (endA == beginB && endA == same)
ans += endA - 1;
else
ans += min(endA, beginB);
cout << ans << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, ans = 0, endA = 0, beginB = 0, same = 0;
cin >> N;
for (int i = 0; i < N; i++) {
string S;
cin >> S;
for (int j = 0; j <= S.length() - 2; j++) {
if (S[j] == 'A' && S[j + 1] == 'B')
ans++;
}
if (S[0] == 'B')
beginB++;
if (S[S.length() - 1] == 'A')
endA++;
if (S[0] == 'B' && S[S.length() - 1] == 'A')
same++;
}
if (endA == beginB && endA == same && endA != 0)
ans += endA - 1;
else
ans += min(endA, beginB);
cout << ans << "\n";
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 866,709 | 866,710 | u501643136 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
int main() {
int N;
cin >> N;
vector<string> S(N);
for (auto &s : S)
cin >> s;
int a = 0, b = 0, c = 0, ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 1; j < S[i].size(); j++) {
if (S[i][j - 1] == 'A' && S[i][j] == 'B')
ans++;
}
if (S[i].back() == 'A' && S[i].front() == 'B')
c++;
else if (S[i].back() == 'A')
a++;
else if (S[i].front() == 'B')
b++;
}
if (a == 0 && b == 0)
ans += c - 1;
else
ans += min(a + c, b + c);
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
int main() {
int N;
cin >> N;
vector<string> S(N);
for (auto &s : S)
cin >> s;
int a = 0, b = 0, c = 0, ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 1; j < S[i].size(); j++) {
if (S[i][j - 1] == 'A' && S[i][j] == 'B')
ans++;
}
if (S[i].back() == 'A' && S[i].front() == 'B')
c++;
else if (S[i].back() == 'A')
a++;
else if (S[i].front() == 'B')
b++;
}
if (a == 0 && b == 0)
ans += max(0, c - 1);
else
ans += min(a + c, b + c);
cout << ans << '\n';
return 0;
} | [
"call.add",
"call.arguments.change"
] | 866,711 | 866,712 | u449722246 | cpp |
p03049 | //#include "pch.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <bitset>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define fri(n) for (i = 0; i < (n); i++)
#define frj(n) for (j = 0; j < (n); i++)
#define min(p, q) ((p) < (q) ? (p) : (q))
#define max(p, q) ((p) > (q) ? (p) : (q))
#define INF 1000000000000000000 // 10^18
#define INFINT 2000000001 // 2*10^9+1
#define MOD 1000000007
#define MODANOTHER 998244353
#define PI acos(-1)
using namespace std;
int main(void) {
//変数の宣言
int n;
int a = 0;
int b = 0;
int c = 0;
char s[15];
//よく使う変数
int i, j, k, l;
int flag = 0;
int ans = 0;
int count = 0;
int temp = 0;
int temp1 = 0;
int temp2 = 0;
int max = 0;
int min = INFINT;
int len = 0;
int sum = 0;
int ok = 0;
int ng = 0;
char dummy;
//データの読み込み
scanf("%d", &n);
// scanf_s("%d",&n);
// scanf("%s",&s);
// scanf_s("%s",&s,200010);
// scanf("%c",&dummy);
// scanf_s("%c",&dummy);
for (i = 0; i < n; i++) {
scanf("%s", &s);
// scanf_s("%s",&s,15);
len = strlen(s);
for (j = 0; j < len - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans++;
}
}
if (s[0] == 'B') {
if (s[len - 1] == 'A') {
c++;
} else {
b++;
}
} else if (s[len - 1] == 'A') {
a++;
}
}
/* for(i=0;i<n;i++){
// scanf("%c",&t[i]);
scanf_s("%c",&t[i]);
}*/
// printf("nは%dです\n", n);
// printf("データの読み込み終了\n");
//実際の処理
// printf("a=%d b=%d c=%d ans=%d\n",a,b,c,ans);
ans = ans + c + min(a, b);
if (a == 0 && b == 0) {
ans = ans - 1;
}
// printf("計算部分終了\n");
//出力
printf("%d", ans);
// C printf("\nL=%d,R=%d,D=%d,U=%d\n",L,R,D,U);
// printf("結果の出力終了\n");
return 0;
}
| //#include "pch.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <bitset>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define ll long long
#define fri(n) for (i = 0; i < (n); i++)
#define frj(n) for (j = 0; j < (n); i++)
#define min(p, q) ((p) < (q) ? (p) : (q))
#define max(p, q) ((p) > (q) ? (p) : (q))
#define INF 1000000000000000000 // 10^18
#define INFINT 2000000001 // 2*10^9+1
#define MOD 1000000007
#define MODANOTHER 998244353
#define PI acos(-1)
using namespace std;
int main(void) {
//変数の宣言
int n;
int a = 0;
int b = 0;
int c = 0;
char s[15];
//よく使う変数
int i, j, k, l;
int flag = 0;
int ans = 0;
int count = 0;
int temp = 0;
int temp1 = 0;
int temp2 = 0;
int max = 0;
int min = INFINT;
int len = 0;
int sum = 0;
int ok = 0;
int ng = 0;
char dummy;
//データの読み込み
scanf("%d", &n);
// scanf_s("%d",&n);
// scanf("%s",&s);
// scanf_s("%s",&s,200010);
// scanf("%c",&dummy);
// scanf_s("%c",&dummy);
for (i = 0; i < n; i++) {
scanf("%s", &s);
// scanf_s("%s",&s,15);
len = strlen(s);
for (j = 0; j < len - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans++;
}
}
if (s[0] == 'B') {
if (s[len - 1] == 'A') {
c++;
} else {
b++;
}
} else if (s[len - 1] == 'A') {
a++;
}
}
/* for(i=0;i<n;i++){
// scanf("%c",&t[i]);
scanf_s("%c",&t[i]);
}*/
// printf("nは%dです\n", n);
// printf("データの読み込み終了\n");
//実際の処理
// printf("a=%d b=%d c=%d ans=%d\n",a,b,c,ans);
ans = ans + c + min(a, b);
if (a == 0 && b == 0 && c != 0) {
ans = ans - 1;
}
// printf("計算部分終了\n");
//出力
printf("%d", ans);
// C printf("\nL=%d,R=%d,D=%d,U=%d\n",L,R,D,U);
// printf("結果の出力終了\n");
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 866,713 | 866,714 | u705931757 | cpp |
p03049 | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
// cin.sync_with_stdio(false);
// streambuf
using namespace std;
typedef long long ll;
typedef double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using ti3 = tuple<int, int, int>;
using vti3 = vector<ti3>;
template <class T, int s> using va = vector<array<T, s>>;
template <class T, class T2> using umap = unordered_map<T, T2>;
template <class T> using uset = unordered_set<T>;
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
#define ALL(a) a.begin(), a.end()
#define rep(i, a) for (int i = 0; i < a; i++)
#define rep1(i, a) for (int i = 1; i <= a; i++)
#define rrep(i, a) for (int i = (a)-1; i >= 0; i--)
#define rrep1(i, a) for (int i = a; i; i--)
#define repi(i, a, b) for (int i = a; i < b; i++)
// const ll mod = 1000000007;
template <class T> using heap = priority_queue<T, vector<T>, greater<T>>;
template <class T> using pque = priority_queue<T, vector<T>, function<T(T, T)>>;
template <class T> inline void hash_combine(size_t &seed, const T &v) {
hash<T> hasher;
seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 6) + (seed >> 2);
}
namespace std {
template <typename S, typename T> struct hash<pair<S, T>> {
inline size_t operator()(const pair<S, T> &v) const {
size_t seed = 0;
hash_combine(seed, v.first);
hash_combine(seed, v.second);
return seed;
}
};
// Recursive template code derived from Matthieu M.
template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
struct HashValueImpl {
static void apply(size_t &seed, Tuple const &tuple) {
HashValueImpl<Tuple, Index - 1>::apply(seed, tuple);
hash_combine(seed, std::get<Index>(tuple));
}
};
template <class Tuple> struct HashValueImpl<Tuple, 0> {
static void apply(size_t &seed, Tuple const &tuple) {
hash_combine(seed, std::get<0>(tuple));
}
};
template <typename... TT> struct hash<std::tuple<TT...>> {
size_t operator()(std::tuple<TT...> const &tt) const {
size_t seed = 0;
HashValueImpl<std::tuple<TT...>>::apply(seed, tt);
return seed;
}
};
} // namespace std
template <class T> int id(vector<T> &a, T b) {
return lower_bound(ALL(a), b) - a.begin();
}
ll pow(ll base, ll i, ll mod) {
ll a = 1;
while (i) {
if (i & 1) {
a *= base;
a %= mod;
}
base *= base;
base %= mod;
i /= 2;
}
return a;
}
ll gcd(ll a, ll b) {
while (b) {
ll c = a % b;
a = b;
b = c;
}
return a;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
#ifdef _MSC_VER
#include <intrin.h>
#endif
int popcnt(unsigned long long a) {
#ifndef _MSC_VER
return __builtin_popcountll(a);
#elif defined _WIN64
return _mm_popcnt_u64(a);
#else
return _mm_popcnt_u32(a >> 32) + _mm_popcnt_u32(a);
a = (a & 0x5555555555555555) + (a >> 1 & 0x5555555555555555);
a = (a & 0x3333333333333333) + (a >> 2 & 0x3333333333333333);
a = (a & 0x0f0f0f0f0f0f0f0f) + (a >> 4 & 0x0f0f0f0f0f0f0f0f);
a = (a & 0x00ff00ff00ff00ff) + (a >> 8 & 0x00ff00ff00ff00ff);
a = (a & 0x0000ffff0000ffff) + (a >> 16 & 0x0000ffff0000ffff);
return (a & 0xffffffff) + (a >> 32);
#endif
}
int BitScanF(unsigned long long a) {
#ifndef _MSC_VER
return __builtin_ctzll(a);
#elif defined _WIN64
unsigned long ret;
_BitScanForward64(&ret, a);
return a;
#else
unsigned long ret;
if (!(unsigned long)a) {
_BitScanForward(&ret, a);
ret += 32;
} else
_BitScanForward(&ret, (unsigned long)a);
return ret;
#endif
}
int BitScanR(unsigned long long a) {
#ifndef _MSC_VER
return 63 - __builtin_clzll(a);
#elif defined _WIN64
unsigned long ret;
_BitScanReverse64(&ret, a);
return a;
#else
unsigned long ret;
if (a >> 32) {
_BitScanReverse(&ret, a);
ret += 32;
} else
_BitScanReverse(&ret, (unsigned long)a);
return ret;
#endif
}
template <class T> class matrix {
public:
vector<valarray<T>> obj;
pair<int, int> s;
public:
matrix(pair<int, int> size, T e = 0) : matrix(size.first, size.second, e) {}
matrix(int n, int m = -1, T e = 0)
: obj(n, valarray<T>(e, m == -1 ? n : m)), s(n, m == -1 ? n : m) {}
static matrix e(int n) {
matrix a = (n);
for (int i = 0; i < n; i++)
a[i][i] = 1;
return a;
}
matrix &operator+=(const matrix &p) {
if (s != p.s)
throw runtime_error("matrix error");
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
obj[i][j] += p.obj[i][j];
return *this;
}
matrix operator+(const matrix &p) {
matrix res(*this);
return res += p;
}
matrix &operator-=(const matrix &p) {
if (s != p.s)
throw runtime_error("matrix error");
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
obj[i][j] -= p.obj[i][j];
return *this;
}
matrix operator-(const matrix &p) {
matrix res(*this);
return res -= p;
}
matrix &operator*=(T p) {
for (auto &a : obj)
for (auto &b : a)
b *= p;
return *this;
}
matrix operator*(T p) {
matrix res(*this);
return res *= p;
}
matrix operator*(const matrix &p) {
if (s.second != p.s.first)
throw runtime_error("matrix error");
matrix ret(s.first, p.s.second);
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
ret[i] += obj[i][j] * p.obj[j];
return ret;
}
matrix &operator*=(const matrix &p) { return *this = *this * p; }
bool operator==(const matrix &p) {
if (s != p.s)
return 0;
for (int i = 0; i < s.first; i++)
for (int j; j < s.second; j++)
if (obj[i][j] != p.obj[i][j])
return 0;
return 1;
}
pair<int, int> size() const { return s; }
matrix &mod(T m) {
for (auto &a : obj)
for (auto &b : a)
b %= m;
return *this;
}
valarray<T> &operator[](int t) { return obj[t]; }
void gauss() {
if (size().first + 1 != size().second)
return;
rep(i, size().first) {
int p = i;
repi(j, i, size().first) if (abs(obj[j][i]) > abs(obj[p][i])) p = j;
swap(obj[i], obj[p]);
if (abs(obj[i][i]) < 1e-8)
return; // contniue;
repi(j, i + 1, size().second) obj[i][j] /= obj[i][i];
rep(j, size().first) {
if (i != j) {
repi(k, i + 1, size().second) obj[j][k] -= obj[j][i] * obj[i][k];
}
}
}
}
};
template <class T>
std::pair<matrix<T>, vector<int>> LU_decomposition(matrix<T> a) {
if (a.size().first != a.size().second)
throw runtime_error("matrix error");
std::vector<int> pi(a.size().first);
std::iota(ALL(pi), 0);
valarray<T> tmp(a.size().first);
for (int i = 0; i < a.size().first; i++) {
// int pivot = i;
// T max = abs(a[i][i]);
// for (int j = i + 1; j < a.size().first; j++) {
// if (max < abs(a[j][i])) {
// max = abs(a[j][i]);
// pivot = j;
// }
//}
// std::swap(i, pivot);
// pi.push_back(pivot);
std::slice slice(i + 1, a.size().first - i - 1, 1);
for (int j = i + 1; j < a.size().first; j++) {
tmp[slice] = a[i][slice];
tmp *= a[j][i] / a[i][i];
a[j][slice] -= tmp[slice];
a[j][i] = a[j][i] / a[i][i];
}
}
return std::make_pair(std::move(a), std::move(pi));
}
template <class T>
matrix<T> LU_solve(pair<matrix<T>, std::vector<int>> a, matrix<T> b) {
auto pi = std::move(a.second);
auto A = std::move(a.first);
if (A.size().first != A.size().second || A.size().first != b.size().first)
throw runtime_error("matrix error");
for (int i = 0; i < A.size().first; i++) {
std::swap(b[i], b[pi[i]]);
}
for (int i = 0; i < A.size().first; i++) {
for (int j = 0; j < i; j++)
b[i] -= A[i][j] * b[j];
}
for (int i = A.size().first - 1; i >= 0; i--) {
for (int j = i + 1; j < A.size().first; j++)
b[i] -= A[i][j] * b[j];
b[i] /= A[i][i];
}
return b;
}
template <class T>
inline matrix<T> pow(matrix<T> &base, unsigned long long exp) {
auto base_(base);
if (base_.size().first != base_.size().second)
throw runtime_error("matrix error");
matrix<T> res = matrix<T>::e(base_.size().first);
for (;;) {
if (exp & 1)
res *= base_;
if (res.obj[0].size() > 100) {
int a = 0;
}
if (!(exp /= 2))
break;
base_ *= base_;
}
return res;
}
template <class T>
inline matrix<T> modpow(matrix<T> &base, unsigned long long exp, ll m) {
auto base_(base);
if (base.size().first != base_.size().second)
throw runtime_error("matrix error");
matrix<T> res = matrix<T>::e(base_.size().first);
for (;;) {
if (exp & 1)
(res *= base_).mod(m);
if (res.obj[0].size() > 100) {
int a = 0;
}
if (!(exp /= 2))
break;
(base_ *= base_).mod(m);
}
return res;
}
class unionfind {
vector<int> par, rank,
size_; //速度ではなくメモリ効率を考えるならrankのかわりにsizeを使う
public:
unionfind(int n) : par(n), rank(n), size_(n, 1) { iota(ALL(par), 0); }
int find(int x) {
if (par[x] == 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 (rank[x] < rank[y])
swap(x, y);
par[y] = x;
size_[x] += size_[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return size_[find(x)]; }
};
// end of lib
// template<class S=void,int ptr_num, class T = char>class trie {
// umap<T, trie<S, ptr_num, T> next;
// public:
// S key;
// trie<S, ptr_num, T>* ptr[ptr_num] = {};
// trie(S &&data) :key(data) {}
// trie(const S &data) :key(data) {}
// void add(T x,S data) {
// if (!next.find(x))next.insert(x, data);
// }
// trie& operator[](T x) {
// return next[x];
// }
// bool find(T x) {
// retun next.find(x);
// }
//};
// template<class T=char>class AhoCorasick {
// trie<pair<bool,int>, 2, T> tree;
// AhoCorasick(vector<string> p) {
// int num = 0;
// vector<decltype(&tree)> que(p.size(),&tree);
// for (int i = 0;; i++) {
// bool end = 1;
// int i = 0;
// for (auto a : p) {
// if (i >= a.size())break;
// end = ;0
// que[i] = (*que[i])[a[i]];
// i++;
// }
// if (end)break;
// }
// }
//};
template <class T, class Func = function<T(T, T)>> class segtree {
vector<T> obj;
int offset;
Func updater;
T e;
int bufsize(int num) {
int i = 1;
for (; num > i; i <<= 1)
;
offset = i - 1;
return (i << 1) - 1;
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return obj[k];
else
return updater(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2, r));
}
public:
void propagate(int a, int b, int k, int l, int r, int p) {
if (r <= a || b <= l)
return;
if (a <= l && r <= b) {
obj[k].second += p;
(obj[k].first *= pow(2, p, (ll)1e9 + 7)) %= (ll)(1e9 + 7);
return;
} else {
if (obj[k].second) {
(obj[k * 2 + 1].first *= pow(2, obj[k].second, (ll)1e9 + 7)) %=
(ll)(1e9 + 7);
(obj[k * 2 + 2].first *= pow(2, obj[k].second, (ll)1e9 + 7)) %=
(ll)(1e9 + 7);
obj[k * 2 + 1].second += obj[k].second;
obj[k * 2 + 2].second += obj[k].second;
}
propagate(a, b, k * 2 + 1, l, (l + r) / 2, p),
propagate(a, b, k * 2 + 2, (l + r) / 2, r, p);
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}
T query(int a, int b) { //[a,b)
// propagate(a, b, 0);
return query(a, b, 0, 0, offset + 1);
}
void propagate(int a, int b, int p = 1) { //[a,b)
return propagate(a, b, 0, 0, offset + 1, p);
}
void updateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
if (l == 0)
return;
do {
l = l - 1 >> 1, r = r - 1 >> 1;
for (int i = l; i < r; i++)
obj[i] = updater(obj[i * 2 + 1], obj[i * 2 + 2]);
} while (l);
}
void update(int k, const T &a) {
// propagate(k, k + 1, 0);
k += offset;
obj[k] = a;
while (k) {
k = k - 1 >> 1;
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}
segtree(int n, T e, const Func &updater = Func())
: obj(bufsize(n), e), e(e), updater(updater) {}
segtree(vector<T> &vec, T e, const Func &updater = Func())
: obj(bufsize(vec.size()), e), e(e), updater(updater) {
copy(vec.begin(), vec.end(), obj.begin() + offset);
updateall();
}
T &operator[](int n) { return obj[n + offset]; }
};
template <class T = int>
class BIT { //多次元BITはループをネストすればいいらしい。
vector<T> bit;
public:
BIT(int n) : bit(n + 1, 0) {}
void add(int i, T x) {
i++;
while (i <= bit.size()) {
bit[i - 1] += x;
i += i & -i;
}
}
T sum(int i) {
T s = 0;
i++;
while (i) {
s += bit[i - 1];
i &= i - 1;
}
return s;
}
};
template <class T> class rangeadd {
BIT<T> b0, b1;
int n;
rangeadd(int n) : b0(n), b1(n), n(n) {}
void add(int l, int r, T x) { //[l,r)
b0.add(l, -x(l - 1));
b1.add(l, x);
b0.add(r, x * r);
b1.add(r, -x);
}
T sum(int i) { return b0.sum(i) + b1.sum(i) * i; }
};
class Flow {
int V;
struct edge {
int to, cap, rev, cost, add;
};
vector<vector<edge>> G;
vector<int> level, iter, h, dist, prevv, preve;
void bfs(int s) {
fill(level.begin(), level.end(), -1);
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
int dfs(int v, int t, int f) {
if (v == t)
return f;
for (int &i = iter[v]; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int res = 0;
int flow = 0;
int s, t;
int max_flow(int s, int t, int fmax = numeric_limits<int>::max()) {
level.resize(V);
iter.resize(V);
for (;;) {
bfs(s);
if (level[t] < 0)
return flow;
fill(iter.begin(), iter.end(), 0);
int f;
while ((f = dfs(s, t, fmax)) > 0) {
flow += f;
fmax -= f;
}
if (fmax == 0)
return flow;
}
}
typedef pair<int, int> P;
int min_cost_flow(int s, int t, int f) {
h.resize(V);
dist.resize(V);
prevv.resize(V);
preve.resize(V);
fill(h.begin(), h.end(), 0);
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
fill(dist.begin(), dist.end(), numeric_limits<int>::max());
dist[s] = 0;
que.push({0, s});
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push({dist[e.to], e.to});
}
}
}
if (dist[t] == numeric_limits<int>::max()) {
return -1;
}
for (int v = 0; v < V; v++)
h[v] += dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
public:
Flow(int size, int s, int t) : G(size + 1), V(size + 1), s(s), t(t) {}
void add_edge(int from, int to, int cap, int cost = 0) {
G[from].push_back(edge{to, cap, (int)G[to].size(), cost, 1});
G[to].push_back(edge{from, 0, (int)G[from].size() - 1, -cost, 0});
}
void remove_edge_max(int from, int to, int cap, int cost = 0) {
for (auto &x : G[from]) {
if (!x.add || x.to != to || x.cap + G[to][x.rev].cap != cap ||
x.cost != cost)
continue;
int prev = flow;
int cap = G[to][x.rev].cap;
G[to][x.rev].cap = 0;
x.cap = 0;
cap -= max_flow(from, to, cap) - prev;
max_flow(t, to, cap);
max_flow(from, s, cap);
flow = prev - cap;
break;
}
}
void remove_edge_cost(int from, int to, int cap, int cost = 0) {
for (auto &x : G[from]) {
if (!x.add || x.to != to || x.cap + G[to][x.rev].cap != cap ||
x.cost != cost)
continue;
cost += G[to][x.rev].cap * G[to][x.rev].cost;
int cap = G[to][x.rev].cap;
G[to][x.rev].cap = 0;
x.cap = 0;
min_cost_flow(from, to, cap);
break;
}
}
int max_flow() { return max_flow(s, t); }
int min_cost_flow(int f) { return min_cost_flow(s, t, f); }
};
ll extgcd(ll a, ll b, ll &x, ll &y) {
int d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
ll mod_inv(ll a, ll m) {
ll x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
pll linear_congruence(const vector<ll> &A, const vll &B, const vll &M) {
ll x = 0, m = 1;
for (int i = 0; i < A.size(); i++) {
ll a = A[i] * m, b = B[i] - A[i] * x, d = gcd(M[i], a);
if (b % d != 0)
return make_pair(0, -1);
ll t = b / d * mod_inv(a / d, M[i] / d) % (M[i] / d);
// if (x + m * t < 0)return pll(x%m, m);
x = x + m * t;
m *= M[i] / d;
}
return make_pair(x % m, m);
}
typedef complex<ld> P;
typedef vector<P> VP;
const ld eps = 1e-11, pi = acos(-1.0);
ld dot(P a, P b) { return real(conj(a) * b); }
ld cross(P a, P b) { return imag(conj(a) * b); }
namespace std {
bool operator<(const P &a, const P &b) {
return abs(a.real() - b.real()) < eps ? a.imag() < b.imag()
: a.real() < b.real();
}
} // namespace std
struct L {
P a, b;
}; // line->l,segment->s
struct C {
P p;
ld r;
};
int ccw(P a, P b, P c) {
b -= a;
c -= a;
if (cross(b, c) > eps)
return 1; // counter clockwise
if (cross(b, c) < -eps)
return -1; // clockwise
if (dot(b, c) < 0)
return 2; // c--a--b on line
if (norm(b) < norm(c))
return -2; // a--b--c on line
return 0; // a--c--b on line
}
bool isis_ll(L l, L m) { // is intersect
return abs(cross(l.b - l.a, m.b - m.a)) > eps;
}
bool isis_ls(L l, L s) {
ld a = cross(l.b - l.a, s.a - l.a);
ld b = cross(l.b - l.a, s.b - l.a);
return (a * b < eps);
}
bool isis_lp(L l, P p) { return abs(cross(l.b - p, l.a - p)) < eps; }
bool isis_ss(L s, L t) {
return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}
P is_ll(L s, L t) { // intersect
P sv = s.b - s.a, tv = t.b - t.a;
return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}
bool isis_sp(L s, P p) {
return abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps;
}
P proj(L l, P p) {
ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
return l.a + t * (l.a - l.b);
}
ld dist_lp(L l, P p) { return abs(p - proj(l, p)); }
ld dist_ll(L l, L m) { return isis_ll(l, m) ? 0 : dist_lp(l, m.a); }
ld dist_ls(L l, L s) {
if (isis_ls(l, s))
return 0;
return min(dist_lp(l, s.a), dist_lp(l, s.b));
}
ld dist_sp(L s, P p) {
P r = proj(s, p);
if (isis_sp(s, r))
return abs(r - p);
return min(abs(s.a - p), abs(s.b - p));
}
ld dist_ss(L s, L t) {
if (isis_ss(s, t))
return 0;
ld a = min(dist_sp(s, t.a), dist_sp(t, s.a));
ld b = min(dist_sp(s, t.b), dist_sp(t, s.b));
return min(a, b);
}
VP is_cc(C c1, C c2) {
VP res;
ld d = abs(c1.p - c2.p);
ld rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
ld dfr = c1.r * c1.r - rc * rc;
if (abs(dfr) < eps)
dfr = 0.0;
else if (dfr < 0.0)
return res; // no intersection
ld rs = sqrt(dfr);
P diff = (c2.p - c1.p) / d;
res.push_back(c1.p + diff * P(rc, rs));
if (dfr != 0.0)
res.push_back(c1.p + diff * P(rc, -rs));
return res;
}
bool isis_vc(vector<C> vc) {
VP crs;
int n = vc.size();
rep(i, n) rep(j, i) for (P p : is_cc(vc[i], vc[j])) crs.push_back(p);
rep(i, n) crs.push_back(vc[i].p);
for (P p : crs) {
bool valid = true;
rep(i, n) if (abs(p - vc[i].p) > vc[i].r + eps) valid = false;
if (valid)
return true;
}
return false;
}
VP is_lc(C c, L l) {
VP res;
ld d = dist_lp(l, c.p);
if (d < c.r + eps) {
ld len = (d > c.r) ? 0.0 : sqrt(c.r * c.r - d * d); // safety;
P nor = (l.a - l.b) / abs(l.a - l.b);
res.push_back(proj(l, c.p) + len * nor);
res.push_back(proj(l, c.p) - len * nor);
}
return res;
}
VP is_sc(C c, L l) {
VP v = is_lc(c, l), res;
for (P p : v)
if (isis_sp(l, p))
res.push_back(p);
return res;
}
vector<L> tangent_cp(C c, P p) { //円の接線?
vector<L> ret;
P v = c.p - p;
ld d = abs(v);
ld l = sqrt(norm(v) - c.r * c.r);
if (std::isnan(l)) {
return ret;
}
P v1 = v * P(l / d, c.r / d);
P v2 = v * P(l / d, -c.r / d);
ret.push_back(L{p, p + v1});
if (l < eps)
return ret;
ret.push_back(L{p, p + v2});
return ret;
}
vector<L> tangent_cc(C c1, C c2) {
vector<L> ret;
if (abs(c1.p - c2.p) - (c1.r + c2.r) > -eps) {
P center = (c1.p * c2.r + c2.p * c1.r) / (c1.r + c2.r);
ret = tangent_cp(c1, center);
}
if (abs(c1.r - c2.r) > eps) {
P out = (-c1.p * c2.r + c2.p * c1.r) / (c1.r - c2.r);
vector<L> nret = tangent_cp(c1, out);
ret.insert(ret.end(), ALL(nret));
} else {
P v = c2.p - c1.p;
v /= abs(v);
P q1 = c1.p + v * P(0, 1) * c1.r;
P q2 = c1.p + v * P(0, -1) * c1.r;
ret.push_back(L{q1, q1 + v});
ret.push_back(L{q2, q2 + v});
}
return ret;
}
ld area(const VP &p) { //面積??
ld res = 0;
int n = p.size();
rep(j, n) res += cross(p[j], p[(j + 1) % n]);
return res / 2;
}
bool is_polygon(L l, VP &g) {
int n = g.size();
for (int i = 0; i < n; i++) {
P a = g[i];
P b = g[(i + 1) % n];
if (isis_ss(l, L{a, b}))
return true;
}
return false;
}
int is_in_Polygon(const VP &g, P p) {
bool in = false;
int n = g.size();
for (int i = 0; i < n; i++) {
P a = g[i] - p, b = g[(i + 1) % n] - p;
if (imag(a) > imag(b))
swap(a, b);
if (imag(a) <= 0 && 0 < imag(b))
if (cross(a, b) < 0)
in = !in;
if (abs(cross(a, b)) < eps && dot(a, b) < eps)
return 0; // on
}
if (in)
return 1; // in
return -1; // out
}
VP ConvexHull(VP ps) {
int n = ps.size();
int k = 0;
sort(ps.begin(), ps.end());
VP ch(2 * n);
for (int i = 0; i < n; ch[k++] = ps[i++])
while (k >= 2 && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
while (k >= t && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
ch.resize(k - 1);
return ch;
}
VP ConvexCut(const VP &ps, L l) {
VP Q;
for (int i = 0; i < (int)ps.size(); i++) {
P A = ps[i], B = ps[(i + 1) % ps.size()];
if (ccw(l.a, l.b, A) != -1)
Q.push_back(A);
if (ccw(l.a, l.b, A) * ccw(l.a, l.b, B) < 0)
Q.push_back(is_ll(L{A, B}, l));
}
return Q;
}
struct unionfind_ {
vector<int> par, rank, size_,
a; //速度ではなくメモリ効率を考えるならrankのかわりにsizeを使う
public:
unionfind_(int n) : par(n), rank(n), size_(n, 1), a(n) { iota(ALL(par), 0); }
int find(int x) {
if (par[x] == 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 (rank[x] < rank[y])
swap(x, y);
par[y] = x;
size_[x] += size_[y];
cmin(a[x], a[y]);
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return size_[find(x)]; }
};
template <class T> class lazysegtree {
vector<T> obj;
int offset;
T e;
int bufsize(int num) {
int i = 1;
for (; num > i; i <<= 1)
;
offset = i - 1;
return (i << 1) - 1;
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return obj[k];
else {
T ret(e);
obj[k].propagate(obj[k * 2 + 1], obj[k * 2 + 2]);
return ret.merge(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2, r));
}
}
void propagateall(int a, int b, int k, int l, int r) {
if (r <= a || b <= l || l == r - 1)
return;
obj[k].propagate(obj[k * 2 + 1], obj[k * 2 + 2]);
propagateall(a, b, k * 2 + 1, l, (l + r) / 2);
propagateall(a, b, k * 2 + 2, (l + r) / 2, r);
}
template <class Param>
T update(int a, int b, int k, int l, int r, const Param ¶m) {
if (r <= a || b <= l)
return obj[k];
if (a <= l && r <= b) {
obj[k].update(param);
return obj[k];
}
obj[k].propagate(obj[k * 2 + 1], obj[k * 2 + 2]);
return obj[k].merge(update(a, b, k * 2 + 1, l, (l + r) / 2, param),
update(a, b, k * 2 + 2, (l + r) / 2, r, param));
}
public:
T query(int a, int b) { //[a,b)
return query(a, b, 0, 0, offset + 1);
}
template <class Param> void update(int a, int b, Param &¶m) {
update(a, b, 0, 0, offset + 1, param);
}
void updateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
if (l == 0)
return;
do {
l = l - 1 >> 1, r = r - 1 >> 1;
for (int i = l; i < r; i++)
obj[i].merge(obj[i * 2 + 1], obj[i * 2 + 2]);
} while (l);
}
void propagateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
updateall(l, r, 0, 0, offset + 1);
}
/*
void update(int k, T &a) {
k += offset;
obj[k] = a;
while (k) {
k = k - 1 >> 1;
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}*/
lazysegtree(int n, T e) : obj(bufsize(n), e), e(e) {}
lazysegtree(vector<T> &vec, T e) : obj(bufsize(vec.size()), e), e(e) {
copy(vec.begin(), vec.end(), obj.begin() + offset);
updateall();
}
T &operator[](int n) { return obj[n + offset]; }
};
class lazyRMQ_t {
ll min, set;
public:
ll getmin() { return min; }
lazyRMQ_t() {
min = numeric_limits<ll>::max() / 2;
set = min;
}
lazyRMQ_t(ll a, ll b = 0) {
min = a;
set = b;
}
void propagate(lazyRMQ_t &a, lazyRMQ_t &b) {
cmin(a.min, set);
cmin(b.min, set);
cmin(a.set, set);
cmin(b.set, set);
set = numeric_limits<ll>::max() / 2;
}
lazyRMQ_t &merge(const lazyRMQ_t &a, const lazyRMQ_t &b) {
min = std::min(a.min, b.min);
set = numeric_limits<ll>::max() / 2;
return *this;
}
lazyRMQ_t &update(ll k) {
cmin(min, k);
cmin(set, k);
return *this;
}
};
int check(array<int, 4> &a, array<int, 4> &b) {
if (a == b)
return 0;
if (a[0] < b[0] && a[1] < b[1])
return b[2];
if (b[0] < a[0] && b[1] < a[1])
return a[2];
return -1;
}
int main() {
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
int a = 0, b = 0, ab = 0;
ll ans = 0;
for (auto &x : s) {
bool af = 0;
for (auto c : x) {
if (c == 'B' && af)
ans++;
if (c == 'A')
af = 1;
else
af = 0;
}
if (x[0] == 'B')
b++;
if (x.back() == 'A')
a++;
if (x[0] == 'B' && x.back() == 'A')
ab++;
}
if (ab == a && ab == b)
ans--;
cout << max(0ll, ans + min(a, b)) << endl;
}
// template<class T, class map = std::unordered_map<T,unique_ptr<node>>>
/*class AhoCorasick {
struct node {
map<char,unique_ptr<node>> next;
node* fail = nullptr, *match_list = nullptr;
std::vector<int> match;
}root;
int pattern;
//template<class string>
AhoCorasick(std::vector<string> &vs) :pattern(vs.size()) {
root.fail = &root;
for (int i = 0; i < vs.size(); i++) {
node* now = &root;
for (auto c : vs[i]) {
if (!now->next[c])now->next[c]=make_unique<node>();
now = now->next[c].get();
}
now->match.push_back(i);
}
std::queue<node*> que;
que.push(&root);
while (!que.empty()) {
auto now = que.front();
que.pop();
for (auto &next : now->next) {
if (!next.second)continue;
if (now->fail->next.count(next.first))next.second->fail =
now->fail->next[next.first].get(); else next.second->fail = now->fail->fail;
//next.second->match.insert(next.second->match.end(),
next.second->fail->match.begin(), next.second->fail->match.end()); if
(next.second->fail->match.empty())next.second->match_list =
next.second->fail->match_list; else next.second->match_list = next.second->fail;
que.push(next.second.get());
}
}
}
auto match_n(string str) {
vector<int> num(pattern);
}
auto match_list(string str) {
vector<pair<int, int>> list;
auto now = &root;
for (int i = 0; i < str.size(); i++) {
if (now->next.count(str[i]))now = now->next[str[i]].get();
else now = now->fail;
auto match = now->match_list;
do {
match
}
}
}
};*/
| #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
// cin.sync_with_stdio(false);
// streambuf
using namespace std;
typedef long long ll;
typedef double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using ti3 = tuple<int, int, int>;
using vti3 = vector<ti3>;
template <class T, int s> using va = vector<array<T, s>>;
template <class T, class T2> using umap = unordered_map<T, T2>;
template <class T> using uset = unordered_set<T>;
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
#define ALL(a) a.begin(), a.end()
#define rep(i, a) for (int i = 0; i < a; i++)
#define rep1(i, a) for (int i = 1; i <= a; i++)
#define rrep(i, a) for (int i = (a)-1; i >= 0; i--)
#define rrep1(i, a) for (int i = a; i; i--)
#define repi(i, a, b) for (int i = a; i < b; i++)
// const ll mod = 1000000007;
template <class T> using heap = priority_queue<T, vector<T>, greater<T>>;
template <class T> using pque = priority_queue<T, vector<T>, function<T(T, T)>>;
template <class T> inline void hash_combine(size_t &seed, const T &v) {
hash<T> hasher;
seed ^= hasher(v) + 0x9e3779b97f4a7c15 + (seed << 6) + (seed >> 2);
}
namespace std {
template <typename S, typename T> struct hash<pair<S, T>> {
inline size_t operator()(const pair<S, T> &v) const {
size_t seed = 0;
hash_combine(seed, v.first);
hash_combine(seed, v.second);
return seed;
}
};
// Recursive template code derived from Matthieu M.
template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
struct HashValueImpl {
static void apply(size_t &seed, Tuple const &tuple) {
HashValueImpl<Tuple, Index - 1>::apply(seed, tuple);
hash_combine(seed, std::get<Index>(tuple));
}
};
template <class Tuple> struct HashValueImpl<Tuple, 0> {
static void apply(size_t &seed, Tuple const &tuple) {
hash_combine(seed, std::get<0>(tuple));
}
};
template <typename... TT> struct hash<std::tuple<TT...>> {
size_t operator()(std::tuple<TT...> const &tt) const {
size_t seed = 0;
HashValueImpl<std::tuple<TT...>>::apply(seed, tt);
return seed;
}
};
} // namespace std
template <class T> int id(vector<T> &a, T b) {
return lower_bound(ALL(a), b) - a.begin();
}
ll pow(ll base, ll i, ll mod) {
ll a = 1;
while (i) {
if (i & 1) {
a *= base;
a %= mod;
}
base *= base;
base %= mod;
i /= 2;
}
return a;
}
ll gcd(ll a, ll b) {
while (b) {
ll c = a % b;
a = b;
b = c;
}
return a;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
#ifdef _MSC_VER
#include <intrin.h>
#endif
int popcnt(unsigned long long a) {
#ifndef _MSC_VER
return __builtin_popcountll(a);
#elif defined _WIN64
return _mm_popcnt_u64(a);
#else
return _mm_popcnt_u32(a >> 32) + _mm_popcnt_u32(a);
a = (a & 0x5555555555555555) + (a >> 1 & 0x5555555555555555);
a = (a & 0x3333333333333333) + (a >> 2 & 0x3333333333333333);
a = (a & 0x0f0f0f0f0f0f0f0f) + (a >> 4 & 0x0f0f0f0f0f0f0f0f);
a = (a & 0x00ff00ff00ff00ff) + (a >> 8 & 0x00ff00ff00ff00ff);
a = (a & 0x0000ffff0000ffff) + (a >> 16 & 0x0000ffff0000ffff);
return (a & 0xffffffff) + (a >> 32);
#endif
}
int BitScanF(unsigned long long a) {
#ifndef _MSC_VER
return __builtin_ctzll(a);
#elif defined _WIN64
unsigned long ret;
_BitScanForward64(&ret, a);
return a;
#else
unsigned long ret;
if (!(unsigned long)a) {
_BitScanForward(&ret, a);
ret += 32;
} else
_BitScanForward(&ret, (unsigned long)a);
return ret;
#endif
}
int BitScanR(unsigned long long a) {
#ifndef _MSC_VER
return 63 - __builtin_clzll(a);
#elif defined _WIN64
unsigned long ret;
_BitScanReverse64(&ret, a);
return a;
#else
unsigned long ret;
if (a >> 32) {
_BitScanReverse(&ret, a);
ret += 32;
} else
_BitScanReverse(&ret, (unsigned long)a);
return ret;
#endif
}
template <class T> class matrix {
public:
vector<valarray<T>> obj;
pair<int, int> s;
public:
matrix(pair<int, int> size, T e = 0) : matrix(size.first, size.second, e) {}
matrix(int n, int m = -1, T e = 0)
: obj(n, valarray<T>(e, m == -1 ? n : m)), s(n, m == -1 ? n : m) {}
static matrix e(int n) {
matrix a = (n);
for (int i = 0; i < n; i++)
a[i][i] = 1;
return a;
}
matrix &operator+=(const matrix &p) {
if (s != p.s)
throw runtime_error("matrix error");
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
obj[i][j] += p.obj[i][j];
return *this;
}
matrix operator+(const matrix &p) {
matrix res(*this);
return res += p;
}
matrix &operator-=(const matrix &p) {
if (s != p.s)
throw runtime_error("matrix error");
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
obj[i][j] -= p.obj[i][j];
return *this;
}
matrix operator-(const matrix &p) {
matrix res(*this);
return res -= p;
}
matrix &operator*=(T p) {
for (auto &a : obj)
for (auto &b : a)
b *= p;
return *this;
}
matrix operator*(T p) {
matrix res(*this);
return res *= p;
}
matrix operator*(const matrix &p) {
if (s.second != p.s.first)
throw runtime_error("matrix error");
matrix ret(s.first, p.s.second);
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
ret[i] += obj[i][j] * p.obj[j];
return ret;
}
matrix &operator*=(const matrix &p) { return *this = *this * p; }
bool operator==(const matrix &p) {
if (s != p.s)
return 0;
for (int i = 0; i < s.first; i++)
for (int j; j < s.second; j++)
if (obj[i][j] != p.obj[i][j])
return 0;
return 1;
}
pair<int, int> size() const { return s; }
matrix &mod(T m) {
for (auto &a : obj)
for (auto &b : a)
b %= m;
return *this;
}
valarray<T> &operator[](int t) { return obj[t]; }
void gauss() {
if (size().first + 1 != size().second)
return;
rep(i, size().first) {
int p = i;
repi(j, i, size().first) if (abs(obj[j][i]) > abs(obj[p][i])) p = j;
swap(obj[i], obj[p]);
if (abs(obj[i][i]) < 1e-8)
return; // contniue;
repi(j, i + 1, size().second) obj[i][j] /= obj[i][i];
rep(j, size().first) {
if (i != j) {
repi(k, i + 1, size().second) obj[j][k] -= obj[j][i] * obj[i][k];
}
}
}
}
};
template <class T>
std::pair<matrix<T>, vector<int>> LU_decomposition(matrix<T> a) {
if (a.size().first != a.size().second)
throw runtime_error("matrix error");
std::vector<int> pi(a.size().first);
std::iota(ALL(pi), 0);
valarray<T> tmp(a.size().first);
for (int i = 0; i < a.size().first; i++) {
// int pivot = i;
// T max = abs(a[i][i]);
// for (int j = i + 1; j < a.size().first; j++) {
// if (max < abs(a[j][i])) {
// max = abs(a[j][i]);
// pivot = j;
// }
//}
// std::swap(i, pivot);
// pi.push_back(pivot);
std::slice slice(i + 1, a.size().first - i - 1, 1);
for (int j = i + 1; j < a.size().first; j++) {
tmp[slice] = a[i][slice];
tmp *= a[j][i] / a[i][i];
a[j][slice] -= tmp[slice];
a[j][i] = a[j][i] / a[i][i];
}
}
return std::make_pair(std::move(a), std::move(pi));
}
template <class T>
matrix<T> LU_solve(pair<matrix<T>, std::vector<int>> a, matrix<T> b) {
auto pi = std::move(a.second);
auto A = std::move(a.first);
if (A.size().first != A.size().second || A.size().first != b.size().first)
throw runtime_error("matrix error");
for (int i = 0; i < A.size().first; i++) {
std::swap(b[i], b[pi[i]]);
}
for (int i = 0; i < A.size().first; i++) {
for (int j = 0; j < i; j++)
b[i] -= A[i][j] * b[j];
}
for (int i = A.size().first - 1; i >= 0; i--) {
for (int j = i + 1; j < A.size().first; j++)
b[i] -= A[i][j] * b[j];
b[i] /= A[i][i];
}
return b;
}
template <class T>
inline matrix<T> pow(matrix<T> &base, unsigned long long exp) {
auto base_(base);
if (base_.size().first != base_.size().second)
throw runtime_error("matrix error");
matrix<T> res = matrix<T>::e(base_.size().first);
for (;;) {
if (exp & 1)
res *= base_;
if (res.obj[0].size() > 100) {
int a = 0;
}
if (!(exp /= 2))
break;
base_ *= base_;
}
return res;
}
template <class T>
inline matrix<T> modpow(matrix<T> &base, unsigned long long exp, ll m) {
auto base_(base);
if (base.size().first != base_.size().second)
throw runtime_error("matrix error");
matrix<T> res = matrix<T>::e(base_.size().first);
for (;;) {
if (exp & 1)
(res *= base_).mod(m);
if (res.obj[0].size() > 100) {
int a = 0;
}
if (!(exp /= 2))
break;
(base_ *= base_).mod(m);
}
return res;
}
class unionfind {
vector<int> par, rank,
size_; //速度ではなくメモリ効率を考えるならrankのかわりにsizeを使う
public:
unionfind(int n) : par(n), rank(n), size_(n, 1) { iota(ALL(par), 0); }
int find(int x) {
if (par[x] == 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 (rank[x] < rank[y])
swap(x, y);
par[y] = x;
size_[x] += size_[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return size_[find(x)]; }
};
// end of lib
// template<class S=void,int ptr_num, class T = char>class trie {
// umap<T, trie<S, ptr_num, T> next;
// public:
// S key;
// trie<S, ptr_num, T>* ptr[ptr_num] = {};
// trie(S &&data) :key(data) {}
// trie(const S &data) :key(data) {}
// void add(T x,S data) {
// if (!next.find(x))next.insert(x, data);
// }
// trie& operator[](T x) {
// return next[x];
// }
// bool find(T x) {
// retun next.find(x);
// }
//};
// template<class T=char>class AhoCorasick {
// trie<pair<bool,int>, 2, T> tree;
// AhoCorasick(vector<string> p) {
// int num = 0;
// vector<decltype(&tree)> que(p.size(),&tree);
// for (int i = 0;; i++) {
// bool end = 1;
// int i = 0;
// for (auto a : p) {
// if (i >= a.size())break;
// end = ;0
// que[i] = (*que[i])[a[i]];
// i++;
// }
// if (end)break;
// }
// }
//};
template <class T, class Func = function<T(T, T)>> class segtree {
vector<T> obj;
int offset;
Func updater;
T e;
int bufsize(int num) {
int i = 1;
for (; num > i; i <<= 1)
;
offset = i - 1;
return (i << 1) - 1;
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return obj[k];
else
return updater(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2, r));
}
public:
void propagate(int a, int b, int k, int l, int r, int p) {
if (r <= a || b <= l)
return;
if (a <= l && r <= b) {
obj[k].second += p;
(obj[k].first *= pow(2, p, (ll)1e9 + 7)) %= (ll)(1e9 + 7);
return;
} else {
if (obj[k].second) {
(obj[k * 2 + 1].first *= pow(2, obj[k].second, (ll)1e9 + 7)) %=
(ll)(1e9 + 7);
(obj[k * 2 + 2].first *= pow(2, obj[k].second, (ll)1e9 + 7)) %=
(ll)(1e9 + 7);
obj[k * 2 + 1].second += obj[k].second;
obj[k * 2 + 2].second += obj[k].second;
}
propagate(a, b, k * 2 + 1, l, (l + r) / 2, p),
propagate(a, b, k * 2 + 2, (l + r) / 2, r, p);
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}
T query(int a, int b) { //[a,b)
// propagate(a, b, 0);
return query(a, b, 0, 0, offset + 1);
}
void propagate(int a, int b, int p = 1) { //[a,b)
return propagate(a, b, 0, 0, offset + 1, p);
}
void updateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
if (l == 0)
return;
do {
l = l - 1 >> 1, r = r - 1 >> 1;
for (int i = l; i < r; i++)
obj[i] = updater(obj[i * 2 + 1], obj[i * 2 + 2]);
} while (l);
}
void update(int k, const T &a) {
// propagate(k, k + 1, 0);
k += offset;
obj[k] = a;
while (k) {
k = k - 1 >> 1;
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}
segtree(int n, T e, const Func &updater = Func())
: obj(bufsize(n), e), e(e), updater(updater) {}
segtree(vector<T> &vec, T e, const Func &updater = Func())
: obj(bufsize(vec.size()), e), e(e), updater(updater) {
copy(vec.begin(), vec.end(), obj.begin() + offset);
updateall();
}
T &operator[](int n) { return obj[n + offset]; }
};
template <class T = int>
class BIT { //多次元BITはループをネストすればいいらしい。
vector<T> bit;
public:
BIT(int n) : bit(n + 1, 0) {}
void add(int i, T x) {
i++;
while (i <= bit.size()) {
bit[i - 1] += x;
i += i & -i;
}
}
T sum(int i) {
T s = 0;
i++;
while (i) {
s += bit[i - 1];
i &= i - 1;
}
return s;
}
};
template <class T> class rangeadd {
BIT<T> b0, b1;
int n;
rangeadd(int n) : b0(n), b1(n), n(n) {}
void add(int l, int r, T x) { //[l,r)
b0.add(l, -x(l - 1));
b1.add(l, x);
b0.add(r, x * r);
b1.add(r, -x);
}
T sum(int i) { return b0.sum(i) + b1.sum(i) * i; }
};
class Flow {
int V;
struct edge {
int to, cap, rev, cost, add;
};
vector<vector<edge>> G;
vector<int> level, iter, h, dist, prevv, preve;
void bfs(int s) {
fill(level.begin(), level.end(), -1);
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
int dfs(int v, int t, int f) {
if (v == t)
return f;
for (int &i = iter[v]; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int res = 0;
int flow = 0;
int s, t;
int max_flow(int s, int t, int fmax = numeric_limits<int>::max()) {
level.resize(V);
iter.resize(V);
for (;;) {
bfs(s);
if (level[t] < 0)
return flow;
fill(iter.begin(), iter.end(), 0);
int f;
while ((f = dfs(s, t, fmax)) > 0) {
flow += f;
fmax -= f;
}
if (fmax == 0)
return flow;
}
}
typedef pair<int, int> P;
int min_cost_flow(int s, int t, int f) {
h.resize(V);
dist.resize(V);
prevv.resize(V);
preve.resize(V);
fill(h.begin(), h.end(), 0);
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
fill(dist.begin(), dist.end(), numeric_limits<int>::max());
dist[s] = 0;
que.push({0, s});
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push({dist[e.to], e.to});
}
}
}
if (dist[t] == numeric_limits<int>::max()) {
return -1;
}
for (int v = 0; v < V; v++)
h[v] += dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
public:
Flow(int size, int s, int t) : G(size + 1), V(size + 1), s(s), t(t) {}
void add_edge(int from, int to, int cap, int cost = 0) {
G[from].push_back(edge{to, cap, (int)G[to].size(), cost, 1});
G[to].push_back(edge{from, 0, (int)G[from].size() - 1, -cost, 0});
}
void remove_edge_max(int from, int to, int cap, int cost = 0) {
for (auto &x : G[from]) {
if (!x.add || x.to != to || x.cap + G[to][x.rev].cap != cap ||
x.cost != cost)
continue;
int prev = flow;
int cap = G[to][x.rev].cap;
G[to][x.rev].cap = 0;
x.cap = 0;
cap -= max_flow(from, to, cap) - prev;
max_flow(t, to, cap);
max_flow(from, s, cap);
flow = prev - cap;
break;
}
}
void remove_edge_cost(int from, int to, int cap, int cost = 0) {
for (auto &x : G[from]) {
if (!x.add || x.to != to || x.cap + G[to][x.rev].cap != cap ||
x.cost != cost)
continue;
cost += G[to][x.rev].cap * G[to][x.rev].cost;
int cap = G[to][x.rev].cap;
G[to][x.rev].cap = 0;
x.cap = 0;
min_cost_flow(from, to, cap);
break;
}
}
int max_flow() { return max_flow(s, t); }
int min_cost_flow(int f) { return min_cost_flow(s, t, f); }
};
ll extgcd(ll a, ll b, ll &x, ll &y) {
int d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
ll mod_inv(ll a, ll m) {
ll x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
pll linear_congruence(const vector<ll> &A, const vll &B, const vll &M) {
ll x = 0, m = 1;
for (int i = 0; i < A.size(); i++) {
ll a = A[i] * m, b = B[i] - A[i] * x, d = gcd(M[i], a);
if (b % d != 0)
return make_pair(0, -1);
ll t = b / d * mod_inv(a / d, M[i] / d) % (M[i] / d);
// if (x + m * t < 0)return pll(x%m, m);
x = x + m * t;
m *= M[i] / d;
}
return make_pair(x % m, m);
}
typedef complex<ld> P;
typedef vector<P> VP;
const ld eps = 1e-11, pi = acos(-1.0);
ld dot(P a, P b) { return real(conj(a) * b); }
ld cross(P a, P b) { return imag(conj(a) * b); }
namespace std {
bool operator<(const P &a, const P &b) {
return abs(a.real() - b.real()) < eps ? a.imag() < b.imag()
: a.real() < b.real();
}
} // namespace std
struct L {
P a, b;
}; // line->l,segment->s
struct C {
P p;
ld r;
};
int ccw(P a, P b, P c) {
b -= a;
c -= a;
if (cross(b, c) > eps)
return 1; // counter clockwise
if (cross(b, c) < -eps)
return -1; // clockwise
if (dot(b, c) < 0)
return 2; // c--a--b on line
if (norm(b) < norm(c))
return -2; // a--b--c on line
return 0; // a--c--b on line
}
bool isis_ll(L l, L m) { // is intersect
return abs(cross(l.b - l.a, m.b - m.a)) > eps;
}
bool isis_ls(L l, L s) {
ld a = cross(l.b - l.a, s.a - l.a);
ld b = cross(l.b - l.a, s.b - l.a);
return (a * b < eps);
}
bool isis_lp(L l, P p) { return abs(cross(l.b - p, l.a - p)) < eps; }
bool isis_ss(L s, L t) {
return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}
P is_ll(L s, L t) { // intersect
P sv = s.b - s.a, tv = t.b - t.a;
return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}
bool isis_sp(L s, P p) {
return abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps;
}
P proj(L l, P p) {
ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
return l.a + t * (l.a - l.b);
}
ld dist_lp(L l, P p) { return abs(p - proj(l, p)); }
ld dist_ll(L l, L m) { return isis_ll(l, m) ? 0 : dist_lp(l, m.a); }
ld dist_ls(L l, L s) {
if (isis_ls(l, s))
return 0;
return min(dist_lp(l, s.a), dist_lp(l, s.b));
}
ld dist_sp(L s, P p) {
P r = proj(s, p);
if (isis_sp(s, r))
return abs(r - p);
return min(abs(s.a - p), abs(s.b - p));
}
ld dist_ss(L s, L t) {
if (isis_ss(s, t))
return 0;
ld a = min(dist_sp(s, t.a), dist_sp(t, s.a));
ld b = min(dist_sp(s, t.b), dist_sp(t, s.b));
return min(a, b);
}
VP is_cc(C c1, C c2) {
VP res;
ld d = abs(c1.p - c2.p);
ld rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
ld dfr = c1.r * c1.r - rc * rc;
if (abs(dfr) < eps)
dfr = 0.0;
else if (dfr < 0.0)
return res; // no intersection
ld rs = sqrt(dfr);
P diff = (c2.p - c1.p) / d;
res.push_back(c1.p + diff * P(rc, rs));
if (dfr != 0.0)
res.push_back(c1.p + diff * P(rc, -rs));
return res;
}
bool isis_vc(vector<C> vc) {
VP crs;
int n = vc.size();
rep(i, n) rep(j, i) for (P p : is_cc(vc[i], vc[j])) crs.push_back(p);
rep(i, n) crs.push_back(vc[i].p);
for (P p : crs) {
bool valid = true;
rep(i, n) if (abs(p - vc[i].p) > vc[i].r + eps) valid = false;
if (valid)
return true;
}
return false;
}
VP is_lc(C c, L l) {
VP res;
ld d = dist_lp(l, c.p);
if (d < c.r + eps) {
ld len = (d > c.r) ? 0.0 : sqrt(c.r * c.r - d * d); // safety;
P nor = (l.a - l.b) / abs(l.a - l.b);
res.push_back(proj(l, c.p) + len * nor);
res.push_back(proj(l, c.p) - len * nor);
}
return res;
}
VP is_sc(C c, L l) {
VP v = is_lc(c, l), res;
for (P p : v)
if (isis_sp(l, p))
res.push_back(p);
return res;
}
vector<L> tangent_cp(C c, P p) { //円の接線?
vector<L> ret;
P v = c.p - p;
ld d = abs(v);
ld l = sqrt(norm(v) - c.r * c.r);
if (std::isnan(l)) {
return ret;
}
P v1 = v * P(l / d, c.r / d);
P v2 = v * P(l / d, -c.r / d);
ret.push_back(L{p, p + v1});
if (l < eps)
return ret;
ret.push_back(L{p, p + v2});
return ret;
}
vector<L> tangent_cc(C c1, C c2) {
vector<L> ret;
if (abs(c1.p - c2.p) - (c1.r + c2.r) > -eps) {
P center = (c1.p * c2.r + c2.p * c1.r) / (c1.r + c2.r);
ret = tangent_cp(c1, center);
}
if (abs(c1.r - c2.r) > eps) {
P out = (-c1.p * c2.r + c2.p * c1.r) / (c1.r - c2.r);
vector<L> nret = tangent_cp(c1, out);
ret.insert(ret.end(), ALL(nret));
} else {
P v = c2.p - c1.p;
v /= abs(v);
P q1 = c1.p + v * P(0, 1) * c1.r;
P q2 = c1.p + v * P(0, -1) * c1.r;
ret.push_back(L{q1, q1 + v});
ret.push_back(L{q2, q2 + v});
}
return ret;
}
ld area(const VP &p) { //面積??
ld res = 0;
int n = p.size();
rep(j, n) res += cross(p[j], p[(j + 1) % n]);
return res / 2;
}
bool is_polygon(L l, VP &g) {
int n = g.size();
for (int i = 0; i < n; i++) {
P a = g[i];
P b = g[(i + 1) % n];
if (isis_ss(l, L{a, b}))
return true;
}
return false;
}
int is_in_Polygon(const VP &g, P p) {
bool in = false;
int n = g.size();
for (int i = 0; i < n; i++) {
P a = g[i] - p, b = g[(i + 1) % n] - p;
if (imag(a) > imag(b))
swap(a, b);
if (imag(a) <= 0 && 0 < imag(b))
if (cross(a, b) < 0)
in = !in;
if (abs(cross(a, b)) < eps && dot(a, b) < eps)
return 0; // on
}
if (in)
return 1; // in
return -1; // out
}
VP ConvexHull(VP ps) {
int n = ps.size();
int k = 0;
sort(ps.begin(), ps.end());
VP ch(2 * n);
for (int i = 0; i < n; ch[k++] = ps[i++])
while (k >= 2 && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
while (k >= t && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
ch.resize(k - 1);
return ch;
}
VP ConvexCut(const VP &ps, L l) {
VP Q;
for (int i = 0; i < (int)ps.size(); i++) {
P A = ps[i], B = ps[(i + 1) % ps.size()];
if (ccw(l.a, l.b, A) != -1)
Q.push_back(A);
if (ccw(l.a, l.b, A) * ccw(l.a, l.b, B) < 0)
Q.push_back(is_ll(L{A, B}, l));
}
return Q;
}
struct unionfind_ {
vector<int> par, rank, size_,
a; //速度ではなくメモリ効率を考えるならrankのかわりにsizeを使う
public:
unionfind_(int n) : par(n), rank(n), size_(n, 1), a(n) { iota(ALL(par), 0); }
int find(int x) {
if (par[x] == 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 (rank[x] < rank[y])
swap(x, y);
par[y] = x;
size_[x] += size_[y];
cmin(a[x], a[y]);
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return size_[find(x)]; }
};
template <class T> class lazysegtree {
vector<T> obj;
int offset;
T e;
int bufsize(int num) {
int i = 1;
for (; num > i; i <<= 1)
;
offset = i - 1;
return (i << 1) - 1;
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return obj[k];
else {
T ret(e);
obj[k].propagate(obj[k * 2 + 1], obj[k * 2 + 2]);
return ret.merge(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2, r));
}
}
void propagateall(int a, int b, int k, int l, int r) {
if (r <= a || b <= l || l == r - 1)
return;
obj[k].propagate(obj[k * 2 + 1], obj[k * 2 + 2]);
propagateall(a, b, k * 2 + 1, l, (l + r) / 2);
propagateall(a, b, k * 2 + 2, (l + r) / 2, r);
}
template <class Param>
T update(int a, int b, int k, int l, int r, const Param ¶m) {
if (r <= a || b <= l)
return obj[k];
if (a <= l && r <= b) {
obj[k].update(param);
return obj[k];
}
obj[k].propagate(obj[k * 2 + 1], obj[k * 2 + 2]);
return obj[k].merge(update(a, b, k * 2 + 1, l, (l + r) / 2, param),
update(a, b, k * 2 + 2, (l + r) / 2, r, param));
}
public:
T query(int a, int b) { //[a,b)
return query(a, b, 0, 0, offset + 1);
}
template <class Param> void update(int a, int b, Param &¶m) {
update(a, b, 0, 0, offset + 1, param);
}
void updateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
if (l == 0)
return;
do {
l = l - 1 >> 1, r = r - 1 >> 1;
for (int i = l; i < r; i++)
obj[i].merge(obj[i * 2 + 1], obj[i * 2 + 2]);
} while (l);
}
void propagateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
updateall(l, r, 0, 0, offset + 1);
}
/*
void update(int k, T &a) {
k += offset;
obj[k] = a;
while (k) {
k = k - 1 >> 1;
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}*/
lazysegtree(int n, T e) : obj(bufsize(n), e), e(e) {}
lazysegtree(vector<T> &vec, T e) : obj(bufsize(vec.size()), e), e(e) {
copy(vec.begin(), vec.end(), obj.begin() + offset);
updateall();
}
T &operator[](int n) { return obj[n + offset]; }
};
class lazyRMQ_t {
ll min, set;
public:
ll getmin() { return min; }
lazyRMQ_t() {
min = numeric_limits<ll>::max() / 2;
set = min;
}
lazyRMQ_t(ll a, ll b = 0) {
min = a;
set = b;
}
void propagate(lazyRMQ_t &a, lazyRMQ_t &b) {
cmin(a.min, set);
cmin(b.min, set);
cmin(a.set, set);
cmin(b.set, set);
set = numeric_limits<ll>::max() / 2;
}
lazyRMQ_t &merge(const lazyRMQ_t &a, const lazyRMQ_t &b) {
min = std::min(a.min, b.min);
set = numeric_limits<ll>::max() / 2;
return *this;
}
lazyRMQ_t &update(ll k) {
cmin(min, k);
cmin(set, k);
return *this;
}
};
int check(array<int, 4> &a, array<int, 4> &b) {
if (a == b)
return 0;
if (a[0] < b[0] && a[1] < b[1])
return b[2];
if (b[0] < a[0] && b[1] < a[1])
return a[2];
return -1;
}
int main() {
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
int a = 0, b = 0, ab = 0;
ll ans = 0;
for (auto &x : s) {
bool af = 0;
for (auto c : x) {
if (c == 'B' && af)
ans++;
if (c == 'A')
af = 1;
else
af = 0;
}
if (x[0] == 'B')
b++;
if (x.back() == 'A')
a++;
if (x[0] == 'B' && x.back() == 'A')
ab++;
}
if (ab == a && ab == b && b != 0)
ans--;
cout << max(0ll, ans + min(a, b)) << endl;
}
// template<class T, class map = std::unordered_map<T,unique_ptr<node>>>
/*class AhoCorasick {
struct node {
map<char,unique_ptr<node>> next;
node* fail = nullptr, *match_list = nullptr;
std::vector<int> match;
}root;
int pattern;
//template<class string>
AhoCorasick(std::vector<string> &vs) :pattern(vs.size()) {
root.fail = &root;
for (int i = 0; i < vs.size(); i++) {
node* now = &root;
for (auto c : vs[i]) {
if (!now->next[c])now->next[c]=make_unique<node>();
now = now->next[c].get();
}
now->match.push_back(i);
}
std::queue<node*> que;
que.push(&root);
while (!que.empty()) {
auto now = que.front();
que.pop();
for (auto &next : now->next) {
if (!next.second)continue;
if (now->fail->next.count(next.first))next.second->fail =
now->fail->next[next.first].get(); else next.second->fail = now->fail->fail;
//next.second->match.insert(next.second->match.end(),
next.second->fail->match.begin(), next.second->fail->match.end()); if
(next.second->fail->match.empty())next.second->match_list =
next.second->fail->match_list; else next.second->match_list = next.second->fail;
que.push(next.second.get());
}
}
}
auto match_n(string str) {
vector<int> num(pattern);
}
auto match_list(string str) {
vector<pair<int, int>> list;
auto now = &root;
for (int i = 0; i < str.size(); i++) {
if (now->next.count(str[i]))now = now->next[str[i]].get();
else now = now->fail;
auto match = now->match_list;
do {
match
}
}
}
};*/
| [
"control_flow.branch.if.condition.change"
] | 866,715 | 866,716 | u480543763 | cpp |
p03049 | #include <iostream>
#define MAXN 3000
using namespace std;
int N, ans, a, b, k, m;
string s;
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> s;
for (int j = 1; j < s.length(); j++) {
if (s[j] == 'B' && s[j - 1] == 'A')
ans++;
}
if (s[0] == 'B')
a--, k++;
if (s[s.length() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.length() - 1] == 'A')
m++;
}
if (a < 0)
k += a;
if (k == N || m == k)
k--;
ans += max(0, k);
cout << ans << endl;
} | #include <iostream>
#define MAXN 3000
using namespace std;
int N, ans, a, b, k, m;
string s;
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> s;
for (int j = 1; j < s.length(); j++) {
if (s[j] == 'B' && s[j - 1] == 'A')
ans++;
}
if (s[0] == 'B')
a--, k++;
if (s[s.length() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.length() - 1] == 'A')
m++;
}
if (a < 0)
k += a;
if (k == N || (m == k && !a))
k--;
ans += max(0, k);
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change"
] | 866,719 | 866,720 | u263762062 | cpp |
p03049 | #include <bits/stdc++.h>
#define rep(i, n) REP(i, 0, n)
#define REP(i, l, r) for (long long i = l; i < r; i++)
#define int long long
using namespace std;
typedef pair<int, int> P;
map<pair<int, int>, int> gmemo;
int gcd(int a, int b) {
if (gmemo[{a, b}] != 0)
return gmemo[{a, b}];
if (gmemo[{b, a}] != 0)
return gmemo[{b, a}];
if (a % b == 0)
return gmemo[{a, b}] = b;
else
return gmemo[{a, b}] = gcd(b, a % b);
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
bool prime(int a) {
if (a == 1)
return false;
for (int i = 2; i * i <= a; i++) {
if (a % i == 0)
return false;
}
return true;
}
signed main() {
int n, ans = 0, cntab = 0, cntb = 0, cnta = 0;
string s[10000];
cin >> n;
rep(i, n) {
cin >> s[i];
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
cntab++;
else if (s[i][0] == 'B')
cntb++;
else if (s[i][s[i].size() - 1] == 'A')
cnta++;
rep(j, s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
ans += (max(0ll, cntab - 1) + min(cnta, cntb));
if (abs(cnta - cntb) > 0)
ans++;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) REP(i, 0, n)
#define REP(i, l, r) for (long long i = l; i < r; i++)
#define int long long
using namespace std;
typedef pair<int, int> P;
map<pair<int, int>, int> gmemo;
int gcd(int a, int b) {
if (gmemo[{a, b}] != 0)
return gmemo[{a, b}];
if (gmemo[{b, a}] != 0)
return gmemo[{b, a}];
if (a % b == 0)
return gmemo[{a, b}] = b;
else
return gmemo[{a, b}] = gcd(b, a % b);
}
int lcm(int a, int b) { return a * b / gcd(a, b); }
bool prime(int a) {
if (a == 1)
return false;
for (int i = 2; i * i <= a; i++) {
if (a % i == 0)
return false;
}
return true;
}
signed main() {
int n, ans = 0, cntab = 0, cntb = 0, cnta = 0;
string s[10000];
cin >> n;
rep(i, n) {
cin >> s[i];
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
cntab++;
else if (s[i][0] == 'B')
cntb++;
else if (s[i][s[i].size() - 1] == 'A')
cnta++;
rep(j, s[i].size() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
ans += (max(0ll, cntab - 1) + min(cnta, cntb));
if (max(cnta, cntb) > 0 && cntab > 0)
ans++;
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"call.function.change",
"control_flow.branch.if.condition.change"
] | 866,728 | 866,727 | u073057072 | cpp |
p03049 | #include <bits/stdc++.h>
#define rep(i, m) for (long long i = 0; i < m; i++)
#define per(i, m) for (long long i = m - 1; i >= 0; i--)
#define FOR(i, n, m) for (long long i = n; i < m; i++)
#define ROF(i, n, m) for (long long i = m - 1; i >= n; i--)
#define SORT(v, n) \
do { \
sort(v, v + n); \
reverse(v, v + n); \
} while (0)
#define all(x) (x).begin(), (x).end()
#define EPS (1e-7)
#define INF (1e18)
#define PI (acos(-1))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
typedef pair<ll, ll> LP;
ll POW(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW(x * x, n / 2) % MOD;
return x % MOD * POW(x, n - 1) % MOD;
}
ll POW2(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW2(x * x, n / 2);
return x * POW2(x, n - 1);
}
ll gcd(ll u, ll v) {
ll r;
while (0 != v) {
r = u % v;
u = v;
v = r;
}
return u;
}
ll lcm(ll u, ll v) { return u * v / gcd(u, v); }
ll KAI(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI(m - 1) % MOD;
}
ll KAI2(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI2(m - 1);
}
ll extGCD(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
inline ll mod(ll a, ll m) { return (a % m + m) % m; }
ll modinv(ll a) {
ll x, y;
extGCD(a, MOD, x, y);
return mod(x, MOD);
}
ll COM(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI(m) % MOD * modinv(KAI(n) % MOD * KAI(m - n) % MOD) % MOD;
}
ll COM2(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI2(m) / KAI2(n) / KAI2(m - n);
}
ll DEC(ll x, ll m, ll n) { return x % POW(m, n + 1) / POW(m, n); }
ll keta(ll x, ll n) {
if (x == 0)
return 0;
return keta(x / n, n) + 1;
}
ll DIV(ll x, ll n) {
if (x == 0)
return 0;
return x / n + DIV(x / n, n);
}
ll ORD(ll x, ll n) {
if (x == 0)
return INF;
if (x % n != 0)
return 0;
return 1 + ORD(x / n, n);
}
int main() {
ll n, a = 0, b = 0, ans = 0, c = 0;
string s[12000];
cin >> n;
rep(i, n) cin >> s[i];
rep(i, n) {
if (s[i][s[i].length() - 1] == 'A')
a++;
if (s[i][0] == 'B')
b++;
if (s[i][0] == 'B' && s[i][s[i].length() - 1] == 'A')
c++;
}
rep(i, n) {
rep(j, s[i].length() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
ans += min(a, b);
if (a == c && b == c)
ans--;
printf("%lld", ans);
} | #include <bits/stdc++.h>
#define rep(i, m) for (long long i = 0; i < m; i++)
#define per(i, m) for (long long i = m - 1; i >= 0; i--)
#define FOR(i, n, m) for (long long i = n; i < m; i++)
#define ROF(i, n, m) for (long long i = m - 1; i >= n; i--)
#define SORT(v, n) \
do { \
sort(v, v + n); \
reverse(v, v + n); \
} while (0)
#define all(x) (x).begin(), (x).end()
#define EPS (1e-7)
#define INF (1e18)
#define PI (acos(-1))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
typedef pair<ll, ll> LP;
ll POW(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW(x * x, n / 2) % MOD;
return x % MOD * POW(x, n - 1) % MOD;
}
ll POW2(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW2(x * x, n / 2);
return x * POW2(x, n - 1);
}
ll gcd(ll u, ll v) {
ll r;
while (0 != v) {
r = u % v;
u = v;
v = r;
}
return u;
}
ll lcm(ll u, ll v) { return u * v / gcd(u, v); }
ll KAI(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI(m - 1) % MOD;
}
ll KAI2(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI2(m - 1);
}
ll extGCD(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
inline ll mod(ll a, ll m) { return (a % m + m) % m; }
ll modinv(ll a) {
ll x, y;
extGCD(a, MOD, x, y);
return mod(x, MOD);
}
ll COM(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI(m) % MOD * modinv(KAI(n) % MOD * KAI(m - n) % MOD) % MOD;
}
ll COM2(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI2(m) / KAI2(n) / KAI2(m - n);
}
ll DEC(ll x, ll m, ll n) { return x % POW(m, n + 1) / POW(m, n); }
ll keta(ll x, ll n) {
if (x == 0)
return 0;
return keta(x / n, n) + 1;
}
ll DIV(ll x, ll n) {
if (x == 0)
return 0;
return x / n + DIV(x / n, n);
}
ll ORD(ll x, ll n) {
if (x == 0)
return INF;
if (x % n != 0)
return 0;
return 1 + ORD(x / n, n);
}
int main() {
ll n, a = 0, b = 0, ans = 0, c = 0;
string s[12000];
cin >> n;
rep(i, n) cin >> s[i];
rep(i, n) {
if (s[i][s[i].length() - 1] == 'A')
a++;
if (s[i][0] == 'B')
b++;
if (s[i][0] == 'B' && s[i][s[i].length() - 1] == 'A')
c++;
}
rep(i, n) {
rep(j, s[i].length() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
ans += min(a, b);
if (a == c && b == c && c != 0)
ans--;
printf("%lld", ans);
} | [
"control_flow.branch.if.condition.change"
] | 866,731 | 866,730 | u107995903 | cpp |
p03049 | #include <bits/stdc++.h>
#define rep(i, m) for (long long i = 0; i < m; i++)
#define per(i, m) for (long long i = m - 1; i >= 0; i--)
#define FOR(i, n, m) for (long long i = n; i < m; i++)
#define ROF(i, n, m) for (long long i = m - 1; i >= n; i--)
#define SORT(v, n) \
do { \
sort(v, v + n); \
reverse(v, v + n); \
} while (0)
#define all(x) (x).begin(), (x).end()
#define EPS (1e-7)
#define INF (1e18)
#define PI (acos(-1))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
typedef pair<ll, ll> LP;
ll POW(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW(x * x, n / 2) % MOD;
return x % MOD * POW(x, n - 1) % MOD;
}
ll POW2(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW2(x * x, n / 2);
return x * POW2(x, n - 1);
}
ll gcd(ll u, ll v) {
ll r;
while (0 != v) {
r = u % v;
u = v;
v = r;
}
return u;
}
ll lcm(ll u, ll v) { return u * v / gcd(u, v); }
ll KAI(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI(m - 1) % MOD;
}
ll KAI2(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI2(m - 1);
}
ll extGCD(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
inline ll mod(ll a, ll m) { return (a % m + m) % m; }
ll modinv(ll a) {
ll x, y;
extGCD(a, MOD, x, y);
return mod(x, MOD);
}
ll COM(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI(m) % MOD * modinv(KAI(n) % MOD * KAI(m - n) % MOD) % MOD;
}
ll COM2(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI2(m) / KAI2(n) / KAI2(m - n);
}
ll DEC(ll x, ll m, ll n) { return x % POW(m, n + 1) / POW(m, n); }
ll keta(ll x, ll n) {
if (x == 0)
return 0;
return keta(x / n, n) + 1;
}
ll DIV(ll x, ll n) {
if (x == 0)
return 0;
return x / n + DIV(x / n, n);
}
ll ORD(ll x, ll n) {
if (x == 0)
return INF;
if (x % n != 0)
return 0;
return 1 + ORD(x / n, n);
}
int main() {
ll n, a = 0, b = 0, ans = 0, c = 0;
string s[15];
cin >> n;
rep(i, n) cin >> s[i];
rep(i, n) {
if (s[i][s[i].length() - 1] == 'A')
a++;
if (s[i][0] == 'B')
b++;
if (s[i][0] == 'B' && s[i][s[i].length() - 1] == 'A')
c++;
}
rep(i, n) {
rep(j, s[i].length() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
ans += min(a, b);
if (a == c && b == c)
ans--;
printf("%lld", ans);
} | #include <bits/stdc++.h>
#define rep(i, m) for (long long i = 0; i < m; i++)
#define per(i, m) for (long long i = m - 1; i >= 0; i--)
#define FOR(i, n, m) for (long long i = n; i < m; i++)
#define ROF(i, n, m) for (long long i = m - 1; i >= n; i--)
#define SORT(v, n) \
do { \
sort(v, v + n); \
reverse(v, v + n); \
} while (0)
#define all(x) (x).begin(), (x).end()
#define EPS (1e-7)
#define INF (1e18)
#define PI (acos(-1))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
typedef pair<ll, ll> LP;
ll POW(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW(x * x, n / 2) % MOD;
return x % MOD * POW(x, n - 1) % MOD;
}
ll POW2(ll x, ll n) {
if (n == 0)
return 1;
if (n % 2 == 0)
return POW2(x * x, n / 2);
return x * POW2(x, n - 1);
}
ll gcd(ll u, ll v) {
ll r;
while (0 != v) {
r = u % v;
u = v;
v = r;
}
return u;
}
ll lcm(ll u, ll v) { return u * v / gcd(u, v); }
ll KAI(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI(m - 1) % MOD;
}
ll KAI2(ll m) {
if (m < 0)
return 0;
if (m == 0)
return 1;
return m * KAI2(m - 1);
}
ll extGCD(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
inline ll mod(ll a, ll m) { return (a % m + m) % m; }
ll modinv(ll a) {
ll x, y;
extGCD(a, MOD, x, y);
return mod(x, MOD);
}
ll COM(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI(m) % MOD * modinv(KAI(n) % MOD * KAI(m - n) % MOD) % MOD;
}
ll COM2(ll m, ll n) {
if (m < n)
return 0;
if (n < 0)
return 0;
if (n == 0)
return 1;
if (m == n)
return 1;
return KAI2(m) / KAI2(n) / KAI2(m - n);
}
ll DEC(ll x, ll m, ll n) { return x % POW(m, n + 1) / POW(m, n); }
ll keta(ll x, ll n) {
if (x == 0)
return 0;
return keta(x / n, n) + 1;
}
ll DIV(ll x, ll n) {
if (x == 0)
return 0;
return x / n + DIV(x / n, n);
}
ll ORD(ll x, ll n) {
if (x == 0)
return INF;
if (x % n != 0)
return 0;
return 1 + ORD(x / n, n);
}
int main() {
ll n, a = 0, b = 0, ans = 0, c = 0;
string s[12000];
cin >> n;
rep(i, n) cin >> s[i];
rep(i, n) {
if (s[i][s[i].length() - 1] == 'A')
a++;
if (s[i][0] == 'B')
b++;
if (s[i][0] == 'B' && s[i][s[i].length() - 1] == 'A')
c++;
}
rep(i, n) {
rep(j, s[i].length() - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
ans += min(a, b);
if (a == c && b == c && c != 0)
ans--;
printf("%lld", ans);
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.branch.if.condition.change"
] | 866,732 | 866,730 | u107995903 | cpp |
p03049 | #include <algorithm>
#include <climits>
#include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
int main() {
int n;
std::cin >> n;
std::vector<std::string> words(n);
for (auto &s : words)
std::cin >> s;
int end_with_a{0}, start_with_b{0}, sand{0}, include{0};
for (const auto &s : words) {
if (s[0] == 'B')
++start_with_b;
if (s[s.size() - 1] == 'A')
++end_with_a;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
++sand;
for (auto i = 1; i < s.size(); ++i) {
if (s[i - 1] == 'A' && s[i] == 'B')
++include;
}
}
if (end_with_a > sand && start_with_b > sand)
std::cout << std::min(end_with_a, start_with_b) + include << std::endl;
else if (end_with_a == sand && start_with_b == sand)
std::cout << sand - 1 + include << std::endl;
else
std::cout << sand + include << std::endl;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <functional>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
int main() {
int n;
std::cin >> n;
std::vector<std::string> words(n);
for (auto &s : words)
std::cin >> s;
int end_with_a{0}, start_with_b{0}, sand{0}, include{0};
for (const auto &s : words) {
if (s[0] == 'B')
++start_with_b;
if (s[s.size() - 1] == 'A')
++end_with_a;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
++sand;
for (auto i = 1; i < s.size(); ++i) {
if (s[i - 1] == 'A' && s[i] == 'B')
++include;
}
}
if (end_with_a > sand && start_with_b > sand)
std::cout << std::min(end_with_a, start_with_b) + include << std::endl;
else if (end_with_a == sand && start_with_b == sand && sand > 0)
std::cout << sand - 1 + include << std::endl;
else
std::cout << sand + include << std::endl;
} | [
"control_flow.branch.if.condition.change"
] | 866,735 | 866,736 | u419330815 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define ZREP(i, n) for (int i = 1; i < (n); ++i)
#define int ll
#define Endl endl
signed main() {
int N;
string s[14514];
int Ans = 0;
int L = 0, R = 0, B = 0;
cin >> N;
REP(i, N) {
cin >> s[i];
int n = s[i].size();
REP(j, n - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
Ans++;
}
}
if (s[i][0] == 'B' && s[i][n - 1] == 'A') {
B++;
} else if (s[i][0] == 'B') {
L++;
} else if (s[i][n - 1] == 'A') {
R++;
}
}
// cout << Ans << " " << L << " " << R << " " << B << endl;
if (L > 0 && R > 0) {
Ans += B + 1;
L--;
R--;
} else if (L > 0 && R == 0) {
Ans += B;
L--;
} else if (L == 0 && R > 0) {
Ans += B;
R--;
} else {
Ans += B - 1;
}
Ans += min(L, R);
cout << Ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
//#define MOD 998244353
#define INF 1145141919810893364
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define OREP(i, n) for (int i = 1; i <= (n); ++i)
#define ZREP(i, n) for (int i = 1; i < (n); ++i)
#define int ll
#define Endl endl
signed main() {
int N;
string s[14514];
int Ans = 0;
int L = 0, R = 0, B = 0;
cin >> N;
REP(i, N) {
cin >> s[i];
int n = s[i].size();
REP(j, n - 1) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B') {
Ans++;
}
}
if (s[i][0] == 'B' && s[i][n - 1] == 'A') {
B++;
} else if (s[i][0] == 'B') {
L++;
} else if (s[i][n - 1] == 'A') {
R++;
}
}
// cout << Ans << " " << L << " " << R << " " << B << endl;
if (L > 0 && R > 0) {
Ans += B + 1;
L--;
R--;
} else if (L > 0 && R == 0) {
Ans += B;
L--;
} else if (L == 0 && R > 0) {
Ans += B;
R--;
} else {
Ans += max(B - 1, 0LL);
}
Ans += min(L, R);
cout << Ans << endl;
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 866,743 | 866,744 | u554953477 | cpp |
p03049 | #include <bits/stdc++.h>
#if MYDEBUG
#include "lib/cp_debug.hpp"
#else
#define DBG(...) ;
#endif
#if __cplusplus <= 201402L
template <typename T> T gcd(T a, T b) {
return ((a % b == 0) ? b : gcd(b, a % b));
}
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
#endif
using LL = long long;
constexpr LL LINF = 334ll << 53;
constexpr int INF = 15 << 26;
constexpr LL MOD = 1E9 + 7;
namespace Problem {
using namespace std;
class Solver {
public:
int n;
Solver(LL n) : n(n){};
void solve() {
vector<int> cnt(4); // XX, XA, BX, BA
int ans = 0;
for (int i = 0; i < n; ++i) {
string tmp;
cin >> tmp;
ans += countAB(tmp);
int t = 0;
if (tmp[0] == 'B')
t += 2;
if (tmp.back() == 'A')
t += 1;
cnt[t]++;
}
if (cnt[1] == 0 && cnt[2] == 0) {
ans += cnt[3] - 1;
} else {
ans += min(cnt[1] + cnt[3], cnt[2] + cnt[3]);
}
cout << ans << endl;
}
int countAB(string s) {
int ret = 0;
for (int i = 0; i < s.size() - 1; ++i) {
if (s[i] == 'A' && s[i + 1] == 'B')
ret++;
}
return ret;
}
};
} // namespace Problem
int main() {
std::cin.tie(0);
std::ios_base::sync_with_stdio(false);
// std::cout << std::fixed << std::setprecision(12);
long long n = 0;
std::cin >> n;
Problem::Solver sol(n);
sol.solve();
return 0;
}
| #include <bits/stdc++.h>
#if MYDEBUG
#include "lib/cp_debug.hpp"
#else
#define DBG(...) ;
#endif
#if __cplusplus <= 201402L
template <typename T> T gcd(T a, T b) {
return ((a % b == 0) ? b : gcd(b, a % b));
}
template <typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
#endif
using LL = long long;
constexpr LL LINF = 334ll << 53;
constexpr int INF = 15 << 26;
constexpr LL MOD = 1E9 + 7;
namespace Problem {
using namespace std;
class Solver {
public:
int n;
Solver(LL n) : n(n){};
void solve() {
vector<int> cnt(4); // XX, XA, BX, BA
int ans = 0;
for (int i = 0; i < n; ++i) {
string tmp;
cin >> tmp;
ans += countAB(tmp);
int t = 0;
if (tmp[0] == 'B')
t += 2;
if (tmp.back() == 'A')
t += 1;
cnt[t]++;
}
if (cnt[1] == 0 && cnt[2] == 0) {
ans += max(cnt[3] - 1, 0);
} else {
ans += min(cnt[1] + cnt[3], cnt[2] + cnt[3]);
}
cout << ans << endl;
}
int countAB(string s) {
int ret = 0;
for (int i = 0; i < s.size() - 1; ++i) {
if (s[i] == 'A' && s[i + 1] == 'B')
ret++;
}
return ret;
}
};
} // namespace Problem
int main() {
std::cin.tie(0);
std::ios_base::sync_with_stdio(false);
// std::cout << std::fixed << std::setprecision(12);
long long n = 0;
std::cin >> n;
Problem::Solver sol(n);
sol.solve();
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 866,745 | 866,746 | u028496463 | cpp |
p03049 | #include <iostream>
using namespace std;
int sua, sbu, sba, n, ans;
string s;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 1; j < s.size(); j++)
ans += (s[j - 1] == 'A' && s[j] == 'B');
if (s[0] == 'B' && s.back() == 'A')
sba++;
else if (s[0] == 'B')
sbu++;
else if (s.back() == 'A')
sua++;
}
if (sua > 0)
ans += sba + min(sua, sbu);
else
ans += sba - 1 + (sbu > 0);
cout << ans;
} | #include <iostream>
using namespace std;
int sua, sbu, sba, n, ans;
string s;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 1; j < s.size(); j++)
ans += (s[j - 1] == 'A' && s[j] == 'B');
if (s[0] == 'B' && s.back() == 'A')
sba++;
else if (s[0] == 'B')
sbu++;
else if (s.back() == 'A')
sua++;
}
if (sua > 0)
ans += sba + min(sua, sbu);
else if (sba > 0)
ans += sba - 1 + (sbu > 0);
cout << ans;
} | [
"control_flow.branch.if.add"
] | 866,749 | 866,750 | u494617175 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(), v.end()
#define SZ(v) ((int)v.size())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
#define bit(n) (1LL << (n))
#define bit_exist(x, n) ((x >> n) & 1)
#define Ans(f, y, n) \
if (f) \
cout << y << endl; \
else \
cout << n << endl;
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) \
cout << #v << "=" << endl; \
REP(i, v.size()) { cout << v[i] << ","; } \
cout << endl;
#define mdebug(m) \
cout << #m << "=" << endl; \
REP(i, m.size()) { \
REP(j, m[i].size()) { cout << m[i][j] << ","; } \
cout << endl; \
}
#define pb push_back
#define f first
#define s second
#define int long long
#define INF 1000000000000000000
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using PiP = pair<int, Pii>;
using PPi = pair<Pii, int>;
using bools = vector<bool>;
using pairs = vector<Pii>;
template <typename T> void readv(vector<T> &a) { REP(i, a.size()) cin >> a[i]; }
void readv_m1(vector<int> &a) {
REP(i, a.size()) {
cin >> a[i];
a[i]--;
}
}
// int dx[4] = {1,0,-1,0};
// int dy[4] = {0,1,0,-1};
const int mod = 1000000007;
// const int mod = 998244353;
#define Add(x, y) x = (x + (y)) % mod
#define Mult(x, y) x = (x * (y)) % mod
signed main() {
int N;
cin >> N;
vector<string> S(N);
readv(S);
int ans = 0;
REP(i, N) {
REP(j, SZ(S[i]) - 1) if (S[i][j] == 'A' && S[i][j + 1] == 'B') ans++;
}
int hB = 0, tA = 0;
int w = 0;
REP(i, N) {
if (S[i][0] == 'B')
hB++;
if (S[i][SZ(S[i]) - 1] == 'A')
tA++;
if (S[i][0] == 'B' && S[i][SZ(S[i]) - 1] == 'A')
w++;
}
int tmp = min(tA, hB);
if (tA == w && hB == w)
tmp--;
ans += tmp;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define FOR(i, begin, end) for (int i = (begin); i < (end); i++)
#define REP(i, n) FOR(i, 0, n)
#define IFOR(i, begin, end) for (int i = (end)-1; i >= (begin); i--)
#define IREP(i, n) IFOR(i, 0, n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define all(v) v.begin(), v.end()
#define SZ(v) ((int)v.size())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
#define bit(n) (1LL << (n))
#define bit_exist(x, n) ((x >> n) & 1)
#define Ans(f, y, n) \
if (f) \
cout << y << endl; \
else \
cout << n << endl;
#define debug(x) cout << #x << "=" << x << endl;
#define vdebug(v) \
cout << #v << "=" << endl; \
REP(i, v.size()) { cout << v[i] << ","; } \
cout << endl;
#define mdebug(m) \
cout << #m << "=" << endl; \
REP(i, m.size()) { \
REP(j, m[i].size()) { cout << m[i][j] << ","; } \
cout << endl; \
}
#define pb push_back
#define f first
#define s second
#define int long long
#define INF 1000000000000000000
using vec = vector<int>;
using mat = vector<vec>;
using Pii = pair<int, int>;
using PiP = pair<int, Pii>;
using PPi = pair<Pii, int>;
using bools = vector<bool>;
using pairs = vector<Pii>;
template <typename T> void readv(vector<T> &a) { REP(i, a.size()) cin >> a[i]; }
void readv_m1(vector<int> &a) {
REP(i, a.size()) {
cin >> a[i];
a[i]--;
}
}
// int dx[4] = {1,0,-1,0};
// int dy[4] = {0,1,0,-1};
const int mod = 1000000007;
// const int mod = 998244353;
#define Add(x, y) x = (x + (y)) % mod
#define Mult(x, y) x = (x * (y)) % mod
signed main() {
int N;
cin >> N;
vector<string> S(N);
readv(S);
int ans = 0;
REP(i, N) {
REP(j, SZ(S[i]) - 1) if (S[i][j] == 'A' && S[i][j + 1] == 'B') ans++;
}
int hB = 0, tA = 0;
int w = 0;
REP(i, N) {
if (S[i][0] == 'B')
hB++;
if (S[i][SZ(S[i]) - 1] == 'A')
tA++;
if (S[i][0] == 'B' && S[i][SZ(S[i]) - 1] == 'A')
w++;
}
int tmp = min(tA, hB);
if (tA == w && hB == w && tmp >= 1)
tmp--;
ans += tmp;
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 866,751 | 866,752 | u434231045 | cpp |
p03049 | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
using namespace std;
using namespace std::chrono;
typedef long long int llint;
typedef double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
/*cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);*/
const llint mod = 1000000007;
const llint big = 2.19e15 + 1;
const long double pai = 3.141592653589793238462643383279502884197;
const long double eps = 1e-15;
template <class T, class U> bool mineq(T &a, U b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool maxeq(T &a, U b) {
if (a < b) {
a = b;
return true;
}
return false;
}
llint gcd(llint a, llint b) {
if (a % b == 0) {
return b;
} else
return gcd(b, a % b);
}
llint lcm(llint a, llint b) {
if (a == 0) {
return b;
}
return a / gcd(a, b) * b;
}
template <class T> void SO(T &ve) { sort(ve.begin(), ve.end()); }
template <class T> void REV(T &ve) { reverse(ve.begin(), ve.end()); }
template <class T> llint LBI(vector<T> &ar, T in) {
return lower_bound(ar.begin(), ar.end(), in) - ar.begin();
}
template <class T> llint UBI(vector<T> &ar, T in) {
return upper_bound(ar.begin(), ar.end(), in) - ar.begin();
}
int main(void) {
int i, n;
cin >> n;
int ans = 0, A = 0, B = 0, kata = 0;
for (i = 0; i < n; i++) {
string str;
cin >> str;
for (int j = 0; j + 1 < str.size(); j++) {
if (str[j] == 'A' && str[j + 1] == 'B') {
ans++;
}
}
if (str.back() == 'A') {
A++;
}
if (str[0] == 'B') {
B++;
}
if ((str.back() == 'A') != (str[0] == 'B')) {
kata = 1;
}
}
cout << ans + min(A, B) - 1 + kata << endl;
} | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
using namespace std;
using namespace std::chrono;
typedef long long int llint;
typedef double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
/*cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);*/
const llint mod = 1000000007;
const llint big = 2.19e15 + 1;
const long double pai = 3.141592653589793238462643383279502884197;
const long double eps = 1e-15;
template <class T, class U> bool mineq(T &a, U b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool maxeq(T &a, U b) {
if (a < b) {
a = b;
return true;
}
return false;
}
llint gcd(llint a, llint b) {
if (a % b == 0) {
return b;
} else
return gcd(b, a % b);
}
llint lcm(llint a, llint b) {
if (a == 0) {
return b;
}
return a / gcd(a, b) * b;
}
template <class T> void SO(T &ve) { sort(ve.begin(), ve.end()); }
template <class T> void REV(T &ve) { reverse(ve.begin(), ve.end()); }
template <class T> llint LBI(vector<T> &ar, T in) {
return lower_bound(ar.begin(), ar.end(), in) - ar.begin();
}
template <class T> llint UBI(vector<T> &ar, T in) {
return upper_bound(ar.begin(), ar.end(), in) - ar.begin();
}
int main(void) {
int i, n;
cin >> n;
int ans = 0, A = 0, B = 0, kata = 0;
for (i = 0; i < n; i++) {
string str;
cin >> str;
for (int j = 0; j + 1 < str.size(); j++) {
if (str[j] == 'A' && str[j + 1] == 'B') {
ans++;
}
}
if (str.back() == 'A') {
A++;
}
if (str[0] == 'B') {
B++;
}
if ((str.back() == 'A') != (str[0] == 'B')) {
kata = 1;
}
}
cout << ans + max(0, min(A, B) - 1 + kata) << endl;
}
| [
"call.add",
"call.arguments.change"
] | 866,753 | 866,754 | u483814783 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repp(i, l, r) for (int i = (l); i < (r); i++)
#define per(i, n) for (int i = ((n)-1); i >= 0; i--)
#define perr(i, l, r) for (int i = ((r)-1); i >= (l); i--)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define IINF 1000000000
#define LINF 1000000000000000000
#define SP << " " <<
#define CYES cout << "Yes" << endl;
#define CNO cout << "No" << endl;
typedef long long LL;
typedef long double LD;
int main() {
int n;
cin >> n;
int a = 0, b = 0;
int x = 0;
string s;
int ans = 0;
rep(i, n) {
cin >> s;
if (s[s.size() - 1] == 'A')
a++;
if (s[0] == 'B')
b++;
if (s[s.size() - 1] == 'A' && s[0] == 'B')
x++;
rep(j, s.size() - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
}
// cout << x SP a SP b << endl;
if (a - x > 0 || b - x > 0)
ans += min(a, b);
else
ans += min(a, b) - 1;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repp(i, l, r) for (int i = (l); i < (r); i++)
#define per(i, n) for (int i = ((n)-1); i >= 0; i--)
#define perr(i, l, r) for (int i = ((r)-1); i >= (l); i--)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define IINF 1000000000
#define LINF 1000000000000000000
#define SP << " " <<
#define CYES cout << "Yes" << endl;
#define CNO cout << "No" << endl;
typedef long long LL;
typedef long double LD;
int main() {
int n;
cin >> n;
int a = 0, b = 0;
int x = 0;
string s;
int ans = 0;
rep(i, n) {
cin >> s;
if (s[s.size() - 1] == 'A')
a++;
if (s[0] == 'B')
b++;
if (s[s.size() - 1] == 'A' && s[0] == 'B')
x++;
rep(j, s.size() - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
}
if (a - x > 0 || b - x > 0)
ans += min(a, b);
else
ans += max(0, min(a, b) - 1);
cout << ans << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 866,755 | 866,756 | u405923605 | cpp |
p03049 | #include <bits/stdc++.h>
#define ADD(a, b) a = (a + ll(b)) % mod
#define MUL(a, b) a = (a * ll(b)) % mod
#define MAX(a, b) a = max(a, b)
#define MIN(a, b) a = min(a, b)
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
#define rer(i, a, b) for (int i = int(a) - 1; i >= int(b); i--)
#define all(a) (a).begin(), (a).end()
#define sz(v) (int)(v).size()
#define pb push_back
#define sec second
#define fst first
#define debug(fmt, ...) Debug(__LINE__, ":", fmt, ##__VA_ARGS__)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<int, pi> ppi;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> mat;
typedef complex<double> comp;
void Debug() { cerr << '\n'; }
template <class FIRST, class... REST> void Debug(FIRST arg, REST... rest) {
cerr << arg << " ";
Debug(rest...);
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
if (!v.empty()) {
rep(i, 0, sz(v) - 1) out << v[i] << ", ";
out << v.back();
}
out << "]";
return out;
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &v) {
out << "(" << v.first << ", " << v.second << ")";
return out;
}
const int MAX_N = 300010;
const int MAX_V = 100010;
const double eps = 1e-6;
const ll mod = 1000000007;
const int inf = 1 << 30;
const ll linf = 1LL << 60;
const double PI = 3.14159265358979323846;
mt19937 rng; // use it by rng() % mod, shuffle(all(vec), rng)
///////////////////////////////////////////////////////////////////////////////////////////////////
int N;
void solve() {
cin >> N;
ll res = 0;
int a = 0, b = 0, c = 0;
rep(i, 0, N) {
string str;
cin >> str;
int n = sz(str);
rep(i, 0, n - 1) {
if (str[i] == 'A' && str[i + 1] == 'B')
res++;
}
if (str[0] == 'B' && str[n - 1] == 'A')
a++;
else if (str[0] == 'B')
b++;
else if (str[n - 1] == 'A')
c++;
}
debug(res, a, b, c);
if (b || c) {
cout << res + a + min(b, c) << "\n";
} else {
cout << res + a - 1 << "\n";
}
}
uint32_t rd() {
uint32_t res;
#ifdef __MINGW32__
asm volatile("rdrand %0" : "=a"(res)::"cc");
#else
res = std::random_device()();
#endif
return res;
}
int main() {
#ifndef LOCAL
ios::sync_with_stdio(false);
cin.tie(0);
#endif
cout << fixed;
cout.precision(20);
cerr << fixed;
cerr.precision(6);
rng.seed(rd());
#ifdef LOCAL
// freopen("in.txt", "wt", stdout); //for tester
freopen("in.txt", "rt", stdin);
#endif
solve();
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
| #include <bits/stdc++.h>
#define ADD(a, b) a = (a + ll(b)) % mod
#define MUL(a, b) a = (a * ll(b)) % mod
#define MAX(a, b) a = max(a, b)
#define MIN(a, b) a = min(a, b)
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
#define rer(i, a, b) for (int i = int(a) - 1; i >= int(b); i--)
#define all(a) (a).begin(), (a).end()
#define sz(v) (int)(v).size()
#define pb push_back
#define sec second
#define fst first
#define debug(fmt, ...) Debug(__LINE__, ":", fmt, ##__VA_ARGS__)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<int, pi> ppi;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vl> mat;
typedef complex<double> comp;
void Debug() { cerr << '\n'; }
template <class FIRST, class... REST> void Debug(FIRST arg, REST... rest) {
cerr << arg << " ";
Debug(rest...);
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
if (!v.empty()) {
rep(i, 0, sz(v) - 1) out << v[i] << ", ";
out << v.back();
}
out << "]";
return out;
}
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &v) {
out << "(" << v.first << ", " << v.second << ")";
return out;
}
const int MAX_N = 300010;
const int MAX_V = 100010;
const double eps = 1e-6;
const ll mod = 1000000007;
const int inf = 1 << 30;
const ll linf = 1LL << 60;
const double PI = 3.14159265358979323846;
mt19937 rng; // use it by rng() % mod, shuffle(all(vec), rng)
///////////////////////////////////////////////////////////////////////////////////////////////////
int N;
void solve() {
cin >> N;
ll res = 0;
int a = 0, b = 0, c = 0;
rep(i, 0, N) {
string str;
cin >> str;
int n = sz(str);
rep(i, 0, n - 1) {
if (str[i] == 'A' && str[i + 1] == 'B')
res++;
}
if (str[0] == 'B' && str[n - 1] == 'A')
a++;
else if (str[0] == 'B')
b++;
else if (str[n - 1] == 'A')
c++;
}
debug(res, a, b, c);
if (b || c) {
cout << res + a + min(b, c) << "\n";
} else {
cout << res + max(a - 1, 0) << "\n";
}
}
uint32_t rd() {
uint32_t res;
#ifdef __MINGW32__
asm volatile("rdrand %0" : "=a"(res)::"cc");
#else
res = std::random_device()();
#endif
return res;
}
int main() {
#ifndef LOCAL
ios::sync_with_stdio(false);
cin.tie(0);
#endif
cout << fixed;
cout.precision(20);
cerr << fixed;
cerr.precision(6);
rng.seed(rd());
#ifdef LOCAL
// freopen("in.txt", "wt", stdout); //for tester
freopen("in.txt", "rt", stdin);
#endif
solve();
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 866,757 | 866,758 | u491153752 | cpp |
p03049 | ///////////////////////// _LeMur_
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
const int N = 100005;
const int inf = 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
int n;
int a, b, c;
int main() {
mt19937 myrand(chrono::steady_clock::now().time_since_epoch().count());
cin >> n;
int answ = 0;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 1; j < (int)s.size(); j++) {
if (s[j - 1] == 'A' && s[j] == 'B') {
++answ;
}
}
if (s[0] == 'B' && s[(int)s.size() - 1] == 'A') {
++a;
continue;
}
if (s[0] == 'B') {
++b;
}
if (s[(int)s.size() - 1] == 'A') {
++c;
}
}
answ += a - 1;
if (c) {
--c;
++answ;
}
if (b) {
--b;
++answ;
}
answ += min(b, c);
cout << answ << endl;
return 0;
}
| ///////////////////////// _LeMur_
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
const int N = 100005;
const int inf = 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
int n;
int a, b, c;
int main() {
mt19937 myrand(chrono::steady_clock::now().time_since_epoch().count());
cin >> n;
int answ = 0;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 1; j < (int)s.size(); j++) {
if (s[j - 1] == 'A' && s[j] == 'B') {
++answ;
}
}
if (s[0] == 'B' && s[(int)s.size() - 1] == 'A') {
++a;
continue;
}
if (s[0] == 'B') {
++b;
}
if (s[(int)s.size() - 1] == 'A') {
++c;
}
}
if (a) {
answ += a - 1;
if (c) {
--c;
++answ;
}
if (b) {
--b;
++answ;
}
}
answ += min(b, c);
cout << answ << endl;
return 0;
}
| [
"control_flow.branch.if.add"
] | 866,759 | 866,760 | u144340663 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<ll, ll> P;
#define M 1000000007
#define F first
#define S second
#define PB push_back
#define INF 100000000000000000
int n, ans, a, b, c;
string s;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j + 1 < s.size(); j++) {
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
if (s[0] == 'B')
b++;
if (s[s.size() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
c++;
}
if (a == c)
b--;
cout << ans + min(a, b) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double D;
typedef pair<ll, ll> P;
#define M 1000000007
#define F first
#define S second
#define PB push_back
#define INF 100000000000000000
int n, ans, a, b, c;
string s;
int main(void) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j + 1 < s.size(); j++) {
if (s[j] == 'A' && s[j + 1] == 'B')
ans++;
}
if (s[0] == 'B')
b++;
if (s[s.size() - 1] == 'A')
a++;
if (s[0] == 'B' && s[s.size() - 1] == 'A')
c++;
}
if (a == c && b > 0)
b--;
cout << ans + min(a, b) << endl;
} | [
"control_flow.branch.if.condition.change"
] | 866,761 | 866,762 | u743900647 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int, int> P;
#define pb push_back
#define ft first
#define sd second
#define mp make_pair
#define fr(i, n) for (int i = 0; i < (n); i++)
#define Fr(i, n) for (int i = 0; i++ < (n);)
#define ifr(i, n) for (int i = (n)-1; i >= 0; i--)
#define iFr(i, n) for (int i = (n); i > 0; i--)
int main() {
int n, ans = 0, f = 0, b = 0;
bool r = 1;
string s;
cin >> n;
fr(i, n) {
cin >> s;
if (s[0] == 'B') {
f++;
if (s[s.length() - 1] != 'A')
r = 0;
}
fr(j, s.length() - 1) if (s[j] == 'A' && s[j + 1] == 'B') ans++;
if (s[s.length() - 1] == 'A') {
b++;
if (s[0] != 'B')
r = 0;
}
}
cout << ans + min(f, b) - r << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int, int> P;
#define pb push_back
#define ft first
#define sd second
#define mp make_pair
#define fr(i, n) for (int i = 0; i < (n); i++)
#define Fr(i, n) for (int i = 0; i++ < (n);)
#define ifr(i, n) for (int i = (n)-1; i >= 0; i--)
#define iFr(i, n) for (int i = (n); i > 0; i--)
int main() {
int n, ans = 0, f = 0, b = 0;
bool r = 1;
string s;
cin >> n;
fr(i, n) {
cin >> s;
if (s[0] == 'B') {
f++;
if (s[s.length() - 1] != 'A')
r = 0;
}
fr(j, s.length() - 1) if (s[j] == 'A' && s[j + 1] == 'B') ans++;
if (s[s.length() - 1] == 'A') {
b++;
if (s[0] != 'B')
r = 0;
}
}
cout << ans + max(min(f, b) - r, 0) << endl;
} | [
"call.add",
"call.arguments.add"
] | 866,765 | 866,766 | u434208140 | cpp |
p03049 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <unistd.h>
#include <vector>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef pair<double, ll> pdlg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
typedef vector<ll> vll;
typedef vector<vector<ll>> matrix;
#define REP(i, x, y) for (ll i = (ll)x; i < (ll)y; i++)
#define DREP(i, x, y, d) for (ll i = (ll)x; i < (ll)y; i += (ll)d)
#define PER(i, x, y) for (ll i = (ll)x; i > (ll)y; i--)
#define DPER(i, x, y, d) for (ll i = (ll)x; i > (ll)y; i -= (ll)d)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 1000000007;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-12;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
ll anum = 0;
ll bnum = 0;
ll ans = 0;
ll num = 0;
REP(i, 0, N) {
string s;
cin >> s;
ll len = s.size();
REP(j, 0, len - 1) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans++;
}
}
if (s[0] == 'B') {
bnum++;
}
if (s[len - 1] == 'A') {
anum++;
}
if (s[0] == 'B' && s[len - 1] == 'A') {
num++;
}
}
ans += min(anum, bnum);
if (num == anum && anum == bnum) {
ans--;
}
cout << ans << endl;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <unistd.h>
#include <vector>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef pair<double, ll> pdlg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
typedef vector<ll> vll;
typedef vector<vector<ll>> matrix;
#define REP(i, x, y) for (ll i = (ll)x; i < (ll)y; i++)
#define DREP(i, x, y, d) for (ll i = (ll)x; i < (ll)y; i += (ll)d)
#define PER(i, x, y) for (ll i = (ll)x; i > (ll)y; i--)
#define DPER(i, x, y, d) for (ll i = (ll)x; i > (ll)y; i -= (ll)d)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 1000000007;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-12;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
ll anum = 0;
ll bnum = 0;
ll ans = 0;
ll num = 0;
REP(i, 0, N) {
string s;
cin >> s;
ll len = s.size();
REP(j, 0, len - 1) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans++;
}
}
if (s[0] == 'B') {
bnum++;
}
if (s[len - 1] == 'A') {
anum++;
}
if (s[0] == 'B' && s[len - 1] == 'A') {
num++;
}
}
ans += min(anum, bnum);
if (num == anum && anum == bnum && anum > 0) {
ans--;
}
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 866,767 | 866,768 | u006204672 | cpp |
p03049 | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
const long long int MOD = 1000000007;
// const int MOD = 1000000007;
// const int MOD = 998244353;
// const long long int MOD = 998244353;
long long int N, M, K, H, W, L, R;
// int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
vector<string> s(N);
for (auto &i : s)
cin >> i;
int num = 0;
int aed = 0;
int bst = 0;
int ab = 0;
for (auto i : s) {
for (int j = 0; j < i.size() - 1; j++) {
if (i[j] == 'A' && i[j + 1] == 'B')
num++;
}
if (i.back() == 'A')
aed++;
if (i.front() == 'B')
bst++;
if (i.back() == 'A' && i.front() == 'B')
ab++;
}
int add = min(aed, bst);
if (max(aed, bst) == ab)
add--;
cout << num + add << endl;
return 0;
} | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
const long long int MOD = 1000000007;
// const int MOD = 1000000007;
// const int MOD = 998244353;
// const long long int MOD = 998244353;
long long int N, M, K, H, W, L, R;
// int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
vector<string> s(N);
for (auto &i : s)
cin >> i;
int num = 0;
int aed = 0;
int bst = 0;
int ab = 0;
for (auto i : s) {
for (int j = 0; j < i.size() - 1; j++) {
if (i[j] == 'A' && i[j + 1] == 'B')
num++;
}
if (i.back() == 'A')
aed++;
if (i.front() == 'B')
bst++;
if (i.back() == 'A' && i.front() == 'B')
ab++;
}
int add = min(aed, bst);
if (max(aed, bst) == ab && ab)
add--;
cout << num + add << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 866,771 | 866,772 | u468700753 | cpp |
p03049 | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
const long long int MOD = 1000000007;
// const int MOD = 1000000007;
// const int MOD = 998244353;
// const long long int MOD = 998244353;
long long int N, M, K, H, W, L, R;
// int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
vector<string> s(N);
for (auto &i : s)
cin >> i;
int num = 0;
int aed = 0;
int bst = 0;
int ab = 0;
for (auto i : s) {
for (int j = 0; j < s.size() - 1; j++) {
if (i[j] == 'A' && i[j + 1] == 'B')
num++;
}
if (i.back() == 'A')
aed++;
if (i.front() == 'B')
bst++;
if (i.back() == 'A' && i.front() == 'B')
ab++;
}
int add = min(aed, bst);
if (max(aed, bst) == ab)
add--;
cout << num + add << endl;
return 0;
} | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
const long long int MOD = 1000000007;
// const int MOD = 1000000007;
// const int MOD = 998244353;
// const long long int MOD = 998244353;
long long int N, M, K, H, W, L, R;
// int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
vector<string> s(N);
for (auto &i : s)
cin >> i;
int num = 0;
int aed = 0;
int bst = 0;
int ab = 0;
for (auto i : s) {
for (int j = 0; j < i.size() - 1; j++) {
if (i[j] == 'A' && i[j + 1] == 'B')
num++;
}
if (i.back() == 'A')
aed++;
if (i.front() == 'B')
bst++;
if (i.back() == 'A' && i.front() == 'B')
ab++;
}
int add = min(aed, bst);
if (max(aed, bst) == ab && ab)
add--;
cout << num + add << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 866,773 | 866,772 | u468700753 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
#define fore(i, a) for (auto &i : a)
#define REP(i, n) for (int i = 0; i < n; i++)
#define eREP(i, n) for (int i = 0; i <= n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define eFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define SORT(c) sort((c).begin(), (c).end())
#define rSORT(c) sort((c).rbegin(), (c).rend())
#define LB(x, a) lower_bound((x).begin(), (x).end(), (a))
#define UB(x, a) upper_bound((x).begin(), (x).end(), (a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
// vector<vector<int> > dp;
// vector<vector<vector<int> > > vvvi;
// dp=vector<vector<int> >(N, vector<int>(M,0));
// vector<pair<int,int> > v;
// v.push_back(make_pair(x,y));
// priority_queue<int,vector<int>, greater<int> > q2;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int ans = 0, asum = 0, bsum = 0, absum = 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[S.size() - 1] == 'A')
absum++;
else if (S[0] == 'B')
bsum++;
else if (S[S.size() - 1] == 'A')
asum++;
}
if (asum == 0 && bsum == 0) {
absum--;
}
cout << ans + min(asum + absum, bsum + absum) << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
#define fore(i, a) for (auto &i : a)
#define REP(i, n) for (int i = 0; i < n; i++)
#define eREP(i, n) for (int i = 0; i <= n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define eFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define SORT(c) sort((c).begin(), (c).end())
#define rSORT(c) sort((c).rbegin(), (c).rend())
#define LB(x, a) lower_bound((x).begin(), (x).end(), (a))
#define UB(x, a) upper_bound((x).begin(), (x).end(), (a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
// vector<vector<int> > dp;
// vector<vector<vector<int> > > vvvi;
// dp=vector<vector<int> >(N, vector<int>(M,0));
// vector<pair<int,int> > v;
// v.push_back(make_pair(x,y));
// priority_queue<int,vector<int>, greater<int> > q2;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int ans = 0, asum = 0, bsum = 0, absum = 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[S.size() - 1] == 'A')
absum++;
else if (S[0] == 'B')
bsum++;
else if (S[S.size() - 1] == 'A')
asum++;
}
if (asum == 0 && bsum == 0 && absum != 0) {
absum--;
}
cout << ans + min(asum + absum, bsum + absum) << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 866,781 | 866,782 | u266643907 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
#define fore(i, a) for (auto &i : a)
#define REP(i, n) for (int i = 0; i < n; i++)
#define eREP(i, n) for (int i = 0; i <= n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define eFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define SORT(c) sort((c).begin(), (c).end())
#define rSORT(c) sort((c).rbegin(), (c).rend())
#define LB(x, a) lower_bound((x).begin(), (x).end(), (a))
#define UB(x, a) upper_bound((x).begin(), (x).end(), (a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
// vector<vector<int> > dp;
// vector<vector<vector<int> > > vvvi;
// dp=vector<vector<int> >(N, vector<int>(M,0));
// vector<pair<int,int> > v;
// v.push_back(make_pair(x,y));
// priority_queue<int,vector<int>, greater<int> > q2;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int ans = 0, asum = 0, bsum = 0, absum = 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[S.size() - 1] == 'A')
absum++;
else if (S[0] == 'B')
bsum++;
else if (S[S.size() - 1] == 'A')
asum++;
}
if (asum == 0 && bsum == 0) {
ans--;
}
cout << ans + min(asum + absum, bsum + absum) << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
#define fore(i, a) for (auto &i : a)
#define REP(i, n) for (int i = 0; i < n; i++)
#define eREP(i, n) for (int i = 0; i <= n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define eFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define SORT(c) sort((c).begin(), (c).end())
#define rSORT(c) sort((c).rbegin(), (c).rend())
#define LB(x, a) lower_bound((x).begin(), (x).end(), (a))
#define UB(x, a) upper_bound((x).begin(), (x).end(), (a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
// vector<vector<int> > dp;
// vector<vector<vector<int> > > vvvi;
// dp=vector<vector<int> >(N, vector<int>(M,0));
// vector<pair<int,int> > v;
// v.push_back(make_pair(x,y));
// priority_queue<int,vector<int>, greater<int> > q2;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int ans = 0, asum = 0, bsum = 0, absum = 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[S.size() - 1] == 'A')
absum++;
else if (S[0] == 'B')
bsum++;
else if (S[S.size() - 1] == 'A')
asum++;
}
if (asum == 0 && bsum == 0 && absum != 0) {
absum--;
}
cout << ans + min(asum + absum, bsum + absum) << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"identifier.change"
] | 866,783 | 866,782 | u266643907 | cpp |
p03049 |
#include <algorithm>
#include <cctype>
#include <climits>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <typeinfo>
#include <utility>
#include <vector>
#define all(x) (x).begin(), (x).end()
#define rep(i, m, n) for (int i = m; i < n; ++i)
#define pb push_back
#define fore(i, a) for (auto &i : a)
#define rrep(i, m, n) for (int i = m; i >= n; --i)
#define INF INT_MAX / 2
using namespace std;
using ll = long long;
using R = double;
using Data = pair<ll, vector<int>>;
const ll MOD = 1e9 + 7;
const ll inf = 1LL << 50;
struct edge {
ll from;
ll to;
ll cost;
};
typedef tuple<ll, ll, ll> T;
typedef pair<int, int> pint;
int cnt(string s) {
int ret = 0;
rep(i, 1, s.size()) {
if (s[i - 1] == 'A' && s[i] == 'B')
ret++;
}
return ret;
}
int main() {
int n;
cin >> n;
int ans = 0;
int c1 = 0;
int c2 = 0;
int c3 = 0;
rep(i, 0, n) {
string temp;
cin >> temp;
ans += cnt(temp);
char ini = temp[0];
char la = temp[temp.size() - 1];
if (ini == 'B' && la == 'A')
c1++;
else if (ini == 'B' && la != 'A')
c2++;
else if (ini != 'B' && la == 'A')
c3++;
}
if (c1 == 0)
cout << ans + min(c2, c3) << endl;
else if (c2 == 0 && c3 == 0)
cout << c1 - 1 << endl;
else
cout << c1 + min(c2, c3) << endl;
return 0;
} | #include <algorithm>
#include <cctype>
#include <climits>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <typeinfo>
#include <utility>
#include <vector>
#define all(x) (x).begin(), (x).end()
#define rep(i, m, n) for (int i = m; i < n; ++i)
#define pb push_back
#define fore(i, a) for (auto &i : a)
#define rrep(i, m, n) for (int i = m; i >= n; --i)
#define INF INT_MAX / 2
using namespace std;
using ll = long long;
using R = double;
using Data = pair<ll, vector<int>>;
const ll MOD = 1e9 + 7;
const ll inf = 1LL << 50;
struct edge {
ll from;
ll to;
ll cost;
};
typedef tuple<ll, ll, ll> T;
typedef pair<int, int> pint;
int cnt(string s) {
int ret = 0;
rep(i, 1, s.size()) {
if (s[i - 1] == 'A' && s[i] == 'B')
ret++;
}
return ret;
}
int main() {
int n;
cin >> n;
int ans = 0;
int c1 = 0;
int c2 = 0;
int c3 = 0;
rep(i, 0, n) {
string temp;
cin >> temp;
ans += cnt(temp);
char ini = temp[0];
char la = temp[temp.size() - 1];
if (ini == 'B' && la == 'A')
c1++;
else if (ini == 'B' && la != 'A')
c2++;
else if (ini != 'B' && la == 'A')
c3++;
}
if (c1 == 0)
cout << ans + min(c2, c3) << endl;
else if (c2 == 0 && c3 == 0)
cout << ans + c1 - 1 << endl;
else
cout << ans + c1 + min(c2, c3) << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 866,786 | 866,787 | u724732842 | cpp |
p03049 | #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
int A = 0;
int B = 0;
int AB = 0;
int ans = 0;
for (int j = 0; j < N; j++) {
string S;
cin >> S;
if (S[0] == 'B') {
if (S[S.size() - 1] == 'A')
AB++;
else
B++;
} else if (S[S.size() - 1] == 'A')
A++;
for (int i = 0; i < S.size() - 1; i++) {
if (S[i] == 'A' && S[i + 1] == 'B')
ans++;
}
}
int k = min(A, B) + AB;
if (A + B == 0)
k--;
ans += k;
cout << ans << endl;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
int N;
cin >> N;
int A = 0;
int B = 0;
int AB = 0;
int ans = 0;
for (int j = 0; j < N; j++) {
string S;
cin >> S;
if (S[0] == 'B') {
if (S[S.size() - 1] == 'A')
AB++;
else
B++;
} else if (S[S.size() - 1] == 'A')
A++;
for (int i = 0; i < S.size() - 1; i++) {
if (S[i] == 'A' && S[i + 1] == 'B')
ans++;
}
}
int k = min(A, B) + AB;
if (A + B == 0 && AB != 0)
k--;
ans += k;
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 866,788 | 866,789 | u058186113 | cpp |
p03049 | #include <iostream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define INF 2000000007
#define MOD 998244353
#define MAX 100005
typedef unsigned int uint;
typedef unsigned long long int ull;
typedef long long int ll;
int main() {
int N;
cin >> N;
int cnt = 0;
string str;
int frontB = 0, backA = 0, bothAB = 0;
REP(i, N) {
cin >> str;
if (str[0] == 'B' && str[str.length() - 1] == 'A')
bothAB++;
else if (str[0] == 'B')
frontB++;
else if (str[str.length() - 1] == 'A')
backA++;
REP(j, str.length() - 1) {
if (str[j] == 'A' && str[j + 1] == 'B')
cnt++;
}
}
if (bothAB == 0)
cnt = min(frontB, backA);
else if (frontB + backA > 0)
cnt = bothAB + min(frontB, backA);
else
cnt = bothAB - 1;
cout << cnt << endl;
return 0;
} | #include <iostream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define INF 2000000007
#define MOD 998244353
#define MAX 100005
typedef unsigned int uint;
typedef unsigned long long int ull;
typedef long long int ll;
int main() {
int N;
cin >> N;
int cnt = 0;
string str;
int frontB = 0, backA = 0, bothAB = 0;
REP(i, N) {
cin >> str;
if (str[0] == 'B' && str[str.length() - 1] == 'A')
bothAB++;
else if (str[0] == 'B')
frontB++;
else if (str[str.length() - 1] == 'A')
backA++;
REP(j, str.length() - 1) {
if (str[j] == 'A' && str[j + 1] == 'B')
cnt++;
}
}
if (bothAB == 0)
cnt += min(frontB, backA);
else if (frontB + backA > 0)
cnt += bothAB + min(frontB, backA);
else
cnt += bothAB - 1;
cout << cnt << endl;
return 0;
} | [
"assignment.value.change"
] | 866,799 | 866,800 | u090325904 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
string s;
int n;
cin >> n;
bool aflag = false;
int cnt = 0;
int bcnt = 0;
int acnt = 0;
int same = 0;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < s.size() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B')
cnt++;
}
if (s.front() == 'B')
acnt++;
if (s.back() == 'A')
bcnt++;
if (s.back() == 'A' && s.front() == 'B')
same++;
}
int m = 0;
if (acnt != 0 && bcnt != 0)
m = min(acnt, bcnt);
if (m == same && m != 0) {
m -= 1;
}
cout << cnt + m << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
string s;
int n;
cin >> n;
bool aflag = false;
int cnt = 0;
int bcnt = 0;
int acnt = 0;
int same = 0;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < s.size() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B')
cnt++;
}
if (s.front() == 'B')
acnt++;
if (s.back() == 'A')
bcnt++;
if (s.back() == 'A' && s.front() == 'B')
same++;
}
int m = 0;
if (acnt != 0 && bcnt != 0)
m = min(acnt, bcnt);
if (max(acnt, bcnt) == same && m != 0) {
m -= 1;
}
cout << cnt + m << endl;
} | [
"control_flow.branch.if.condition.change",
"call.arguments.add"
] | 866,801 | 866,802 | u698571659 | cpp |
p03049 | #include <assert.h>
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
i64 n;
cin >> n;
vector<string> s(n);
for (i64 i = 0; i < n; i++)
cin >> s[i];
i64 ans = 0, ea = 0, sb = 0, ba = 0;
for (i64 i = 0; i < n; i++) {
if (s[i][s[i].size() - 1] == 'A' && s[i][0] == 'B')
ba++;
else if (s[i][s[i].size() - 1] == 'A')
ea++;
else if (s[i][0] == 'B')
sb++;
for (i64 j = 0; j < s[i].size() - 1; j++)
if (s[i].substr(j, 2) == "AB")
ans++;
}
cout << ans + ba + (0 < ea + sb ? min(ea, sb) : -1) << endl;
return 0;
}
| #include <assert.h>
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int main() {
i64 n;
cin >> n;
vector<string> s(n);
for (i64 i = 0; i < n; i++)
cin >> s[i];
i64 ans = 0, ea = 0, sb = 0, ba = 0;
for (i64 i = 0; i < n; i++) {
if (s[i][s[i].size() - 1] == 'A' && s[i][0] == 'B')
ba++;
else if (s[i][s[i].size() - 1] == 'A')
ea++;
else if (s[i][0] == 'B')
sb++;
for (i64 j = 0; j < s[i].size() - 1; j++)
if (s[i].substr(j, 2) == "AB")
ans++;
}
cout << ans + ba + (0 < ea + sb || ba == 0 ? min(ea, sb) : -1) << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 866,807 | 866,808 | u623115612 | cpp |
p03049 | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
int B = 0, A = 0, BA = 0;
int ans = 0;
for (int i = 0; i < N; i++) {
string str;
cin >> str;
int len = str.length();
if (str[len - 1] == 'A' && str[0] == 'B')
BA++;
else if (str[len - 1] == 'A')
A++;
else if (str[0] == 'B')
B++;
for (int j = 1; j < len; j++) {
if (str[j - 1] == 'A' && str[j] == 'B')
ans++;
}
}
ans += BA - 1;
if (A) {
ans++;
A--;
}
if (B) {
ans++;
B--;
}
ans += min(B, A);
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
int B = 0, A = 0, BA = 0;
int ans = 0;
for (int i = 0; i < N; i++) {
string str;
cin >> str;
int len = str.length();
if (str[len - 1] == 'A' && str[0] == 'B')
BA++;
else if (str[len - 1] == 'A')
A++;
else if (str[0] == 'B')
B++;
for (int j = 1; j < len; j++) {
if (str[j - 1] == 'A' && str[j] == 'B')
ans++;
}
}
if (BA) {
ans += BA - 1;
if (A) {
ans++;
A--;
}
if (B) {
ans++;
B--;
}
}
ans += min(B, A);
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.add"
] | 866,809 | 866,810 | u450733728 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
#define INF 1LL << 60
#define MOD 1000000007;
#define pb push_back
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REPR(i, b, e) for (int i = (b); i <= (e); i++)
#define DEBUG(x) cout << #x << ": " << (x) << endl
#define DEBUGA(a) \
cout << #a << ": " << endl; \
for (const auto &v : (a)) \
cout << v << endl
int N;
int main() {
cin.tie(0);
cin >> N;
string s;
int cnt = 0;
int a = 0, b = 0, ba = 0;
REP(i, N) {
cin >> s;
int L = s.size();
REP(j, L - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
cnt++;
}
if (s[L - 1] == 'A' && s[0] == 'B') {
ba++;
} else if (s[L - 1] == 'A') {
a++;
} else if (s[0] == 'B') {
b++;
}
}
int ans = cnt + ba + min(a, b);
if (a + b == 0)
ans--;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
#define INF 1LL << 60
#define MOD 1000000007;
#define pb push_back
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REPR(i, b, e) for (int i = (b); i <= (e); i++)
#define DEBUG(x) cout << #x << ": " << (x) << endl
#define DEBUGA(a) \
cout << #a << ": " << endl; \
for (const auto &v : (a)) \
cout << v << endl
int N;
int main() {
cin.tie(0);
cin >> N;
string s;
int cnt = 0;
int a = 0, b = 0, ba = 0;
REP(i, N) {
cin >> s;
int L = s.size();
REP(j, L - 1) {
if (s[j] == 'A' && s[j + 1] == 'B')
cnt++;
}
if (s[L - 1] == 'A' && s[0] == 'B') {
ba++;
} else if (s[L - 1] == 'A') {
a++;
} else if (s[0] == 'B') {
b++;
}
}
int ans = cnt + ba + min(a, b);
if (ba > 0 && a + b == 0)
ans--;
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 866,814 | 866,815 | u703272444 | cpp |
p03049 | #include "algorithm"
#include "cstring"
#include "iostream"
#include "math.h"
#include "queue"
#include "stack"
#include "string"
#include "vector"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<ll>> mat;
int main() {
int ans = 0;
int numB = 0;
int numA = 0;
bool check = false;
int n;
cin >> n;
string s;
bool headB, tailA;
for (int i = 0; i < n; i++) {
cin >> s;
int size = s.size();
for (int j = 0; j < size - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans++;
}
}
headB = (s[0] == 'B' ? true : false);
if (s[0] == 'B') {
numB++;
}
tailA = (s[size - 1] == 'A' ? true : false);
if (s[size - 1] == 'A') {
numA++;
}
if (headB != tailA) {
check = true;
}
}
cout << (check ? ans + min(numB, numA) : max(ans + min(numB, numA) - 1, 0))
<< "\n";
}
| #include "algorithm"
#include "cstring"
#include "iostream"
#include "math.h"
#include "queue"
#include "stack"
#include "string"
#include "vector"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<vector<ll>> mat;
int main() {
int ans = 0;
int numB = 0;
int numA = 0;
bool check = false;
int n;
cin >> n;
string s;
bool headB, tailA;
for (int i = 0; i < n; i++) {
cin >> s;
int size = s.size();
for (int j = 0; j < size - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans++;
}
}
headB = (s[0] == 'B' ? true : false);
if (s[0] == 'B') {
numB++;
}
tailA = (s[size - 1] == 'A' ? true : false);
if (s[size - 1] == 'A') {
numA++;
}
if (headB != tailA) {
check = true;
}
}
cout << (check ? ans + min(numB, numA) : ans + max(min(numB, numA) - 1, 0))
<< "\n";
} | [
"call.remove",
"call.add"
] | 866,818 | 866,819 | u346193734 | cpp |
p03049 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
//#include "h.h"
using namespace std;
#define ll long long
#define pint pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define mp make_pair
#define pm(first, second) pb(mp(first, second))
#define SPACE " "
#define fpf first.first
#define fps first.second
#define spf second.first
#define sps second.second
#define all(X) (X).begin(), (X).end()
int N;
vector<string> A;
int main() {
cin >> N;
A = vector<string>(N);
int res = 0;
int cntBA = 0;
int cntXA = 0;
int cntBX = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
int len = A[i].length();
for (int j = 0; j < len; j++)
if (A[i][j] == 'A' && A[i][j + 1] == 'B') {
res++;
}
if (A[i][len - 1] == 'A') {
cntXA++;
}
if (A[i][0] == 'B') {
cntBX++;
}
if (A[i][0] == 'B' && A[i][len - 1] == 'A') {
cntBA++;
cntBX--;
cntXA--;
}
}
int ans = min(cntBA + cntBX, cntBA + cntXA);
if (cntXA + cntBX == 0) {
ans = cntBA - 1;
}
cout << ans + res << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
//#include "h.h"
using namespace std;
#define ll long long
#define pint pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define mp make_pair
#define pm(first, second) pb(mp(first, second))
#define SPACE " "
#define fpf first.first
#define fps first.second
#define spf second.first
#define sps second.second
#define all(X) (X).begin(), (X).end()
int N;
vector<string> A;
int main() {
cin >> N;
A = vector<string>(N);
int res = 0;
int cntBA = 0;
int cntXA = 0;
int cntBX = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
int len = A[i].length();
for (int j = 0; j < len; j++)
if (A[i][j] == 'A' && A[i][j + 1] == 'B') {
res++;
}
if (A[i][len - 1] == 'A') {
cntXA++;
}
if (A[i][0] == 'B') {
cntBX++;
}
if (A[i][0] == 'B' && A[i][len - 1] == 'A') {
cntBA++;
cntBX--;
cntXA--;
}
}
int ans = min(cntBA + cntBX, cntBA + cntXA);
if (cntXA + cntBX == 0 && cntBA > 0) {
ans = cntBA - 1;
}
cout << ans + res << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 866,820 | 866,821 | u169678167 | cpp |
p03049 | #include <array>
#include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define RFOR(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n); i > 0; --i)
#define CI cin >>
#define CO cout <<
#define EN << endl
#define all(x) (x).begin(), (x).end()
using namespace std;
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
using ll = long long;
using VI = vector<int>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int main() {
int n;
CI n;
vector<string> a;
vector<string> b;
vector<string> ab;
int ans = 0;
REP(i, n) {
string s;
CI s;
if (s[0] == 'B' and s[s.length() - 1] == 'A') {
ab.push_back(s);
}
if (s[0] == 'B')
a.push_back(s);
if (s[s.length() - 1] == 'A')
b.push_back(s);
REP(i, s.length()) {
if (s.substr(i, 2) == "AB")
ans++;
}
}
if (ab.size() != 0) {
if (a.size() + b.size() == 0) {
ans += ab.size() - 1;
} else {
ans += ab.size() + min(a.size(), b.size());
}
} else {
ans += min(a.size(), b.size());
}
CO ans EN;
} | #include <array>
#include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define RFOR(i, a, b) for (int i = (a); i >= (b); --i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n); i > 0; --i)
#define CI cin >>
#define CO cout <<
#define EN << endl
#define all(x) (x).begin(), (x).end()
using namespace std;
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
using ll = long long;
using VI = vector<int>;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int main() {
int n;
CI n;
vector<string> a;
vector<string> b;
vector<string> ab;
int ans = 0;
REP(i, n) {
string s;
CI s;
if (s[0] == 'B' and s[s.length() - 1] == 'A') {
ab.push_back(s);
} else if (s[0] == 'B')
a.push_back(s);
else if (s[s.length() - 1] == 'A')
b.push_back(s);
REP(i, s.length()) {
if (s.substr(i, 2) == "AB")
ans++;
}
}
if (ab.size() != 0) {
if (a.size() + b.size() == 0) {
ans += ab.size() - 1;
} else {
ans += ab.size() + min(a.size(), b.size());
}
} else {
ans += min(a.size(), b.size());
}
CO ans EN;
} | [
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 866,822 | 866,823 | u165567408 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
int a = 0; // ooooA
int b = 0; // Boooo
int c = 0; // BoooA
int ans = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int ss = s.size() - 1;
if (s[0] == 'B' and s[ss] == 'A')
c++;
else if (s[0] == 'B')
b++;
else if (s[ss] == 'A')
a++;
for (int j = 0; j < n - 1; j++) {
if (s[j] == 'A' and s[j + 1] == 'B') {
ans++;
}
}
}
if (c == 0)
ans += min(a, b);
else if (a == 0 and b == 0 and c > 0)
ans += c - 1;
else
ans += c + min(a, b);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
int a = 0; // ooooA
int b = 0; // Boooo
int c = 0; // BoooA
int ans = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int ss = s.size() - 1;
if (s[0] == 'B' and s[ss] == 'A')
c++;
else if (s[0] == 'B')
b++;
else if (s[ss] == 'A')
a++;
for (int j = 0; j < s.size(); j++) {
if (s[j] == 'A' and s[j + 1] == 'B') {
ans++;
}
}
}
if (c == 0)
ans += min(a, b);
else if (a == 0 and b == 0 and c > 0)
ans += c - 1;
else
ans += c + min(a, b);
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"call.add"
] | 866,826 | 866,827 | u136869985 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
bool flag = true;
int a_cnt = 0;
int b_cnt = 0;
int ab_cnt = 0;
for (int i = 0; i < n; i++) {
std::string s;
cin >> s;
int l = s.length();
if (s[0] == 'B')
b_cnt++;
if (s[l - 1] == 'A')
a_cnt++;
if ((s[0] == 'B') && (s[l - 1] != 'A')) {
flag = false;
} else if ((s[0] != 'B') && (s[l - 1] == 'A')) {
flag = false;
}
for (int i = 0; i < l - 1; i++) {
if ((s[i] == 'A') && (s[i + 1] == 'B')) {
ab_cnt++;
}
}
}
// cout << "b_cnt: " << b_cnt << endl;
// cout << "a_cnt: " << a_cnt << endl;
// cout << "ab_cnt: " << ab_cnt << endl;
// cout << "flag: " << flag << endl;
int cnt;
cnt = ab_cnt + min(a_cnt, b_cnt);
if ((a_cnt == b_cnt) && (flag == true) && (cnt != 0) && (n >= 2))
cnt--;
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
bool flag = true;
int a_cnt = 0;
int b_cnt = 0;
int ab_cnt = 0;
for (int i = 0; i < n; i++) {
std::string s;
cin >> s;
int l = s.length();
if (s[0] == 'B')
b_cnt++;
if (s[l - 1] == 'A')
a_cnt++;
if ((s[0] == 'B') && (s[l - 1] != 'A')) {
flag = false;
} else if ((s[0] != 'B') && (s[l - 1] == 'A')) {
flag = false;
}
for (int i = 0; i < l - 1; i++) {
if ((s[i] == 'A') && (s[i + 1] == 'B')) {
ab_cnt++;
}
}
}
// cout << "b_cnt: " << b_cnt << endl;
// cout << "a_cnt: " << a_cnt << endl;
// cout << "ab_cnt: " << ab_cnt << endl;
// cout << "flag: " << flag << endl;
int cnt;
cnt = ab_cnt + min(a_cnt, b_cnt);
if ((a_cnt == b_cnt) && (flag == true) && (cnt != 0) && (a_cnt != 0))
cnt--;
cout << cnt << endl;
} | [] | 866,828 | 866,829 | u902266190 | cpp |
p03049 | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
string data;
int counter = 0;
int counter_1 = 0;
int counter_2 = 0;
int counter_3 = 0;
for (int i = 0; i < N; i++) {
cin >> data;
for (int j = 0; j < data.size(); j++) {
if (data.substr(j, 2) == "AB")
counter++;
}
if (data.substr(data.size() - 1, 1) == "A")
counter_3++;
if (data.substr(0, 1) == "B")
counter_2++;
if (data.substr(data.size() - 1, 1) == "A" && data.substr(0, 1) == "B")
counter_1++;
}
counter_3 -= counter_1;
counter_2 -= counter_1;
if (counter_1 == 0) {
counter = min(counter_2, counter_3);
} else {
if (counter_2 + counter_3 > 0) {
counter = counter_1 + min(counter_2, counter_3);
} else {
counter = counter_1 - 1;
}
}
cout << counter << endl;
}
| #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
string data;
int counter = 0;
int counter_1 = 0;
int counter_2 = 0;
int counter_3 = 0;
for (int i = 0; i < N; i++) {
cin >> data;
for (int j = 0; j < data.size(); j++) {
if (data.substr(j, 2) == "AB")
counter++;
}
if (data.substr(data.size() - 1, 1) == "A")
counter_3++;
if (data.substr(0, 1) == "B")
counter_2++;
if (data.substr(data.size() - 1, 1) == "A" && data.substr(0, 1) == "B")
counter_1++;
}
counter_3 -= counter_1;
counter_2 -= counter_1;
if (counter_1 == 0) {
counter += min(counter_2, counter_3);
} else {
if (counter_2 + counter_3 > 0) {
counter += counter_1 + min(counter_2, counter_3);
} else {
counter += counter_1 - 1;
}
}
cout << counter << endl;
}
| [
"assignment.value.change"
] | 866,833 | 866,834 | u774910314 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
int a = 0, b = 0, cnt = 0;
bool head = false;
for (auto i = 0; i < n; ++i) {
string s;
cin >> s;
for (auto j = 0; j < (int)s.size() - 1; ++j) {
if (s[j] == 'A' && s[j + 1] == 'B')
++cnt;
}
if (s[0] == 'B')
++b;
if (s[s.size() - 1] == 'A')
++a;
if (s[0] != 'B' && s[s.size() - 1] == 'A')
head = true;
}
cout << max(0, cnt + min(a, b - !head)) << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
int a = 0, b = 0, cnt = 0;
bool head = false;
for (auto i = 0; i < n; ++i) {
string s;
cin >> s;
for (auto j = 0; j < (int)s.size() - 1; ++j) {
if (s[j] == 'A' && s[j + 1] == 'B')
++cnt;
}
if (s[0] == 'B')
++b;
if (s[s.size() - 1] == 'A')
++a;
if (s[0] != 'B' && s[s.size() - 1] == 'A')
head = true;
}
cout << cnt + max(0, min(a, b - !head)) << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 866,838 | 866,839 | u338550320 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
int a = 0, b = 0, cnt = 0;
bool head = false;
for (auto i = 0; i < n; ++i) {
string s;
cin >> s;
for (auto j = 0; j < (int)s.size() - 1; ++j) {
if (s[j] == 'A' && s[j + 1] == 'B')
++cnt;
}
if (s[0] == 'B')
++b;
if (s[s.size() - 1] == 'A')
++a;
if (s[0] != 'B' && s[s.size() - 1] == 'A')
head = true;
}
cout << cnt + min(a, b - !head) << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
int a = 0, b = 0, cnt = 0;
bool head = false;
for (auto i = 0; i < n; ++i) {
string s;
cin >> s;
for (auto j = 0; j < (int)s.size() - 1; ++j) {
if (s[j] == 'A' && s[j + 1] == 'B')
++cnt;
}
if (s[0] == 'B')
++b;
if (s[s.size() - 1] == 'A')
++a;
if (s[0] != 'B' && s[s.size() - 1] == 'A')
head = true;
}
cout << cnt + max(0, min(a, b - !head)) << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 866,840 | 866,839 | u338550320 | cpp |
p03049 | #include "bits/stdc++.h"
using namespace std;
int main() {
int N, Acount, Bcount, ABcount, ans;
;
cin >> N;
Acount = 0;
Bcount = 0;
ABcount = 0;
ans = 0;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
if (s[0] == 'B' && s[s.size() - 1] == 'A') {
ABcount += 1;
}
if (s[0] != 'B' && s[s.size() - 1] == 'A') {
Acount += 1;
}
if (s[0] == 'B' && s[s.size() - 1] != 'A') {
Bcount += 1;
}
for (int j = 0; j < s.size() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans += 1;
}
}
}
if (ABcount == 0 && Acount + Bcount != 0) {
ans += min(Acount, Bcount);
} else if (ABcount == 0 && Acount + Bcount == 0) {
ans += ABcount - 1;
} else if (ABcount != 0 && Acount + Bcount != 0) {
ans += ABcount + min(Acount, Bcount);
}
cout << ans << endl;
} | #include "bits/stdc++.h"
using namespace std;
int main() {
int N, Acount, Bcount, ABcount, ans;
;
cin >> N;
Acount = 0;
Bcount = 0;
ABcount = 0;
ans = 0;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
if (s[0] == 'B' && s[s.size() - 1] == 'A') {
ABcount += 1;
}
if (s[0] != 'B' && s[s.size() - 1] == 'A') {
Acount += 1;
}
if (s[0] == 'B' && s[s.size() - 1] != 'A') {
Bcount += 1;
}
for (int j = 0; j < s.size() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
ans += 1;
}
}
}
if (ABcount == 0 && Acount + Bcount != 0) {
ans += min(Acount, Bcount);
} else if (ABcount != 0 && Acount + Bcount == 0) {
ans += ABcount - 1;
} else if (ABcount != 0 && Acount + Bcount != 0) {
ans += ABcount + min(Acount, Bcount);
}
cout << ans << endl;
} | [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 866,841 | 866,842 | u373796790 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> s;
for (int i = 0; i < N; i++) {
string si;
cin >> si;
s.push_back(si);
}
int ans = 0;
for (int j = 0; j < N; j++) {
for (int i = 1; i < s[j].size(); i++) {
if (s[j][i - 1] == 'A' && s[j][i] == 'B')
ans++;
}
}
int a = 0, b = 0, c = 0;
for (int j = 0; j < N; j++) {
if (s[j].front() == 'B' && s[j].back() == 'A')
c++;
else if (s[j].back() == 'A')
a++;
else if (s[j].front() == 'B')
b++;
}
if (a == b && a == 0)
ans += c - 1;
else
ans += min(a, b) + c;
cout << ans;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> s;
for (int i = 0; i < N; i++) {
string si;
cin >> si;
s.push_back(si);
}
int ans = 0;
for (int j = 0; j < N; j++) {
for (int i = 1; i < s[j].size(); i++) {
if (s[j][i - 1] == 'A' && s[j][i] == 'B')
ans++;
}
}
int a = 0, b = 0, c = 0;
for (int j = 0; j < N; j++) {
if (s[j].front() == 'B' && s[j].back() == 'A')
c++;
else if (s[j].back() == 'A')
a++;
else if (s[j].front() == 'B')
b++;
}
if (a == b && a == 0 && c > 0)
ans += c - 1;
else
ans += min(a, b) + c;
cout << ans;
} | [
"control_flow.branch.if.condition.change"
] | 866,845 | 866,846 | u923676814 | cpp |
p03049 | #include <bits/stdc++.h>
const int MAX_N = 10000;
int main() {
int N;
std::string s[MAX_N];
std::cin >> N;
for (int i = 0; i < N; ++i) {
std::cin >> s[i];
}
int cnt[4] = {}, ans = 0;
for (int i = 0; i < N; ++i) {
std::string S = s[i];
int n = S.length();
for (int j = 1; j < N; ++j) {
if (S[j - 1] == 'A' and S[j] == 'B')
++ans;
}
if (S[0] == 'B' and S[n - 1] == 'A')
++cnt[0];
else if (S[0] == 'B' and S[n - 1] != 'A')
++cnt[1];
else if (S[0] != 'B' and S[n - 1] == 'A')
++cnt[2];
else
++cnt[3];
}
if (cnt[0] > 0 and cnt[1] == 0 and cnt[2] == 0)
ans += cnt[0] - 1;
else
ans += cnt[0] + std::min(cnt[1], cnt[2]);
std::cout << ans << std::endl;
}
| #include <bits/stdc++.h>
const int MAX_N = 10000;
int main() {
int N;
std::string s[MAX_N];
std::cin >> N;
for (int i = 0; i < N; ++i) {
std::cin >> s[i];
}
int cnt[4] = {}, ans = 0;
for (int i = 0; i < N; ++i) {
std::string S = s[i];
int n = S.length();
for (int j = 1; j < n; ++j) {
if (S[j - 1] == 'A' and S[j] == 'B')
++ans;
}
if (S[0] == 'B' and S[n - 1] == 'A')
++cnt[0];
else if (S[0] == 'B' and S[n - 1] != 'A')
++cnt[1];
else if (S[0] != 'B' and S[n - 1] == 'A')
++cnt[2];
else
++cnt[3];
}
if (cnt[0] > 0 and cnt[1] == 0 and cnt[2] == 0)
ans += cnt[0] - 1;
else
ans += cnt[0] + std::min(cnt[1], cnt[2]);
std::cout << ans << std::endl;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 866,847 | 866,848 | u600759947 | cpp |
p03049 | #include <bits/stdc++.h>
#define maxn 10000
using namespace std;
int n, cnt = 0;
string s[maxn];
vector<string> v;
int a = 0, b = 0, c = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j <= s[i].size() - 2; j++)
if (s[i].substr(j, 2) == "AB")
++cnt;
string t = "";
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
c++;
else if (s[i][0] == 'B')
a++;
else if (s[i][s[i].size() - 1] == 'A')
b++;
}
cnt += min(a, b);
if (a == c && b == c && b > 0)
--cnt;
cout << cnt << endl;
return 0;
} | #include <bits/stdc++.h>
#define maxn 10000
using namespace std;
int n, cnt = 0;
string s[maxn];
vector<string> v;
int a = 0, b = 0, c = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j <= s[i].size() - 2; j++)
if (s[i].substr(j, 2) == "AB")
++cnt;
string t = "";
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
c++;
if (s[i][0] == 'B')
a++;
if (s[i][s[i].size() - 1] == 'A')
b++;
}
cnt += min(a, b);
if (a == c && b == c && b > 0)
--cnt;
cout << cnt << endl;
return 0;
} | [
"control_flow.branch.if.replace.add",
"control_flow.branch.else_if.replace.remove"
] | 866,849 | 866,850 | u954081460 | cpp |
p03049 | #include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
inline void rd(int &x) {
x = 0;
register char k = getchar();
int s = 1;
while (k > '9' | k < '0') {
if (k == '-')
s = -1;
k = getchar();
}
while (k >= '0' && k <= '9')
x = x * 10 + k - 48, k = getchar();
x *= s;
}
int a1, b1, a2, b2, bb, aa;
char k[100];
int main() {
int r, g, n, ans = 0;
rd(n);
for (int i = 1; i <= n; i++) {
scanf("%s", k);
int len = strlen(k), opa = 0, opb = 0;
for (int j = 0; j < len; j++) {
if (k[j] == 'A' && k[j + 1] == 'B')
ans++;
}
int fir = k[0], la = k[len - 1];
if (fir != 'B' && la != 'A')
continue;
if (fir == 'B' && la == 'A') {
aa++;
continue;
}
if (k[0] == 'B') {
b1++;
} else
a1++;
}
ans += aa + min(b1, a1);
if (b1 == a1 && a1 == 0)
ans--;
cout << ans;
} | #include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
inline void rd(int &x) {
x = 0;
register char k = getchar();
int s = 1;
while (k > '9' | k < '0') {
if (k == '-')
s = -1;
k = getchar();
}
while (k >= '0' && k <= '9')
x = x * 10 + k - 48, k = getchar();
x *= s;
}
int a1, b1, a2, b2, bb, aa;
char k[100];
int main() {
int r, g, n, ans = 0;
rd(n);
for (int i = 1; i <= n; i++) {
scanf("%s", k);
int len = strlen(k), opa = 0, opb = 0;
for (int j = 0; j < len; j++) {
if (k[j] == 'A' && k[j + 1] == 'B')
ans++;
}
int fir = k[0], la = k[len - 1];
if (fir != 'B' && la != 'A')
continue;
if (fir == 'B' && la == 'A') {
aa++;
continue;
}
if (k[0] == 'B') {
b1++;
} else
a1++;
}
ans += aa + min(b1, a1);
if (b1 == a1 && a1 == 0 && aa)
ans--;
cout << ans;
} | [
"control_flow.branch.if.condition.change"
] | 866,853 | 866,854 | u111509820 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int n;
string s[10000];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> s[i];
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < s[i].size(); j++)
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
int a = 0, b = 0;
int d = 0;
for (int i = 0; i < n; i++) {
if (s[i][0] == 'B')
b++;
if (s[i][s[i].size() - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
d++;
}
if (d == n || (d == a && d == b))
ans--;
ans += min(a, b);
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n;
string s[10000];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> s[i];
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < s[i].size(); j++)
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
int a = 0, b = 0;
int d = 0;
for (int i = 0; i < n; i++) {
if (s[i][0] == 'B')
b++;
if (s[i][s[i].size() - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
d++;
}
if (d == n || (d == a && d == b && d != 0))
ans--;
ans += min(a, b);
cout << ans;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 866,855 | 866,856 | u201808715 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
string S[10010];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> S[i];
}
//まず内部のBAを数える
int inside_BA = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < (S[i].size() - 1); j++) {
if (S[i].at(j) == 'A' && S[i].at(j + 1) == 'B')
inside_BA++;
}
}
int B_A = 0;
int B_hoge = 0;
int hoge_A = 0;
for (int i = 0; i < N; i++) {
if (S[i].at(0) == 'B' && S[i].at(S[i].size() - 1) == 'A') {
B_A++;
continue;
}
if (S[i].at(0) == 'B') {
B_hoge++;
}
if (S[i].at(S[i].size() - 1) == 'A') {
hoge_A++;
}
}
if (B_hoge > 0 || hoge_A > 0) {
cout << inside_BA + B_A + min(B_hoge, hoge_A) << endl;
} else {
cout << inside_BA + B_A - 1 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
string S[10010];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> S[i];
}
//まず内部のBAを数える
int inside_BA = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < (S[i].size() - 1); j++) {
if (S[i].at(j) == 'A' && S[i].at(j + 1) == 'B')
inside_BA++;
}
}
int B_A = 0;
int B_hoge = 0;
int hoge_A = 0;
for (int i = 0; i < N; i++) {
if (S[i].at(0) == 'B' && S[i].at(S[i].size() - 1) == 'A') {
B_A++;
continue;
}
if (S[i].at(0) == 'B') {
B_hoge++;
}
if (S[i].at(S[i].size() - 1) == 'A') {
hoge_A++;
}
}
if (B_hoge > 0 || hoge_A > 0) {
cout << inside_BA + B_A + min(B_hoge, hoge_A) << endl;
} else {
cout << inside_BA + max(B_A, 1) - 1 << endl;
}
} | [
"call.add",
"call.arguments.add"
] | 866,859 | 866,860 | u824310141 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
int cnt = 0;
int fBlist = 0;
int bAlist = 0;
int vlist = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A') {
if (s[i][j + 1] == 'B') {
cnt++;
}
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
vlist++;
if (s[i][0] == 'B')
fBlist++;
if (s[i][s[i].size() - 1] == 'A')
bAlist++;
}
if (vlist == fBlist && fBlist == bAlist && cnt != 0) {
cnt--;
}
cnt += fBlist < bAlist ? fBlist : bAlist;
cout << cnt;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
int cnt = 0;
int fBlist = 0;
int bAlist = 0;
int vlist = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A') {
if (s[i][j + 1] == 'B') {
cnt++;
}
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
vlist++;
if (s[i][0] == 'B')
fBlist++;
if (s[i][s[i].size() - 1] == 'A')
bAlist++;
}
if (vlist == fBlist && fBlist == bAlist && vlist != 0) {
cnt--;
}
cnt += fBlist < bAlist ? fBlist : bAlist;
cout << cnt;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 866,865 | 866,866 | u228807040 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
int cnt = 0;
int fBlist = 0;
int bAlist = 0;
int vlist = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A') {
if (s[i][j + 1] == 'B') {
cnt++;
}
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
vlist++;
if (s[i][0] == 'B')
fBlist++;
if (s[i][s[i].size() - 1] == 'A')
bAlist++;
}
if (vlist == fBlist && fBlist == bAlist) {
cnt--;
}
cnt += fBlist < bAlist ? fBlist : bAlist;
cout << cnt;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
int cnt = 0;
int fBlist = 0;
int bAlist = 0;
int vlist = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A') {
if (s[i][j + 1] == 'B') {
cnt++;
}
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
vlist++;
if (s[i][0] == 'B')
fBlist++;
if (s[i][s[i].size() - 1] == 'A')
bAlist++;
}
if (vlist == fBlist && fBlist == bAlist && vlist != 0) {
cnt--;
}
cnt += fBlist < bAlist ? fBlist : bAlist;
cout << cnt;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 866,867 | 866,866 | u228807040 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
int cnt = 0;
int fBlist = 0;
int bAlist = 0;
int vlist = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A') {
if (s[i][j + 1] == 'B') {
cnt++;
}
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
vlist++;
else if (s[i][0] == 'B')
fBlist++;
else if (s[i][s[i].size() - 1] == 'A')
bAlist++;
}
if (vlist != 0) {
cnt += vlist;
}
cnt += fBlist < bAlist ? fBlist : bAlist;
if (fBlist + bAlist == 0 && vlist == 0) {
cnt--;
}
cout << cnt;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
int cnt = 0;
int fBlist = 0;
int bAlist = 0;
int vlist = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A') {
if (s[i][j + 1] == 'B') {
cnt++;
}
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
vlist++;
else if (s[i][0] == 'B')
fBlist++;
else if (s[i][s[i].size() - 1] == 'A')
bAlist++;
}
if (vlist != 0) {
cnt += vlist;
}
cnt += fBlist < bAlist ? fBlist : bAlist;
if (fBlist + bAlist == 0 && vlist != 0) {
cnt--;
}
cout << cnt;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 866,868 | 866,869 | u228807040 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
int cnt = 0;
int fBlist = 0;
int bAlist = 0;
int vlist = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A') {
if (s[i][j + 1] == 'B') {
cnt++;
}
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
vlist++;
else if (s[i][0] == 'B')
fBlist++;
else if (s[i][s[i].size() - 1] == 'A')
bAlist++;
}
if (vlist != 0) {
cnt += vlist;
}
cnt += fBlist < bAlist ? fBlist : bAlist;
if (fBlist + bAlist == 0) {
cnt--;
}
cout << cnt;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
int cnt = 0;
int fBlist = 0;
int bAlist = 0;
int vlist = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A') {
if (s[i][j + 1] == 'B') {
cnt++;
}
}
}
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
vlist++;
else if (s[i][0] == 'B')
fBlist++;
else if (s[i][s[i].size() - 1] == 'A')
bAlist++;
}
if (vlist != 0) {
cnt += vlist;
}
cnt += fBlist < bAlist ? fBlist : bAlist;
if (fBlist + bAlist == 0 && vlist != 0) {
cnt--;
}
cout << cnt;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 866,870 | 866,869 | u228807040 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define int64 long long
#define modbig (10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 + 7)
using namespace std;
int main() {
int n;
cin >> n;
string s[n];
rep(i, n) { cin >> s[i]; }
int ab = 0, enda = 0, startb = 0, both = 0;
rep(i, n) {
rep(j, s[i].length() - 1) {
if (s[i].substr(j, 2) == "AB") {
ab++;
}
}
if (s[i][0] == 'B') {
startb++;
}
if (s[i][s[i].length() - 1] == 'A') {
enda++;
}
if (s[i][0] == 'B' && s[i][s[i].length() - 1] == 'A') {
startb--;
enda--;
both++;
}
if (startb == 0 && enda == 0 && both != 0) {
cout << ab + both - 1;
} else {
cout << ab + min(enda, startb) + both;
}
}
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
#define int64 long long
#define modbig (10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 * 10 + 7)
using namespace std;
int main() {
int n;
cin >> n;
string s[n];
rep(i, n) { cin >> s[i]; }
int ab = 0, enda = 0, startb = 0, both = 0;
rep(i, n) {
rep(j, s[i].length() - 1) {
if (s[i].substr(j, 2) == "AB") {
ab++;
}
}
if (s[i][0] == 'B') {
startb++;
}
if (s[i][s[i].length() - 1] == 'A') {
enda++;
}
if (s[i][0] == 'B' && s[i][s[i].length() - 1] == 'A') {
startb--;
enda--;
both++;
}
}
if (startb == 0 && enda == 0 && both != 0) {
cout << ab + both - 1;
} else {
cout << ab + min(enda, startb) + both;
}
}
| [] | 866,877 | 866,878 | u170301438 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, i, j, m, c = 0, ca = 0, cb = 0, cab = 0;
cin >> n;
string s;
for (i = 0; i < n; i++) {
cin >> s;
m = s.size();
for (j = 0; j < m - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
c++;
}
}
if (s[0] == 'B' && s[m - 1] != 'A') {
cb++;
} else if (s[m - 1] == 'A' && s[0] != 'B') {
ca++;
} else if (s[0] = 'B' && s[m - 1] == 'A') {
cab++;
}
}
if (cab == 0) {
cout << c + min(ca, cb) << endl;
} else {
if (ca == 0 && cb == 0) {
cout << c + cab << endl;
} else {
cout << c + cab + 1 + min(ca - 1, cb - 1) << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, i, j, m, c = 0, ca = 0, cb = 0, cab = 0;
cin >> n;
string s;
for (i = 0; i < n; i++) {
cin >> s;
m = s.size();
for (j = 0; j < m - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B') {
c++;
}
}
if (s[0] == 'B' && s[m - 1] != 'A') {
cb++;
} else if (s[m - 1] == 'A' && s[0] != 'B') {
ca++;
} else if (s[0] = 'B' && s[m - 1] == 'A') {
cab++;
}
}
if (cab == 0) {
cout << c + min(ca, cb) << endl;
} else {
if (ca == 0 && cb == 0) {
cout << c + cab - 1 << endl;
} else {
cout << c + cab + 1 + min(ca - 1, cb - 1) << endl;
}
}
}
| [
"expression.operation.binary.add"
] | 866,879 | 866,880 | u061912210 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
// define
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (((a) % mod) * ((b) % mod)) % mod
#define rollcall cout << "I'm Sucu." << endl;
#define repi(i, m, n) for (int i = m; i < n; i++)
#define drep(i, n, m) for (int i = n; i >= m; i--)
#define rep(i, n) repi(i, 0, n)
#define rrep(i, n) repi(i, 1, n + 1)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x, y) make_pair(x, y)
#define dmt(x, y, z) make_tuple(x, y, z)
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define fi first
#define se second
// debug
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T, typename U, typename V>
ostream &operator<<(ostream &os, const tuple<T, U, V> &t) {
os << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << " ";
os << *it;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
for (auto x : mp)
os << "(" << x.first << "," << x.second << ")" << endl;
return os;
}
template <typename T, int SIZE> int array_length(const T (&)[SIZE]) {
return SIZE;
}
template <typename T, int N>
void PRINTF(const T (&a)[N], int s = N, int t = -1, bool f = true) {
if (t == -1) {
rep(i, s) {
if (i)
cout << " ";
cout << a[i];
}
} else
repi(i, s, t) {
if (i != s)
cout << " ";
cout << a[i];
}
if (f)
cout << "\n";
}
template <typename T, int N1, int N2>
void PRINTF(const T (&a)[N1][N2], int h = N1, int w = N2) {
rep(i, h) {
rep(j, w) { cout << a[i][j] << " \n"[j == w - 1]; }
}
}
string substr(const string &str, int S1, int S2 = -1) {
if (S2 == -1)
return str.substr(S1);
return str.substr(S1, S2 - S1);
}
// typedef
typedef complex<double> Point;
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<P, int> Pi;
typedef tuple<int, int, int> TT;
typedef pair<int, TT> PT;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;
// int sum = accumulate(a, a+n, 0LL);
// int mx = max_element(a, a+n);
// int mn = min_element(a, a+n);
// int cnt = count(a, a+n, k);
string str[100000];
signed main() {
int n;
cin >> n;
rep(i, n) cin >> str[i];
int a = 0, b = 0, ab = 0;
rep(i, n) a += (str[i][str[i].size() - 1] == 'A');
rep(i, n) b += (str[i][0] == 'B');
rep(i, n) ab += (str[i][0] == 'B' and str[i][str[i].size() - 1] == 'A');
int ans = 0;
rep(i, n) {
rep(j, str[i].size() - 1) {
if (str[i][j] == 'A' and str[i][j + 1] == 'B')
ans++;
}
}
if (a == b and a == ab)
cout << ans + max(0LL, a) << endl;
else
cout << ans + min(a, b) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// define
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (((a) % mod) * ((b) % mod)) % mod
#define rollcall cout << "I'm Sucu." << endl;
#define repi(i, m, n) for (int i = m; i < n; i++)
#define drep(i, n, m) for (int i = n; i >= m; i--)
#define rep(i, n) repi(i, 0, n)
#define rrep(i, n) repi(i, 1, n + 1)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x, y) make_pair(x, y)
#define dmt(x, y, z) make_tuple(x, y, z)
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define fi first
#define se second
// debug
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T, typename U, typename V>
ostream &operator<<(ostream &os, const tuple<T, U, V> &t) {
os << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << " ";
os << *it;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
for (auto x : mp)
os << "(" << x.first << "," << x.second << ")" << endl;
return os;
}
template <typename T, int SIZE> int array_length(const T (&)[SIZE]) {
return SIZE;
}
template <typename T, int N>
void PRINTF(const T (&a)[N], int s = N, int t = -1, bool f = true) {
if (t == -1) {
rep(i, s) {
if (i)
cout << " ";
cout << a[i];
}
} else
repi(i, s, t) {
if (i != s)
cout << " ";
cout << a[i];
}
if (f)
cout << "\n";
}
template <typename T, int N1, int N2>
void PRINTF(const T (&a)[N1][N2], int h = N1, int w = N2) {
rep(i, h) {
rep(j, w) { cout << a[i][j] << " \n"[j == w - 1]; }
}
}
string substr(const string &str, int S1, int S2 = -1) {
if (S2 == -1)
return str.substr(S1);
return str.substr(S1, S2 - S1);
}
// typedef
typedef complex<double> Point;
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<P, int> Pi;
typedef tuple<int, int, int> TT;
typedef pair<int, TT> PT;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;
// int sum = accumulate(a, a+n, 0LL);
// int mx = max_element(a, a+n);
// int mn = min_element(a, a+n);
// int cnt = count(a, a+n, k);
string str[100000];
signed main() {
int n;
cin >> n;
rep(i, n) cin >> str[i];
int a = 0, b = 0, ab = 0;
rep(i, n) a += (str[i][str[i].size() - 1] == 'A');
rep(i, n) b += (str[i][0] == 'B');
rep(i, n) ab += (str[i][0] == 'B' and str[i][str[i].size() - 1] == 'A');
int ans = 0;
rep(i, n) {
rep(j, str[i].size() - 1) {
if (str[i][j] == 'A' and str[i][j + 1] == 'B')
ans++;
}
}
if (a == b and a == ab)
cout << ans + max(0LL, a - 1) << endl;
else
cout << ans + min(a, b) << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 866,881 | 866,882 | u691493208 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
// define
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (((a) % mod) * ((b) % mod)) % mod
#define rollcall cout << "I'm Sucu." << endl;
#define repi(i, m, n) for (int i = m; i < n; i++)
#define drep(i, n, m) for (int i = n; i >= m; i--)
#define rep(i, n) repi(i, 0, n)
#define rrep(i, n) repi(i, 1, n + 1)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x, y) make_pair(x, y)
#define dmt(x, y, z) make_tuple(x, y, z)
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define fi first
#define se second
// debug
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T, typename U, typename V>
ostream &operator<<(ostream &os, const tuple<T, U, V> &t) {
os << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << " ";
os << *it;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
for (auto x : mp)
os << "(" << x.first << "," << x.second << ")" << endl;
return os;
}
template <typename T, int SIZE> int array_length(const T (&)[SIZE]) {
return SIZE;
}
template <typename T, int N>
void PRINTF(const T (&a)[N], int s = N, int t = -1, bool f = true) {
if (t == -1) {
rep(i, s) {
if (i)
cout << " ";
cout << a[i];
}
} else
repi(i, s, t) {
if (i != s)
cout << " ";
cout << a[i];
}
if (f)
cout << "\n";
}
template <typename T, int N1, int N2>
void PRINTF(const T (&a)[N1][N2], int h = N1, int w = N2) {
rep(i, h) {
rep(j, w) { cout << a[i][j] << " \n"[j == w - 1]; }
}
}
string substr(const string &str, int S1, int S2 = -1) {
if (S2 == -1)
return str.substr(S1);
return str.substr(S1, S2 - S1);
}
// typedef
typedef complex<double> Point;
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<P, int> Pi;
typedef tuple<int, int, int> TT;
typedef pair<int, TT> PT;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;
// int sum = accumulate(a, a+n, 0LL);
// int mx = max_element(a, a+n);
// int mn = min_element(a, a+n);
// int cnt = count(a, a+n, k);
string str[100000];
signed main() {
int n;
cin >> n;
rep(i, n) cin >> str[i];
int a = 0, b = 0, ab = 0;
rep(i, n) a += (str[i][str[i].size() - 1] == 'A');
rep(i, n) b += (str[i][0] == 'B');
rep(i, n) ab += (str[i][0] == 'B' and str[i][str[i].size() - 1] == 'A');
int ans = 0;
rep(i, n) {
rep(j, str[i].size() - 1) {
if (str[i][j] == 'A' and str[i][j + 1] == 'B')
ans++;
}
}
if (a == b and a == ab)
cout << ans + min(a, b) - 1 << endl;
else
cout << ans + min(a, b) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// define
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (((a) % mod) * ((b) % mod)) % mod
#define rollcall cout << "I'm Sucu." << endl;
#define repi(i, m, n) for (int i = m; i < n; i++)
#define drep(i, n, m) for (int i = n; i >= m; i--)
#define rep(i, n) repi(i, 0, n)
#define rrep(i, n) repi(i, 1, n + 1)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x, y) make_pair(x, y)
#define dmt(x, y, z) make_tuple(x, y, z)
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define fi first
#define se second
// debug
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T, typename U, typename V>
ostream &operator<<(ostream &os, const tuple<T, U, V> &t) {
os << "(" << get<0>(t) << "," << get<1>(t) << "," << get<2>(t) << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin())
os << " ";
os << *it;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
for (auto x : mp)
os << "(" << x.first << "," << x.second << ")" << endl;
return os;
}
template <typename T, int SIZE> int array_length(const T (&)[SIZE]) {
return SIZE;
}
template <typename T, int N>
void PRINTF(const T (&a)[N], int s = N, int t = -1, bool f = true) {
if (t == -1) {
rep(i, s) {
if (i)
cout << " ";
cout << a[i];
}
} else
repi(i, s, t) {
if (i != s)
cout << " ";
cout << a[i];
}
if (f)
cout << "\n";
}
template <typename T, int N1, int N2>
void PRINTF(const T (&a)[N1][N2], int h = N1, int w = N2) {
rep(i, h) {
rep(j, w) { cout << a[i][j] << " \n"[j == w - 1]; }
}
}
string substr(const string &str, int S1, int S2 = -1) {
if (S2 == -1)
return str.substr(S1);
return str.substr(S1, S2 - S1);
}
// typedef
typedef complex<double> Point;
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<P, int> Pi;
typedef tuple<int, int, int> TT;
typedef pair<int, TT> PT;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;
// int sum = accumulate(a, a+n, 0LL);
// int mx = max_element(a, a+n);
// int mn = min_element(a, a+n);
// int cnt = count(a, a+n, k);
string str[100000];
signed main() {
int n;
cin >> n;
rep(i, n) cin >> str[i];
int a = 0, b = 0, ab = 0;
rep(i, n) a += (str[i][str[i].size() - 1] == 'A');
rep(i, n) b += (str[i][0] == 'B');
rep(i, n) ab += (str[i][0] == 'B' and str[i][str[i].size() - 1] == 'A');
int ans = 0;
rep(i, n) {
rep(j, str[i].size() - 1) {
if (str[i][j] == 'A' and str[i][j + 1] == 'B')
ans++;
}
}
if (a == b and a == ab)
cout << ans + max(0LL, a - 1) << endl;
else
cout << ans + min(a, b) << endl;
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change",
"io.output.change",
"identifier.replace.remove",
"literal.replace.add",
"literal.number.type.widen.change",
"call.arguments.change"
] | 866,883 | 866,882 | u691493208 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
/*
#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
using cint = cpp_int;
*/
// Define
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const ll dx[4] = {1, 0, -1, 0};
const ll dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
const ll mod = 998244353;
const ll inf = 1 << 30;
// const ll INF = LONG_MAX;
const ll INF = 1LL << 60;
const ull MAX = ULONG_MAX;
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define elif else if
#define endl '\n'
#define space ' '
#define def inline auto
#define func inline constexpr ll
#define run(a) __attribute__((constructor)) def _##a()
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define input(a) scanf("%lld", &(a))
#define print(a) printf("%lld\n", (a))
#define fi first
#define se second
#define ok(a, b) (0 <= (a) && (a) < (b))
template <class T> using vvector = vector<vector<T>>;
template <class T> using pvector = vector<pair<T, T>>;
template <class T>
using rpriority_queue = priority_queue<T, vector<T>, greater<T>>;
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 (a > b) {
a = b;
return 1;
}
return 0;
}
// Debug
#define debug(...) \
{ \
cerr << __LINE__ << ": " << #__VA_ARGS__ << " = "; \
for (auto &&X : {__VA_ARGS__}) \
cerr << "[" << X << "] "; \
cerr << endl; \
}
#define dump(a, h, w) \
{ \
cerr << __LINE__ << ": " << #a << " = [" << endl; \
rep(__i, h) { \
rep(__j, w) cerr << a[__i][__j] << space; \
cerr << endl; \
} \
cerr << "]" << endl; \
}
#define vdump(a, n) \
{ \
cerr << __LINE__ << ": " << #a << " = ["; \
rep(__i, n) if (__i) cerr << space << a[__i]; \
else cerr << a[__i]; \
cerr << "]" << endl; \
}
struct edge {
ll to, cost;
edge(ll a, ll b) : to(a), cost(b) {}
};
struct position {
ll x, y;
position() {}
position(ll a, ll b) : x(a), y(b) {}
position next(ll i) { return {x + dx[i], y + dy[i]}; }
ll mdist() { return abs(x) + abs(y); }
double dist() { return sqrt(x * x + y * y); }
double norm(ll d) {
if (d == inf)
return max(x, y);
if (d == 1)
return mdist();
if (d == 2)
return dist();
return 0;
}
ll num(ll width) { return abs(x) * width + abs(y); }
bool operator==(position a) { return x == a.x && y == a.y; }
bool operator!=(position a) { return x != a.x || y != a.y; }
bool operator<(position a) { return x < a.x && y < a.y; }
bool operator>(position a) { return x > a.x && y > a.y; }
bool operator<=(position a) { return x <= a.x && y <= a.y; }
bool operator>=(position a) { return x >= a.x && y >= a.y; }
position operator+(position a) { return position(x + a.x, y + a.y); }
position operator-(position a) { return position(x - a.x, y - a.y); }
position operator*(position a) { return position(x * a.x, y * a.y); }
position operator/(position a) { return position(x / a.x, y / a.y); }
position operator%(position a) { return position(x % a.x, y % a.y); }
position complex(position a) {
return position(x * a.x - y * a.y, x * a.y + y * a.x);
}
/*
// for sort:
bool operator<(position a) { return x ^ a.x ? x < a.x : y < a.y; }
bool operator>(position a) { return x ^ a.x ? x > a.x : y > a.y; }
bool operator<=(position a) { return x ^ a.x ? x < a.x : y <= a.y; }
bool operator>=(position a) { return x ^ a.x ? x > a.x : y >= a.y; }
*/
};
position Origin = position(0, 0);
using pos = position;
using vec = position;
struct Range {
ll left, right;
Range() {}
Range(ll l, ll r) : left(l), right(r) {}
ll length() { return right - left; }
bool operator==(Range A) { return left == A.left && right == A.right; }
bool operator!=(Range A) { return !(Range(left, right) == A); }
bool operator>(Range A) { return left < A.left && right > A.right; }
bool operator<(Range A) { return left > A.left && right < A.right; }
bool operator>=(Range A) { return left <= A.left && right >= A.right; }
bool operator<=(Range A) { return left >= A.left && right <= A.right; }
};
// Loop
#define inc(i, a, n) for (ll i = (a), _##i = (n); i <= _##i; ++i)
#define dec(i, a, n) for (ll i = (a), _##i = (n); i >= _##i; --i)
#define rep(i, n) for (ll i = 0, _##i = (n); i < _##i; ++i)
#define each(i, a) for (auto &&i : a)
#define loop() for (;;)
// Stream
#define fout(n) cout << fixed << setprecision(n)
#define fasten cin.tie(0), ios::sync_with_stdio(0)
// Speed
run(0) { fasten, fout(10); }
#pragma GCC optimize("O3")
#pragma GCC target("avx")
// Gen-Test
#define RAND(a) \
{ \
random_device rnd; \
mt19937_64 a(rnd()); \
}
#define warning(A) \
if (!(A)) \
return 1
#define sin(a, b) ifstream a(b);
#define sout(a, b) ofstream a(b);
// Math
//#define gcd __gcd
func gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
func lcm(ll a, ll b) { return a * b / gcd(a, b); }
func sign(ll a) { return a ? abs(a) / a : 0; }
template <class T> def in() {
T A;
cin >> A;
return A;
}
template <class T>
def out(vector<vector<T>> A, ll H, ll W, char divc = space, char endc = endl) {
rep(i, H) {
rep(j, W) {
if (j)
cout << divc << A[i][j];
else
cout << A[i][j];
}
cout << endc;
}
}
signed main() {
ll N, res = 0, A = 0, B = 0, BA = 0;
cin >> N;
string S;
rep(i, N) {
cin >> S;
if (S.front() == 'B' && S.back() == 'A')
BA++;
else if (S.front() == 'B')
B++;
else if (S.back() == 'A')
A++;
rep(i, S.size() - 1) {
if (S[i] == 'A' && S[i + 1] == 'B')
res++;
}
}
debug(A, BA, B);
if (A || B)
res += BA + min(A, B);
else
res += BA - 1;
cout << res << endl;
}
// for compilation: g++ -Ofast -march=native -o _ _.cpp -std=c++17
| #include <bits/stdc++.h>
using namespace std;
/*
#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
using cint = cpp_int;
*/
// Define
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const ll dx[4] = {1, 0, -1, 0};
const ll dy[4] = {0, 1, 0, -1};
const ll MOD = 1e9 + 7;
const ll mod = 998244353;
const ll inf = 1 << 30;
// const ll INF = LONG_MAX;
const ll INF = 1LL << 60;
const ull MAX = ULONG_MAX;
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define elif else if
#define endl '\n'
#define space ' '
#define def inline auto
#define func inline constexpr ll
#define run(a) __attribute__((constructor)) def _##a()
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define input(a) scanf("%lld", &(a))
#define print(a) printf("%lld\n", (a))
#define fi first
#define se second
#define ok(a, b) (0 <= (a) && (a) < (b))
template <class T> using vvector = vector<vector<T>>;
template <class T> using pvector = vector<pair<T, T>>;
template <class T>
using rpriority_queue = priority_queue<T, vector<T>, greater<T>>;
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 (a > b) {
a = b;
return 1;
}
return 0;
}
// Debug
#define debug(...) \
{ \
cerr << __LINE__ << ": " << #__VA_ARGS__ << " = "; \
for (auto &&X : {__VA_ARGS__}) \
cerr << "[" << X << "] "; \
cerr << endl; \
}
#define dump(a, h, w) \
{ \
cerr << __LINE__ << ": " << #a << " = [" << endl; \
rep(__i, h) { \
rep(__j, w) cerr << a[__i][__j] << space; \
cerr << endl; \
} \
cerr << "]" << endl; \
}
#define vdump(a, n) \
{ \
cerr << __LINE__ << ": " << #a << " = ["; \
rep(__i, n) if (__i) cerr << space << a[__i]; \
else cerr << a[__i]; \
cerr << "]" << endl; \
}
struct edge {
ll to, cost;
edge(ll a, ll b) : to(a), cost(b) {}
};
struct position {
ll x, y;
position() {}
position(ll a, ll b) : x(a), y(b) {}
position next(ll i) { return {x + dx[i], y + dy[i]}; }
ll mdist() { return abs(x) + abs(y); }
double dist() { return sqrt(x * x + y * y); }
double norm(ll d) {
if (d == inf)
return max(x, y);
if (d == 1)
return mdist();
if (d == 2)
return dist();
return 0;
}
ll num(ll width) { return abs(x) * width + abs(y); }
bool operator==(position a) { return x == a.x && y == a.y; }
bool operator!=(position a) { return x != a.x || y != a.y; }
bool operator<(position a) { return x < a.x && y < a.y; }
bool operator>(position a) { return x > a.x && y > a.y; }
bool operator<=(position a) { return x <= a.x && y <= a.y; }
bool operator>=(position a) { return x >= a.x && y >= a.y; }
position operator+(position a) { return position(x + a.x, y + a.y); }
position operator-(position a) { return position(x - a.x, y - a.y); }
position operator*(position a) { return position(x * a.x, y * a.y); }
position operator/(position a) { return position(x / a.x, y / a.y); }
position operator%(position a) { return position(x % a.x, y % a.y); }
position complex(position a) {
return position(x * a.x - y * a.y, x * a.y + y * a.x);
}
/*
// for sort:
bool operator<(position a) { return x ^ a.x ? x < a.x : y < a.y; }
bool operator>(position a) { return x ^ a.x ? x > a.x : y > a.y; }
bool operator<=(position a) { return x ^ a.x ? x < a.x : y <= a.y; }
bool operator>=(position a) { return x ^ a.x ? x > a.x : y >= a.y; }
*/
};
position Origin = position(0, 0);
using pos = position;
using vec = position;
struct Range {
ll left, right;
Range() {}
Range(ll l, ll r) : left(l), right(r) {}
ll length() { return right - left; }
bool operator==(Range A) { return left == A.left && right == A.right; }
bool operator!=(Range A) { return !(Range(left, right) == A); }
bool operator>(Range A) { return left < A.left && right > A.right; }
bool operator<(Range A) { return left > A.left && right < A.right; }
bool operator>=(Range A) { return left <= A.left && right >= A.right; }
bool operator<=(Range A) { return left >= A.left && right <= A.right; }
};
// Loop
#define inc(i, a, n) for (ll i = (a), _##i = (n); i <= _##i; ++i)
#define dec(i, a, n) for (ll i = (a), _##i = (n); i >= _##i; --i)
#define rep(i, n) for (ll i = 0, _##i = (n); i < _##i; ++i)
#define each(i, a) for (auto &&i : a)
#define loop() for (;;)
// Stream
#define fout(n) cout << fixed << setprecision(n)
#define fasten cin.tie(0), ios::sync_with_stdio(0)
// Speed
run(0) { fasten, fout(10); }
#pragma GCC optimize("O3")
#pragma GCC target("avx")
// Gen-Test
#define RAND(a) \
{ \
random_device rnd; \
mt19937_64 a(rnd()); \
}
#define warning(A) \
if (!(A)) \
return 1
#define sin(a, b) ifstream a(b);
#define sout(a, b) ofstream a(b);
// Math
//#define gcd __gcd
func gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
func lcm(ll a, ll b) { return a * b / gcd(a, b); }
func sign(ll a) { return a ? abs(a) / a : 0; }
template <class T> def in() {
T A;
cin >> A;
return A;
}
template <class T>
def out(vector<vector<T>> A, ll H, ll W, char divc = space, char endc = endl) {
rep(i, H) {
rep(j, W) {
if (j)
cout << divc << A[i][j];
else
cout << A[i][j];
}
cout << endc;
}
}
signed main() {
ll N, res = 0, A = 0, B = 0, BA = 0;
cin >> N;
string S;
rep(i, N) {
cin >> S;
if (S.front() == 'B' && S.back() == 'A')
BA++;
else if (S.front() == 'B')
B++;
else if (S.back() == 'A')
A++;
rep(i, S.size() - 1) {
if (S[i] == 'A' && S[i + 1] == 'B')
res++;
}
}
debug(A, BA, B);
if (A || B)
res += BA + min(A, B);
else
res += max(BA - 1, 0LL);
cout << res << endl;
}
// for compilation: g++ -Ofast -march=native -o _ _.cpp -std=c++17
| [
"call.add",
"call.arguments.add"
] | 866,884 | 866,885 | u398942100 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
string s;
cin >> n;
int b = 0;
int a = 0;
int ba = 0;
int ab = 0;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < s.size() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B')
ab++;
}
if (s[0] == 'B' && s[s.size() - 1] == 'A') {
ba++;
} else if (s[0] == 'B') {
b++;
} else if (s[s.size() - 1] == 'A') {
a++;
}
}
cerr << ab << " " << ba << " " << b << " " << a << endl;
int k = 0;
if (ba > 0) {
k = ba - 1;
if (k > 0 && b > 0) {
k++;
b--;
}
if (k > 0 && a > 0) {
k++;
a--;
}
k = k + min(a, b);
} else {
k = min(a, b);
}
cout << ab + k << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
string s;
cin >> n;
int b = 0;
int a = 0;
int ba = 0;
int ab = 0;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < s.size() - 1; j++) {
if (s[j] == 'A' && s[j + 1] == 'B')
ab++;
}
if (s[0] == 'B' && s[s.size() - 1] == 'A') {
ba++;
} else if (s[0] == 'B') {
b++;
} else if (s[s.size() - 1] == 'A') {
a++;
}
}
cerr << ab << " " << ba << " " << b << " " << a << endl;
int k = 0;
if (ba > 0) {
k = ba - 1;
if (ba > 0 && b > 0) {
k++;
b--;
}
if (ba > 0 && a > 0) {
k++;
a--;
}
k = k + min(a, b);
} else {
k = min(a, b);
}
cout << ab + k << endl;
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 866,886 | 866,887 | u145078501 | cpp |
p03049 | // by adiforluls
#pragma GCC optimize("-O2")
#include <bits/stdc++.h>
using namespace std;
#define FAST ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define ll long long
#define ld long double
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define mii map<int, int>
#define vi vector<int>
#define vll vector<long long>
#define all(a) (a).begin(), (a).end()
#define clz(a) __builtin_clz(a) // count leading zeroes
#define ctz(a) __builtin_ctz(a) // count trailing zeroes
#define popc(a) \
__builtin_popcount(a) // count set bits (for ints only diff for ll)
#define lul 1000000007
#define rep(i, a, b) for (int i = a; i < b; i++)
#define SIZE 1000005
#define F first
#define S second
#define debug(x) cerr << #x << " = " << x << endl;
#define mod 998244353
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
std::cerr << name << " = " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " = " << arg1 << " |";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
#define endl '\n'
const ld PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
void solve() {
int n;
cin >> n;
string s;
int pref = 0, suf = 0, mid = 0, ans = 0;
rep(i, 0, n) {
cin >> s;
int sz = s.size();
rep(j, 0, sz - 1) { ans += ((s[j] == 'A') && (s[j + 1] == 'B')); }
if (s[0] == 'B' && s[sz - 1] == 'A') {
mid++;
continue;
}
if (s[0] == 'B')
pref++;
if (s[sz - 1] == 'A')
suf++;
}
ans += mid - 1;
if (pref)
ans++, pref--;
if (suf)
ans++, suf--;
ans += max(0, min(pref, suf));
cout << ans;
}
int main() {
FAST;
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
int t;
t = 1;
while (t--) {
solve();
}
return 0;
} | // by adiforluls
#pragma GCC optimize("-O2")
#include <bits/stdc++.h>
using namespace std;
#define FAST ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define ll long long
#define ld long double
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define mii map<int, int>
#define vi vector<int>
#define vll vector<long long>
#define all(a) (a).begin(), (a).end()
#define clz(a) __builtin_clz(a) // count leading zeroes
#define ctz(a) __builtin_ctz(a) // count trailing zeroes
#define popc(a) \
__builtin_popcount(a) // count set bits (for ints only diff for ll)
#define lul 1000000007
#define rep(i, a, b) for (int i = a; i < b; i++)
#define SIZE 1000005
#define F first
#define S second
#define debug(x) cerr << #x << " = " << x << endl;
#define mod 998244353
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
std::cerr << name << " = " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " = " << arg1 << " |";
__f(comma + 1, args...);
}
#else
#define trace(...)
#endif
#define endl '\n'
const ld PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
void solve() {
int n;
cin >> n;
string s;
int pref = 0, suf = 0, mid = 0, ans = 0;
rep(i, 0, n) {
cin >> s;
int sz = s.size();
rep(j, 0, sz - 1) { ans += ((s[j] == 'A') && (s[j + 1] == 'B')); }
if (s[0] == 'B' && s[sz - 1] == 'A') {
mid++;
continue;
}
if (s[0] == 'B')
pref++;
if (s[sz - 1] == 'A')
suf++;
}
if (mid) {
ans += mid - 1;
if (pref)
ans++, pref--;
if (suf)
ans++, suf--;
}
ans += max(0, min(pref, suf));
cout << ans;
}
int main() {
FAST;
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
int t;
t = 1;
while (t--) {
solve();
}
return 0;
} | [
"control_flow.branch.if.add"
] | 866,892 | 866,893 | u701389155 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int x, y, z, n, p, ans;
x = y = z = p = 0;
cin >> n;
string s;
Rep(i, n) {
cin >> s;
Rep(j, s.length() - 1) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
p++;
}
}
if (s.at(0) == 'B') {
if (s.at(s.length() - 1) == 'A')
z++;
else
x++;
} else if (s.at(s.length() - 1) == 'A')
y++;
}
if (x == 0 && y == 0)
ans = z - 1 + p;
else
ans = p + z + min(x, y);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int x, y, z, n, p, ans;
x = y = z = p = 0;
cin >> n;
string s;
Rep(i, n) {
cin >> s;
Rep(j, s.length() - 1) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
p++;
}
}
if (s.at(0) == 'B') {
if (s.at(s.length() - 1) == 'A')
z++;
else
x++;
} else if (s.at(s.length() - 1) == 'A')
y++;
}
if (x == 0 && y == 0 && z > 0)
ans = z - 1 + p;
else
ans = p + z + min(x, y);
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change"
] | 866,894 | 866,895 | u532894762 | cpp |
p03049 | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define mod 1000000007
#define FOR(x, to) for (int x = 0; x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ALL(a) (a.begin()), (a.end())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define long long long
inline int rei() {
int x;
cin >> x;
return x;
}
inline long rel() {
long x;
cin >> x;
return x;
}
inline string res() {
string x;
cin >> x;
return x;
}
//-------------------------------------------------------
void Calc() {
int N = rei();
long ans = 0;
int BA = 0;
int A = 0;
int B = 0;
for (int j = 0; j < N; j++) {
string S = res();
for (int i = 0; i < S.length() - 1; i++) {
if (S[i] == 'A' && S[i + 1] == 'B') {
ans++;
}
}
if (S[0] == 'B' && S[S.length() - 1] == 'A') {
BA++;
} else if (S[0] == 'B') {
B++;
} else if (S[S.length() - 1] == 'A') {
A++;
}
}
if (A == 0 && B == 0) {
ans += BA - 1;
} else {
ans += BA + min(A, B);
}
cout << ans << endl;
}
int main(int argc, char **argv) {
ios::sync_with_stdio(false), cin.tie(0);
cout.tie(0);
Calc();
return 0;
} | #include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define mod 1000000007
#define FOR(x, to) for (int x = 0; x < (to); x++)
#define FORR(x, arr) for (auto &x : arr)
#define ALL(a) (a.begin()), (a.end())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define long long long
inline int rei() {
int x;
cin >> x;
return x;
}
inline long rel() {
long x;
cin >> x;
return x;
}
inline string res() {
string x;
cin >> x;
return x;
}
//-------------------------------------------------------
void Calc() {
int N = rei();
long ans = 0;
int BA = 0;
int A = 0;
int B = 0;
for (int j = 0; j < N; j++) {
string S = res();
for (int i = 0; i < S.length() - 1; i++) {
if (S[i] == 'A' && S[i + 1] == 'B') {
ans++;
}
}
if (S[0] == 'B' && S[S.length() - 1] == 'A') {
BA++;
} else if (S[0] == 'B') {
B++;
} else if (S[S.length() - 1] == 'A') {
A++;
}
}
if (A == 0 && B == 0) {
ans += max(BA - 1, 0);
} else {
ans += BA + min(A, B);
}
cout << ans << endl;
}
int main(int argc, char **argv) {
ios::sync_with_stdio(false), cin.tie(0);
cout.tie(0);
Calc();
return 0;
} | [
"call.add",
"call.arguments.add"
] | 866,900 | 866,901 | u387013436 | cpp |
p03049 | // IO
#include <cstdio>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm
#include <algorithm>
#include <cmath>
#include <numeric>
// container
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
// others
#include <cassert>
#include <ctime>
#include <functional>
#include <limits>
#include <random>
// type alias
using lint = long long;
using ldouble = long double;
template <class T>
using greater_priority_queue =
std::priority_queue<T, std::vector<T>, std::greater<T>>;
/* ----- class ----- */
template <class Cost = int> struct Edge {
int from, to;
Cost cost;
Edge(int from = -1, int to = -1, Cost cost = 1)
: from(from), to(to), cost(cost){};
bool operator<(const Edge<Cost> &e) const { return this->cost < e.cost; }
bool operator>(const Edge<Cost> &e) const { return this->cost > e.cost; }
};
template <class Cost = int> using Edges = std::vector<Edge<Cost>>;
template <class Cost = int> class Graph {
public:
int size;
std::vector<std::vector<Edge<Cost>>> path;
explicit Graph(int N = 0) : size(N), path(size) {}
void span(int from, int to, Cost cost = 1) {
path[from].push_back(Edge<Cost>(from, to, cost));
}
std::vector<Edge<Cost>> &operator[](int v) { return path[v]; }
};
/* ----- Output Functions for Debugging ----- */
template <class T> std::ostream &operator<<(std::ostream &os, std::vector<T> v);
template <class T> std::ostream &operator<<(std::ostream &os, std::set<T> v);
template <class L, class R>
std::ostream &operator<<(std::ostream &os, std::pair<L, R> p);
template <class K, class T>
std::ostream &operator<<(std::ostream &os, std::map<K, T> v);
template <class T> std::ostream &operator<<(std::ostream &os, std::stack<T> s);
template <class T> std::ostream &operator<<(std::ostream &os, std::queue<T> q);
template <class T>
std::ostream &operator<<(std::ostream &os, std::priority_queue<T> q);
template <class T>
std::ostream &
operator<<(std::ostream &os,
std::priority_queue<T, std::vector<T>, std::greater<T>> q);
template <class T> std::ostream &operator<<(std::ostream &os, Edge<T> e);
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> v) {
os << "[";
for (auto vv : v)
os << vv << ",";
return os << "]";
}
template <class T> std::ostream &operator<<(std::ostream &os, std::set<T> v) {
os << "{";
for (auto vv : v)
os << vv << ",";
return os << "}";
}
template <class L, class R>
std::ostream &operator<<(std::ostream &os, std::pair<L, R> p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <class K, class T>
std::ostream &operator<<(std::ostream &os, std::map<K, T> v) {
os << "{";
for (auto vv : v)
os << vv << ",";
return os << "}";
}
template <class T> std::ostream &operator<<(std::ostream &os, std::stack<T> s) {
os << "[";
while (!s.empty()) {
os << s.top() << ",";
s.pop();
}
return os << "]";
}
template <class T> std::ostream &operator<<(std::ostream &os, std::queue<T> q) {
os << "[";
while (!q.empty()) {
os << q.front() << ",";
q.pop();
}
return os << "]";
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::priority_queue<T> q) {
os << "{";
while (!q.empty()) {
os << q.top() << ",";
q.pop();
}
return os << "}";
}
template <class T>
std::ostream &
operator<<(std::ostream &os,
std::priority_queue<T, std::vector<T>, std::greater<T>> q) {
os << "{";
while (!q.empty()) {
os << q.top() << ",";
q.pop();
}
return os << "}";
}
template <class T> std::ostream &operator<<(std::ostream &os, Edge<T> e) {
return os << "(" << e.from << "->" << e.to << ":" << e.cost << ")";
}
/* ----- Short Functions ----- */
template <class T> inline T sq(T a) { return a * a; }
template <class T> inline T iceil(T n, T d) { return (n + d - 1) / d; }
template <class T> T gcd(T a, T b) {
while (b > 0) {
a %= b;
std::swap(a, b);
}
return a;
}
template <class T, class U> T ipow(T b, U n) {
T ret = 1;
while (n > 0) {
if (n & 1)
ret *= b;
n >>= 1;
b *= b;
}
return ret;
}
// 0-indexed
template <class T, class U> inline T kthbit(T a, U k) { return (a >> k) & 1; }
template <class T, class U> inline T mask(T a, U k) {
return a & ((1 << k) - 1);
}
template <class T> std::map<T, int> compress(std::vector<T> &v) {
std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end());
std::map<T, int> rev;
for (int i = 0; i < v.size(); ++i)
rev[v[i]] = i;
return rev;
}
template <class T> T Vec(T v) { return v; }
template <class T, class... Ts> auto Vec(size_t l, Ts... ts) {
return std::vector<decltype(Vec<T>(ts...))>(l, Vec<T>(ts...));
}
/* ----- Constants ----- */
// const int INF = std::numeric_limits<int>::max() / 3;
// const lint INF = std::numeric_limits<lint>::max() / 3;
// const ldouble PI = acos(-1);
// const ldouble EPS = 1e-10;
// std::mt19937 mt(int(std::time(nullptr)));
using namespace std;
int main() {
int N;
cin >> N;
vector<int> cnt(3, 0);
int ans = 0;
for (int i = 0; i < N; ++i) {
string S;
cin >> S;
if (S.front() == 'B' && S.back() == 'A') {
++cnt[2];
} else {
if (S.front() == 'B')
++cnt[0];
if (S.back() == 'A')
++cnt[1];
}
for (int j = 0; j + 1 < S.length(); ++j) {
if (S.substr(j, 2) == "AB")
++ans;
}
}
if (cnt[0] > 0 && cnt[1] > 0) {
ans += cnt[2] + 1;
--cnt[0];
--cnt[1];
ans += min(cnt[0], cnt[1]);
} else if (cnt[0] > 0 || cnt[1] > 0) {
ans += cnt[2];
} else {
ans += cnt[2] - 1;
}
cout << ans << endl;
return 0;
}
| // IO
#include <cstdio>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm
#include <algorithm>
#include <cmath>
#include <numeric>
// container
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
// others
#include <cassert>
#include <ctime>
#include <functional>
#include <limits>
#include <random>
// type alias
using lint = long long;
using ldouble = long double;
template <class T>
using greater_priority_queue =
std::priority_queue<T, std::vector<T>, std::greater<T>>;
/* ----- class ----- */
template <class Cost = int> struct Edge {
int from, to;
Cost cost;
Edge(int from = -1, int to = -1, Cost cost = 1)
: from(from), to(to), cost(cost){};
bool operator<(const Edge<Cost> &e) const { return this->cost < e.cost; }
bool operator>(const Edge<Cost> &e) const { return this->cost > e.cost; }
};
template <class Cost = int> using Edges = std::vector<Edge<Cost>>;
template <class Cost = int> class Graph {
public:
int size;
std::vector<std::vector<Edge<Cost>>> path;
explicit Graph(int N = 0) : size(N), path(size) {}
void span(int from, int to, Cost cost = 1) {
path[from].push_back(Edge<Cost>(from, to, cost));
}
std::vector<Edge<Cost>> &operator[](int v) { return path[v]; }
};
/* ----- Output Functions for Debugging ----- */
template <class T> std::ostream &operator<<(std::ostream &os, std::vector<T> v);
template <class T> std::ostream &operator<<(std::ostream &os, std::set<T> v);
template <class L, class R>
std::ostream &operator<<(std::ostream &os, std::pair<L, R> p);
template <class K, class T>
std::ostream &operator<<(std::ostream &os, std::map<K, T> v);
template <class T> std::ostream &operator<<(std::ostream &os, std::stack<T> s);
template <class T> std::ostream &operator<<(std::ostream &os, std::queue<T> q);
template <class T>
std::ostream &operator<<(std::ostream &os, std::priority_queue<T> q);
template <class T>
std::ostream &
operator<<(std::ostream &os,
std::priority_queue<T, std::vector<T>, std::greater<T>> q);
template <class T> std::ostream &operator<<(std::ostream &os, Edge<T> e);
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> v) {
os << "[";
for (auto vv : v)
os << vv << ",";
return os << "]";
}
template <class T> std::ostream &operator<<(std::ostream &os, std::set<T> v) {
os << "{";
for (auto vv : v)
os << vv << ",";
return os << "}";
}
template <class L, class R>
std::ostream &operator<<(std::ostream &os, std::pair<L, R> p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <class K, class T>
std::ostream &operator<<(std::ostream &os, std::map<K, T> v) {
os << "{";
for (auto vv : v)
os << vv << ",";
return os << "}";
}
template <class T> std::ostream &operator<<(std::ostream &os, std::stack<T> s) {
os << "[";
while (!s.empty()) {
os << s.top() << ",";
s.pop();
}
return os << "]";
}
template <class T> std::ostream &operator<<(std::ostream &os, std::queue<T> q) {
os << "[";
while (!q.empty()) {
os << q.front() << ",";
q.pop();
}
return os << "]";
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::priority_queue<T> q) {
os << "{";
while (!q.empty()) {
os << q.top() << ",";
q.pop();
}
return os << "}";
}
template <class T>
std::ostream &
operator<<(std::ostream &os,
std::priority_queue<T, std::vector<T>, std::greater<T>> q) {
os << "{";
while (!q.empty()) {
os << q.top() << ",";
q.pop();
}
return os << "}";
}
template <class T> std::ostream &operator<<(std::ostream &os, Edge<T> e) {
return os << "(" << e.from << "->" << e.to << ":" << e.cost << ")";
}
/* ----- Short Functions ----- */
template <class T> inline T sq(T a) { return a * a; }
template <class T> inline T iceil(T n, T d) { return (n + d - 1) / d; }
template <class T> T gcd(T a, T b) {
while (b > 0) {
a %= b;
std::swap(a, b);
}
return a;
}
template <class T, class U> T ipow(T b, U n) {
T ret = 1;
while (n > 0) {
if (n & 1)
ret *= b;
n >>= 1;
b *= b;
}
return ret;
}
// 0-indexed
template <class T, class U> inline T kthbit(T a, U k) { return (a >> k) & 1; }
template <class T, class U> inline T mask(T a, U k) {
return a & ((1 << k) - 1);
}
template <class T> std::map<T, int> compress(std::vector<T> &v) {
std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end());
std::map<T, int> rev;
for (int i = 0; i < v.size(); ++i)
rev[v[i]] = i;
return rev;
}
template <class T> T Vec(T v) { return v; }
template <class T, class... Ts> auto Vec(size_t l, Ts... ts) {
return std::vector<decltype(Vec<T>(ts...))>(l, Vec<T>(ts...));
}
/* ----- Constants ----- */
// const int INF = std::numeric_limits<int>::max() / 3;
// const lint INF = std::numeric_limits<lint>::max() / 3;
// const ldouble PI = acos(-1);
// const ldouble EPS = 1e-10;
// std::mt19937 mt(int(std::time(nullptr)));
using namespace std;
int main() {
int N;
cin >> N;
vector<int> cnt(3, 0);
int ans = 0;
for (int i = 0; i < N; ++i) {
string S;
cin >> S;
if (S.front() == 'B' && S.back() == 'A') {
++cnt[2];
} else {
if (S.front() == 'B')
++cnt[0];
if (S.back() == 'A')
++cnt[1];
}
for (int j = 0; j + 1 < S.length(); ++j) {
if (S.substr(j, 2) == "AB")
++ans;
}
}
if (cnt[0] > 0 && cnt[1] > 0) {
ans += cnt[2] + 1;
--cnt[0];
--cnt[1];
ans += min(cnt[0], cnt[1]);
} else if (cnt[0] > 0 || cnt[1] > 0) {
ans += cnt[2];
} else {
ans += max(0, cnt[2] - 1);
}
cout << ans << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 866,902 | 866,903 | u059727354 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
int TA = 0, TB = 0, TAB = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
TAB++;
} else if (s[i][0] == 'B') {
TB++;
} else if (s[i][s[i].size() - 1] == 'A') {
TA++;
}
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
if (TA == 0 && TB == 0) {
ans += TAB - 1;
} else {
ans += min(TA, TB) + TAB;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
int TA = 0, TB = 0, TAB = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A') {
TAB++;
} else if (s[i][0] == 'B') {
TB++;
} else if (s[i][s[i].size() - 1] == 'A') {
TA++;
}
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
}
if (TA == 0 && TB == 0 && TAB != 0) {
ans += TAB - 1;
} else {
ans += min(TA, TB) + TAB;
}
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change"
] | 866,909 | 866,910 | u083190434 | cpp |
p03049 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rrep(i, a, b) for (int i = (int)(a); i >= (int)(b); --i)
#define fore(i, a) for (auto &i : a)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define isin(i, a, b) ((a) <= (i) && (i) < (b))
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define fi first
#define se second
#define pb push_back
#define sz(a) (int)(a).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
using ll = long long;
using unit = unsigned;
using ull = unsigned long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vp = vector<P>;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
template <class T> void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> void POSS(T condition) {
if (condition)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
}
template <class T> void Poss(T condition) {
if (condition)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
}
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> T gcd(T a, T b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
constexpr double eps = 1e-10;
constexpr int inf = INT_MAX / 2;
constexpr ll infl = 1LL << 60;
void _main() {
int N;
cin >> N;
vector<string> s(N);
rep(i, 0, N) cin >> s[i];
int cnt_a = 0;
int cnt_b = 0;
int cnt_ab = 0;
int ans = 0;
rep(i, 0, N) {
int ssize = s[i].size();
if (s[i][ssize - 1] == 'A' && s[i][0] == 'B')
cnt_ab++;
else if (s[i][ssize - 1] == 'A')
cnt_a++;
else if (s[i][0] == 'B')
cnt_b++;
rep(j, 1, ssize) {
if (s[i][j - 1] == 'A' && s[i][j] == 'B')
ans++;
}
}
if (cnt_a > 0 || cnt_b > 0) {
ans += cnt_ab;
ans += min({cnt_a, cnt_b});
} else {
ans += min(0, cnt_ab - 1);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rrep(i, a, b) for (int i = (int)(a); i >= (int)(b); --i)
#define fore(i, a) for (auto &i : a)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define isin(i, a, b) ((a) <= (i) && (i) < (b))
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define fi first
#define se second
#define pb push_back
#define sz(a) (int)(a).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
using ll = long long;
using unit = unsigned;
using ull = unsigned long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vp = vector<P>;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
template <class T> void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> void POSS(T condition) {
if (condition)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
}
template <class T> void Poss(T condition) {
if (condition)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
}
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> T gcd(T a, T b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
constexpr double eps = 1e-10;
constexpr int inf = INT_MAX / 2;
constexpr ll infl = 1LL << 60;
void _main() {
int N;
cin >> N;
vector<string> s(N);
rep(i, 0, N) cin >> s[i];
int cnt_a = 0;
int cnt_b = 0;
int cnt_ab = 0;
int ans = 0;
rep(i, 0, N) {
int ssize = s[i].size();
if (s[i][ssize - 1] == 'A' && s[i][0] == 'B')
cnt_ab++;
else if (s[i][ssize - 1] == 'A')
cnt_a++;
else if (s[i][0] == 'B')
cnt_b++;
rep(j, 1, ssize) {
if (s[i][j - 1] == 'A' && s[i][j] == 'B')
ans++;
}
}
if (cnt_a > 0 || cnt_b > 0) {
ans += cnt_ab;
ans += min({cnt_a, cnt_b});
} else {
ans += max(0, cnt_ab - 1);
}
cout << ans << endl;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 866,915 | 866,916 | u430494842 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, i, w, x, y, z, t;
string str;
t = 0;
x = 0;
y = 0;
z = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> str;
w = str.size();
if (str.at(w - 1) == 'A' && str.at(0) == 'B') {
z++;
}
else if (str.at(0) == 'B') {
x++;
} else if (str.at(w - 1) == 'A') {
y++;
}
for (m = 0; m < w - 1; m++) {
if (str.at(m) == 'A' && str.at(m + 1) == 'B') {
t++;
}
}
}
if (x + y == 0) {
t = t + z - 1;
} else if (x >= y) {
t = t + y + z;
} else {
t = t + x + z;
}
cout << t;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, i, w, x, y, z, t;
string str;
t = 0;
x = 0;
y = 0;
z = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> str;
w = str.size();
if (str.at(w - 1) == 'A' && str.at(0) == 'B') {
z++;
} else if (str.at(0) == 'B') {
x++;
} else if (str.at(w - 1) == 'A') {
y++;
}
for (m = 0; m < w - 1; m++) {
if (str.at(m) == 'A' && str.at(m + 1) == 'B') {
t++;
}
}
}
if (x + y == 0 && z > 0) {
t = t + z - 1;
} else if (x >= y) {
t = t + y + z;
} else {
t = t + x + z;
}
cout << t;
} | [
"control_flow.branch.if.condition.change"
] | 866,924 | 866,925 | u325573017 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, f, n) for (int i = (f); i < (n); i++)
#define loop(i, L, R) for (int i = (L); i <= (R); i++)
const int maxn = 1e5 + 5;
int main() {
int n;
string s;
scanf("%d", &n);
int ans = 0, x = 0, y = 0, z = 0;
rep(i, n) {
cin >> s;
int n = s.size();
rep(i, n - 1) if (s[i] == 'A' && s[i + 1] == 'B') ans++;
if (s[0] == 'B')
x++;
if (s[n - 1] == 'A')
y++;
if (s[0] == 'B' && s[n - 1] == 'A')
z++;
}
if (x == y && x == z)
ans += (x - 1);
else
ans += min(x, y);
printf("%d\n", ans);
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, f, n) for (int i = (f); i < (n); i++)
#define loop(i, L, R) for (int i = (L); i <= (R); i++)
const int maxn = 1e5 + 5;
int main() {
int n;
string s;
scanf("%d", &n);
int ans = 0, x = 0, y = 0, z = 0;
rep(i, n) {
cin >> s;
int n = s.size();
rep(i, n - 1) if (s[i] == 'A' && s[i + 1] == 'B') ans++;
if (s[0] == 'B')
x++;
if (s[n - 1] == 'A')
y++;
if (s[0] == 'B' && s[n - 1] == 'A')
z++;
}
if (x == y && x == z && x && y && z)
ans += (x - 1);
else
ans += min(x, y);
printf("%d\n", ans);
}
| [
"control_flow.branch.if.condition.change"
] | 866,928 | 866,929 | u439283029 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
int count(string s) {
int res = 0;
for (int i = 0; i < s.length() - 1; i++)
if (s[i] == 'A' && s[i + 1] == 'B')
res++;
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int res = 0;
int n;
cin >> n;
int a, b, ba;
a = b = ba = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
res += count(s);
if (s[0] != 'B' && s.back() == 'A')
a++;
if (s[0] == 'B' && s.back() != 'A')
b++;
if (s[0] == 'B' && s.back() == 'A')
ba++;
}
res += min(a, b) + ba;
if (a == 0 && b == 0)
res--;
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
int count(string s) {
int res = 0;
for (int i = 0; i < s.length() - 1; i++)
if (s[i] == 'A' && s[i + 1] == 'B')
res++;
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int res = 0;
int n;
cin >> n;
int a, b, ba;
a = b = ba = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
res += count(s);
if (s[0] != 'B' && s.back() == 'A')
a++;
if (s[0] == 'B' && s.back() != 'A')
b++;
if (s[0] == 'B' && s.back() == 'A')
ba++;
}
res += min(a, b) + ba;
if (a == 0 && b == 0 && ba >= 1)
res--;
cout << res << endl;
} | [
"control_flow.branch.if.condition.change"
] | 866,930 | 866,931 | u473635856 | cpp |
p03049 | #include <bits/stdc++.h>
#define rep(i, x, y) for (int i = (x); i <= (y); i++)
using namespace std;
const int N = 1e4 + 10;
int n, l, ans, a, b, ba;
char s[N];
int main() {
scanf("%d", &n);
rep(i, 1, n) {
scanf("%s", s + 1), l = strlen(s + 1);
if (s[1] == 'B' && s[l] == 'A')
ba++;
else if (s[1] == 'B')
b++;
else if (s[l] == 'A')
a++;
rep(j, 1, l - 1) if (s[j] == 'A' && s[j + 1] == 'B') ans++;
}
ans += min(a, b) + ba;
if (!a && !b)
ans--;
printf("%d\n", ans);
return 0;
} | #include <bits/stdc++.h>
#define rep(i, x, y) for (int i = (x); i <= (y); i++)
using namespace std;
const int N = 1e4 + 10;
int n, l, ans, a, b, ba;
char s[N];
int main() {
scanf("%d", &n);
rep(i, 1, n) {
scanf("%s", s + 1), l = strlen(s + 1);
if (s[1] == 'B' && s[l] == 'A')
ba++;
else if (s[1] == 'B')
b++;
else if (s[l] == 'A')
a++;
rep(j, 1, l - 1) if (s[j] == 'A' && s[j + 1] == 'B') ans++;
}
ans += min(a, b) + ba;
if (!a && !b && ba)
ans--;
printf("%d\n", ans);
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 866,935 | 866,936 | u222216068 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0, na = 0, nb = 0, c = 1;
string temp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> temp;
if (temp.front() == 'B') {
nb++;
if (temp.back() != 'A') {
c = 0;
}
}
if (temp.back() == 'A') {
na++;
}
for (int j = 0; j < temp.size() - 1; j++) {
if (temp[j] == 'A') {
if (temp[j + 1] == 'B') {
ans++;
}
}
}
}
if (na == nb && c == 1) {
ans += min(na, nb) - 1;
} else {
ans += min(na, nb);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0, na = 0, nb = 0, c = 1;
string temp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> temp;
if (temp.front() == 'B') {
nb++;
if (temp.back() != 'A') {
c = 0;
}
}
if (temp.back() == 'A') {
na++;
}
for (int j = 0; j < temp.size() - 1; j++) {
if (temp[j] == 'A') {
if (temp[j + 1] == 'B') {
ans++;
}
}
}
}
if (na == nb && na > 0 && c == 1) {
ans += min(na, nb) - 1;
} else {
ans += min(na, nb);
}
cout << ans << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 866,939 | 866,940 | u576357314 | cpp |
p03049 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF (1 << 29)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
Int n, a, b, ba;
string str;
Int bias;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str;
for (int j = 0; j < str.size() - 1; j++) {
if (str[j] == 'A' && str[j + 1] == 'B')
bias++;
}
if (str[0] == 'B' && str[str.size() - 1] == 'A')
ba++;
if (str[0] == 'B' && str[str.size() - 1] != 'A')
b++;
if (str[0] != 'B' && str[str.size() - 1] == 'A')
a++;
}
if (a || b) {
bias += ba;
bias += min(a, b);
} else {
bias += max(0LL, b - 1);
}
cout << bias << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INF (1 << 29)
#define LINF (1LL << 60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
Int n, a, b, ba;
string str;
Int bias;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str;
for (int j = 0; j < str.size() - 1; j++) {
if (str[j] == 'A' && str[j + 1] == 'B')
bias++;
}
if (str[0] == 'B' && str[str.size() - 1] == 'A')
ba++;
if (str[0] == 'B' && str[str.size() - 1] != 'A')
b++;
if (str[0] != 'B' && str[str.size() - 1] == 'A')
a++;
}
if (a || b) {
bias += ba;
bias += min(a, b);
} else {
bias += max(0LL, ba - 1);
}
cout << bias << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 866,944 | 866,945 | u299869545 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 99999999
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
int main() {
int n;
// int pos;
cin >> n;
vector<string> s(n);
bool flag;
int ans = 0;
int Akey = 0;
int Bkey = 0;
int minus = 0;
rep(i, n) { cin >> s[i]; }
rep(i, n) {
/*
flag = false;
rep(j,s[i].size())
{
if(flag)
{
if(s[i][j] == 'B')
{
ans++;
//cout << "i is " << i << " and j is " << j << endl;
}
flag = false;
}
else if(s[i][j] == 'A') flag = true;
else flag = false;
}
*/
string::size_type pos = s[i].find("AB");
while (pos != std::string::npos) {
pos = s[i].find("AB", pos + 2);
ans++;
}
if (s[i][s[i].size() - 1] == 'A' && s[i][0] != 'B')
Akey++;
if (s[i][s[i].size() - 1] != 'A' && s[i][0] == 'B')
Bkey++;
if (s[i][s[i].size() - 1] == 'A' && s[i][0] == 'B')
minus++;
}
// cout << "ans is" << ans << " and Akey is " << Akey << " and Bkey is " <<
// Bkey << endl; if(min(Akey,Bkey) <= minus) cout << ans + min(Akey,Bkey) -
// minus + 1 << endl;
if (Akey + Bkey == 0 && minus != 0)
cout << ans + minus - 1 << endl;
else
cout << ans + min(Akey, Bkey) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define INF 99999999
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
int main() {
int n;
// int pos;
cin >> n;
vector<string> s(n);
bool flag;
int ans = 0;
int Akey = 0;
int Bkey = 0;
int minus = 0;
rep(i, n) { cin >> s[i]; }
rep(i, n) {
/*
flag = false;
rep(j,s[i].size())
{
if(flag)
{
if(s[i][j] == 'B')
{
ans++;
//cout << "i is " << i << " and j is " << j << endl;
}
flag = false;
}
else if(s[i][j] == 'A') flag = true;
else flag = false;
}
*/
string::size_type pos = s[i].find("AB");
while (pos != std::string::npos) {
pos = s[i].find("AB", pos + 2);
ans++;
}
if (s[i][s[i].size() - 1] == 'A' && s[i][0] != 'B')
Akey++;
if (s[i][s[i].size() - 1] != 'A' && s[i][0] == 'B')
Bkey++;
if (s[i][s[i].size() - 1] == 'A' && s[i][0] == 'B')
minus++;
}
// cout << "ans is" << ans << " and Akey is " << Akey << " and Bkey is " <<
// Bkey << endl; if(min(Akey,Bkey) <= minus) cout << ans + min(Akey,Bkey) -
// minus + 1 << endl;
if (Akey + Bkey == 0 && minus != 0)
cout << ans + minus - 1 << endl;
else
cout << ans + minus + min(Akey, Bkey) << endl;
}
| [
"expression.operation.binary.add"
] | 866,947 | 866,948 | u730271001 | cpp |
p03049 | #include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
int containAB = 0;
int beginB = 0;
int endA = 0;
int beginBendA = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
auto pos = s.find("AB");
while (pos != string::npos) {
containAB++;
pos = s.find("AB", pos + 2);
}
if (s[0] == 'B')
beginB++;
if (s[s.size() - 1] == 'A')
endA++;
if (s[s.size() - 1] == 'A' && s[0] == 'B')
beginBendA++;
}
if (beginBendA == beginB && beginBendA == endA)
cout << beginBendA - 1 + containAB << endl;
else
cout << min(beginB, endA) + containAB << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
int containAB = 0;
int beginB = 0;
int endA = 0;
int beginBendA = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
auto pos = s.find("AB");
while (pos != string::npos) {
containAB++;
pos = s.find("AB", pos + 2);
}
if (s[0] == 'B')
beginB++;
if (s[s.size() - 1] == 'A')
endA++;
if (s[s.size() - 1] == 'A' && s[0] == 'B')
beginBendA++;
}
if (beginBendA == beginB && beginBendA == endA && beginBendA)
cout << beginBendA - 1 + containAB << endl;
else
cout << min(beginB, endA) + containAB << endl;
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 866,956 | 866,957 | u841641310 | cpp |
p03049 | #include <bits/stdc++.h>
#define cinf(n, x) \
for (int i = 0; i < (n); i++) \
cin >> x[i];
typedef long long int ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
cinf(n, s);
ll cnt = 0;
ll cnt_A = 0;
ll cnt_B = 0;
ll cntw = 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')
cnt++;
}
if (s[i][0] == 'B')
cnt_B++;
if (s[i][s[i].size() - 1] == 'A')
cnt_A++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
cntw++;
}
if (cntw == cnt_A && cntw == cnt_B)
cout << cnt + min(cnt_A, cnt_B) - 1 << endl;
else
cout << cnt + min(cnt_A, cnt_B) << endl;
} | #include <bits/stdc++.h>
#define cinf(n, x) \
for (int i = 0; i < (n); i++) \
cin >> x[i];
typedef long long int ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
cinf(n, s);
ll cnt = 0;
ll cnt_A = 0;
ll cnt_B = 0;
ll cntw = 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')
cnt++;
}
if (s[i][0] == 'B')
cnt_B++;
if (s[i][s[i].size() - 1] == 'A')
cnt_A++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
cntw++;
}
if (cntw == cnt_A && cntw == cnt_B && cntw != 0)
cout << cnt + min(cnt_A, cnt_B) - 1 << endl;
else
cout << cnt + min(cnt_A, cnt_B) << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 866,958 | 866,959 | u928536113 | cpp |
p03049 | #include <bits/stdc++.h>
#define cinf(n, x) \
for (int i = 0; i < (n); i++) \
cin >> x[i];
typedef long long int ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
cinf(n, s);
ll cnt = 0;
ll cnt_A = 0;
ll cnt_B = 0;
ll cntw = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < s[i].size() - 2; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
cnt++;
}
if (s[i][0] == 'B')
cnt_B++;
if (s[i][s[i].size() - 1] == 'A')
cnt_A++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
cntw++;
}
if (cntw == cnt_A && cntw == cnt_B)
cout << cnt + min(cnt_A, cnt_B) - 1 << endl;
else
cout << cnt + min(cnt_A, cnt_B) << endl;
} | #include <bits/stdc++.h>
#define cinf(n, x) \
for (int i = 0; i < (n); i++) \
cin >> x[i];
typedef long long int ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
cinf(n, s);
ll cnt = 0;
ll cnt_A = 0;
ll cnt_B = 0;
ll cntw = 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')
cnt++;
}
if (s[i][0] == 'B')
cnt_B++;
if (s[i][s[i].size() - 1] == 'A')
cnt_A++;
if (s[i][0] == 'B' && s[i][s[i].size() - 1] == 'A')
cntw++;
}
if (cntw == cnt_A && cntw == cnt_B && cntw != 0)
cout << cnt + min(cnt_A, cnt_B) - 1 << endl;
else
cout << cnt + min(cnt_A, cnt_B) << endl;
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 866,960 | 866,959 | u928536113 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//#define int ll
using vb = vector<bool>;
using vvb = vector<vb>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
template <class T> using V = vector<T>;
template <class T> using VV = vector<V<T>>;
#define fi first
#define se second
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (ll i = (ll)(b)-1; i >= a; --i)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1), EPS = 1e-10;
const ll MOD = 1e9 + 7;
void cioacc() { // accelerate cin/cout
cin.tie(0);
ios::sync_with_stdio(false);
}
int abct(string &s) {
int res = 0;
int now = 0;
while (now < (int)s.size() && ((now = s.find("AB", now)) != -1)) {
res++;
now += 2;
}
return res;
}
signed main() {
int n;
cin >> n;
vector<string> s(n);
int a = 0, b = 0, id = 0;
int ans = 0;
REP(i, n) {
cin >> s[i];
ans += abct(s[i]);
if (s[i].back() == 'A' && s[i].front() == 'B')
id++;
else if (s[i].back() == 'A')
++a;
else if (s[i].front() == 'B')
++b;
}
if (n == 1) {
cout << abct(s[0]) << endl;
return 0;
}
if (id)
ans += id - 1;
if (a)
ans++, a--;
if (b)
ans++, b--;
ans += min(a, b);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//#define int ll
using vb = vector<bool>;
using vvb = vector<vb>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
template <class T> using V = vector<T>;
template <class T> using VV = vector<V<T>>;
#define fi first
#define se second
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (ll i = (ll)(b)-1; i >= a; --i)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1), EPS = 1e-10;
const ll MOD = 1e9 + 7;
void cioacc() { // accelerate cin/cout
cin.tie(0);
ios::sync_with_stdio(false);
}
int abct(string &s) {
int res = 0;
int now = 0;
while (now < (int)s.size() && ((now = s.find("AB", now)) != -1)) {
res++;
now += 2;
}
return res;
}
signed main() {
int n;
cin >> n;
vector<string> s(n);
int a = 0, b = 0, id = 0;
int ans = 0;
REP(i, n) {
cin >> s[i];
ans += abct(s[i]);
if (s[i].back() == 'A' && s[i].front() == 'B')
id++;
else if (s[i].back() == 'A')
++a;
else if (s[i].front() == 'B')
++b;
}
if (n == 1) {
cout << abct(s[0]) << endl;
return 0;
}
if (id) {
ans += id - 1;
if (a)
ans++, a--;
if (b)
ans++, b--;
}
ans += min(a, b);
cout << ans << endl;
}
| [] | 866,969 | 866,970 | u949798495 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//#define int ll
using vb = vector<bool>;
using vvb = vector<vb>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
template <class T> using V = vector<T>;
template <class T> using VV = vector<V<T>>;
#define fi first
#define se second
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (ll i = (ll)(b)-1; i >= a; --i)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1), EPS = 1e-10;
const ll MOD = 1e9 + 7;
void cioacc() { // accelerate cin/cout
cin.tie(0);
ios::sync_with_stdio(false);
}
int abct(string &s) {
int res = 0;
int now = 0;
while (now < (int)s.size() && ((now = s.find("AB", now)) != -1)) {
res++;
now += 2;
}
return res;
}
signed main() {
int n;
cin >> n;
vector<string> s(n);
int a = 0, b = 0, id = 0;
int ans = 0;
REP(i, n) {
cin >> s[i];
ans += abct(s[i]);
if (s[i].back() == 'A' && s[i].front() == 'B')
id++;
if (s[i].back() == 'A')
++a;
if (s[i].front() == 'B')
++b;
}
if (n == 1) {
cout << abct(s[0]) << endl;
return 0;
}
if (id == a && id == b)
a--, b--;
// else if(id==a) b--;
// else if(id==b) a--;
ans += min({a, b, n - 1});
cout << ans << endl;
// vi diff;
// set_difference(a.begin(), a.end(),b.begin(), b.end(),std::inserter(diff,
// diff.end())); string t; int fs = 0; if((int)b.size()==n) fs = 0; else {
// REP(i,b.size()){
// if(b[i]!=i){
// fs = i;
// break;
// }
// }
// fs = b.size();
// }
// set<int> st;
// REP(i,n){
// st.insert(i);
// }
// t += s[fs];
// st.erase(fs);
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//#define int ll
using vb = vector<bool>;
using vvb = vector<vb>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
template <class T> using V = vector<T>;
template <class T> using VV = vector<V<T>>;
#define fi first
#define se second
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (ll i = (ll)(b)-1; i >= a; --i)
#define RREP(i, n) RFOR(i, 0, n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1), EPS = 1e-10;
const ll MOD = 1e9 + 7;
void cioacc() { // accelerate cin/cout
cin.tie(0);
ios::sync_with_stdio(false);
}
int abct(string &s) {
int res = 0;
int now = 0;
while (now < (int)s.size() && ((now = s.find("AB", now)) != -1)) {
res++;
now += 2;
}
return res;
}
signed main() {
int n;
cin >> n;
vector<string> s(n);
int a = 0, b = 0, id = 0;
int ans = 0;
REP(i, n) {
cin >> s[i];
ans += abct(s[i]);
if (s[i].back() == 'A' && s[i].front() == 'B')
id++;
if (s[i].back() == 'A')
++a;
if (s[i].front() == 'B')
++b;
}
if (n == 1) {
cout << abct(s[0]) << endl;
return 0;
}
if (id == a && id == b)
a--, b--;
ans += max(min({a, b, n - 1}), 0);
cout << ans << endl;
}
| [
"call.add",
"call.arguments.add"
] | 866,971 | 866,972 | u949798495 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, cA, cB, cAB, counter, i, j;
counter = 0;
string s;
cA = 0;
cB = 0;
cAB = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> s;
int count = 0;
for (j = 0; j < s.size() - 1; j++) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
count++;
}
}
counter += count;
if (s.at(s.size() - 1) == 'A' && s.at(0) == 'B')
cAB++;
else if (s.at(s.size() - 1) == 'A')
cA++;
else if (s.at(0) == 'B')
cB++;
}
if (cAB > 0) {
counter += cAB - 1;
cA++;
cB++;
}
if (cA == 1 && cB == 1)
cout << counter << endl;
else {
counter += min(cA, cB);
cout << counter << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, cA, cB, cAB, counter, i, j;
counter = 0;
string s;
cA = 0;
cB = 0;
cAB = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> s;
int count = 0;
for (j = 0; j < s.size() - 1; j++) {
if (s.at(j) == 'A' && s.at(j + 1) == 'B') {
count++;
}
}
counter += count;
if (s.at(s.size() - 1) == 'A' && s.at(0) == 'B')
cAB++;
else if (s.at(s.size() - 1) == 'A')
cA++;
else if (s.at(0) == 'B')
cB++;
}
if (cAB > 0) {
counter += cAB - 1;
cA++;
cB++;
}
if (cA == 1 && cB == 1 && cAB > 0)
cout << counter << endl;
else {
counter += min(cA, cB);
cout << counter << endl;
}
} | [
"control_flow.branch.if.condition.change"
] | 866,982 | 866,983 | u409569205 | cpp |
p03049 | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
for (int i = 0; i < n; ++i)
cin >> s[i];
int ret = 0;
int xa = 0, bx = 0, bxa = 0;
for (auto &t : s) {
for (int i = 0; i < t.size() - 1; ++i) {
if (t[i] == 'A' && t[i + 1] == 'B')
++ret;
}
if (t.front() == 'B') {
if (t.back() == 'A')
++bxa;
else
++bx;
} else if (t.back() == 'A')
++xa;
}
ret += bxa + min(bx, xa);
if (bx == 0 && xa == 0)
--ret;
cout << ret << "\n";
return 0;
}
| #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
for (int i = 0; i < n; ++i)
cin >> s[i];
int ret = 0;
int xa = 0, bx = 0, bxa = 0;
for (auto &t : s) {
for (int i = 0; i < t.size() - 1; ++i) {
if (t[i] == 'A' && t[i + 1] == 'B')
++ret;
}
if (t.front() == 'B') {
if (t.back() == 'A')
++bxa;
else
++bx;
} else if (t.back() == 'A')
++xa;
}
ret += bxa + min(bx, xa);
if (bx == 0 && xa == 0 && bxa)
--ret;
cout << ret << "\n";
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 866,984 | 866,985 | u661686644 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
int n;
cin >> n;
string s[n + 1];
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
int count = 0;
int startb = 0;
int enda = 0;
int both = 0;
for (int i = 1; i <= n; i++) {
int len = s[i].length();
for (int j = 0; j < len - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
count++;
}
if (s[i][0] == 'B')
startb++;
if (s[i][len - 1] == 'A')
enda++;
if (s[i][0] == 'B' && s[i][len - 1] == 'A')
both++;
}
if (startb == enda && both == startb)
startb--;
cout << count + min(startb, enda) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main() {
int n;
cin >> n;
string s[n + 1];
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
int count = 0;
int startb = 0;
int enda = 0;
int both = 0;
for (int i = 1; i <= n; i++) {
int len = s[i].length();
for (int j = 0; j < len - 1; j++) {
if (s[i][j] == 'A' && s[i][j + 1] == 'B')
count++;
}
if (s[i][0] == 'B')
startb++;
if (s[i][len - 1] == 'A')
enda++;
if (s[i][0] == 'B' && s[i][len - 1] == 'A')
both++;
}
if (startb == enda && both == startb)
startb--;
cout << count + max(0, min(startb, enda)) << endl;
} | [
"call.add",
"call.arguments.change"
] | 866,989 | 866,990 | u742642200 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N;
cin >> N;
string s;
int AB{0}, BA{0}, A{0}, B{0};
for (int i{0}; i < N; ++i) {
cin >> s;
for (int j{1}; j < s.size(); ++j) {
if (s[j - 1] == 'A' and s[j] == 'B')
++AB;
}
if (s[0] == 'B' and s[s.size() - 1] == 'A') {
++BA;
} else if (s[0] == 'B') {
++B;
} else if (s[s.size() - 1] == 'A') {
++A;
}
}
int sum{AB};
if (A + B == 0)
sum += BA - 1;
else
sum += BA + min(A, B);
cout << sum << endl;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N;
cin >> N;
string s;
int AB{0}, BA{0}, A{0}, B{0};
for (int i{0}; i < N; ++i) {
cin >> s;
for (int j{1}; j < s.size(); ++j) {
if (s[j - 1] == 'A' and s[j] == 'B')
++AB;
}
if (s[0] == 'B' and s[s.size() - 1] == 'A') {
++BA;
} else if (s[0] == 'B') {
++B;
} else if (s[s.size() - 1] == 'A') {
++A;
}
}
int sum{AB};
if (A + B == 0 and BA > 0)
sum += BA - 1;
else
sum += BA + min(A, B);
cout << sum << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 866,993 | 866,994 | u454037451 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> PII;
typedef map<int, int> MII;
typedef priority_queue<int> P_QI;
typedef priority_queue<string> P_QS;
typedef vector<int> VI;
typedef vector<long long> VLL;
typedef vector<int>::iterator $$;
#define SET(arr) memset(arr, -1, sizeof(arr))
#define CLR(arr) memset(arr, 0, sizeof(arr))
#define READ(f) freopen(f, "r", stdin)
#define WRITE(f) freopen(f, "w", stdout)
#define $ vector<int>::iterator
#define m_p make_pair
#define p_b push_back
#define rep(i, n) for (int i = 0; i < (n); i++)
#define forn(i, n) for (int i = 1; i <= (int)(n); ++i)
#define forab(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
#define forba(i, b, a) for (int i = (int)(b); i >= (int)(a); --i)
#define forv(i, v) rep(i, SZ(v))
#define forit(i, s) for (auto i = (s).begin(); i != (s).end(); ++i)
#define Boost \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define all(a) (a).begin(), (a).end()
#define SZ(x) ((int)(x).size())
#define F first
#define S second
#define _ << " " <<
#define CS(i) cout << "Case " << (int)(i) << ": "
const int MOD = 1e9 + 7;
const int inf = 1e9 + 9;
const long long INF = 1e18 + 3;
const ld eps = 1e-9;
const ld PI = acos(-1.0);
const ld E = 2.71828182845904523536;
int main() {
Boost;
// READ("in.txt");
// WRITE("out.txt");
int n, ans = 0, b = 0, a = 0, ba = 0;
cin >> n;
string s[n];
rep(i, n) cin >> s[i];
rep(i, n) {
forv(j, s[i]) {
if (j == SZ(s[i]) - 1)
;
else if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
if (s[i][0] == 'B')
b++;
if (s[i][SZ(s[i]) - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][SZ(s[i]) - 1] == 'A')
ba++;
}
// cout<<a _ b _ ba _ ans<<endl;
if (a == b) {
if (a == ba)
ans += a - 1;
else
ans += a;
} else
ans += min(a, b);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> PII;
typedef map<int, int> MII;
typedef priority_queue<int> P_QI;
typedef priority_queue<string> P_QS;
typedef vector<int> VI;
typedef vector<long long> VLL;
typedef vector<int>::iterator $$;
#define SET(arr) memset(arr, -1, sizeof(arr))
#define CLR(arr) memset(arr, 0, sizeof(arr))
#define READ(f) freopen(f, "r", stdin)
#define WRITE(f) freopen(f, "w", stdout)
#define $ vector<int>::iterator
#define m_p make_pair
#define p_b push_back
#define rep(i, n) for (int i = 0; i < (n); i++)
#define forn(i, n) for (int i = 1; i <= (int)(n); ++i)
#define forab(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
#define forba(i, b, a) for (int i = (int)(b); i >= (int)(a); --i)
#define forv(i, v) rep(i, SZ(v))
#define forit(i, s) for (auto i = (s).begin(); i != (s).end(); ++i)
#define Boost \
ios_base::sync_with_stdio(0); \
cin.tie(0)
#define all(a) (a).begin(), (a).end()
#define SZ(x) ((int)(x).size())
#define F first
#define S second
#define _ << " " <<
#define CS(i) cout << "Case " << (int)(i) << ": "
const int MOD = 1e9 + 7;
const int inf = 1e9 + 9;
const long long INF = 1e18 + 3;
const ld eps = 1e-9;
const ld PI = acos(-1.0);
const ld E = 2.71828182845904523536;
int main() {
Boost;
// READ("in.txt");
// WRITE("out.txt");
int n, ans = 0, b = 0, a = 0, ba = 0;
cin >> n;
string s[n];
rep(i, n) cin >> s[i];
rep(i, n) {
forv(j, s[i]) {
if (j == SZ(s[i]) - 1)
;
else if (s[i][j] == 'A' && s[i][j + 1] == 'B')
ans++;
}
if (s[i][0] == 'B')
b++;
if (s[i][SZ(s[i]) - 1] == 'A')
a++;
if (s[i][0] == 'B' && s[i][SZ(s[i]) - 1] == 'A')
ba++;
}
// cout<<a _ b _ ba _ ans<<endl;
if (a == b) {
if (a == ba && a > 0)
ans += a - 1;
else
ans += a;
} else
ans += min(a, b);
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 866,998 | 866,999 | u934685914 | cpp |
p03049 | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, ans = 0, A = 0, B = 0, AB = 0;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++) {
cin >> s.at(i);
for (int j = 1; j < s.at(i).size(); j++) {
if (s.at(i).at(j) == 'B' && s.at(i).at(j - 1) == 'A')
ans++;
}
if (s.at(i).at(0) == 'B' && s.at(i).at(s.at(i).size() - 1) == 'A')
AB++;
else if (s.at(i).at(0) == 'B' && s.at(i).at(s.at(i).size() - 1) != 'A')
B++;
else if (s.at(i).at(0) != 'B' && s.at(i).at(s.at(i).size() - 1) == 'A')
A++;
}
if (A == 0 && B == 0 && AB != 0)
cout << ans + AB - 1 << endl;
else
cout << ans + min(A, B) << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, ans = 0, A = 0, B = 0, AB = 0;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++) {
cin >> s.at(i);
for (int j = 1; j < s.at(i).size(); j++) {
if (s.at(i).at(j) == 'B' && s.at(i).at(j - 1) == 'A')
ans++;
}
if (s.at(i).at(0) == 'B' && s.at(i).at(s.at(i).size() - 1) == 'A')
AB++;
else if (s.at(i).at(0) == 'B' && s.at(i).at(s.at(i).size() - 1) != 'A')
B++;
else if (s.at(i).at(0) != 'B' && s.at(i).at(s.at(i).size() - 1) == 'A')
A++;
}
if (A == 0 && B == 0 && AB != 0)
cout << ans + AB - 1 << endl;
else
cout << ans + AB + min(A, B) << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 867,008 | 867,009 | u050045886 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define For(i, a, b) for (int i = (a); i <= static_cast<int>(b); i++)
#define Forr(i, a, b) for (int i = (a); i >= static_cast<int>(b); i--)
#define rep(i, n) For(i, 0, n - 1)
#define repall(i, arr) for (auto &i : (arr))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define dump(x) cerr << #x << " = " << (x) << '\n'
#define dump2(x, y) \
cerr << #x << " = " << (x) << " " << #y << " = " << (y) << '\n'
template <typename T> using pq = priority_queue<T>;
template <typename T> using pqr = priority_queue<T, vector<T>, greater<T>>;
const int INF = LLONG_MAX / 2;
constexpr int MOD = 1e9 + 7;
using P = pair<int, int>;
using vec = vector<int>;
using mat = vector<vec>;
template <typename T1, typename T2>
ostream &operator<<(ostream &stream, const pair<T1, T2> &p) {
return stream << p.first << " " << p.second;
}
template <typename T> void print(const vector<vector<T>> matrix) {
repall(vec, matrix) print(vec);
}
template <typename T> void print(const vector<T> vec) {
unsigned int len = vec.size();
rep(i, len - 1) cout << vec[i] << ' ';
cout << vec[len - 1] << '\n';
}
template <typename Arg> void print(const Arg arg) { cout << arg << '\n'; }
template <typename Head, typename... Args>
void print(const Head head, const Args... args) {
cout << head << " ";
print(args...);
}
template <typename T> T sum_(vector<T> vec, T init = 0) {
return std::accumulate(all(vec), T(init));
}
void yn(bool tf) { print(tf ? "Yes" : "No"); }
void YN(bool tf) { print(tf ? "YES" : "NO"); }
template <typename T> void init(vector<T> &v) { rep(i, v.size()) cin >> v[i]; }
template <typename T, typename U> void init(vector<T> &v, vector<U> &w) {
assert(v.size() == w.size());
rep(i, v.size()) cin >> v[i] >> w[i];
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
// -------------------------------------------------------------------
// sort 1 2 3 4
// pqr 1 2 3 must impl >
int in(string s) {
int cnt = 0;
rep(i, s.length() - 1) if (s.substr(i, 2) == "AB") cnt++;
return cnt;
}
signed main() {
cin.tie(0), cout.tie(0), ios::sync_with_stdio(false);
int N;
cin >> N;
vector<string> s(N);
rep(i, N) cin >> s[i];
int inlin = 0;
int a = 0, b = 0, ab = 0;
rep(i, N) {
bool frontb = s[i][0] == 'B';
bool backa = s[i].back() == 'A';
if (frontb and backa)
ab++;
else if (frontb)
b++;
else if (backa)
a++;
inlin += in(s[i]);
}
print(inlin + (a + b == 0 ? ab - 1 : ab + min(a, b)));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define For(i, a, b) for (int i = (a); i <= static_cast<int>(b); i++)
#define Forr(i, a, b) for (int i = (a); i >= static_cast<int>(b); i--)
#define rep(i, n) For(i, 0, n - 1)
#define repall(i, arr) for (auto &i : (arr))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define dump(x) cerr << #x << " = " << (x) << '\n'
#define dump2(x, y) \
cerr << #x << " = " << (x) << " " << #y << " = " << (y) << '\n'
template <typename T> using pq = priority_queue<T>;
template <typename T> using pqr = priority_queue<T, vector<T>, greater<T>>;
const int INF = LLONG_MAX / 2;
constexpr int MOD = 1e9 + 7;
using P = pair<int, int>;
using vec = vector<int>;
using mat = vector<vec>;
template <typename T1, typename T2>
ostream &operator<<(ostream &stream, const pair<T1, T2> &p) {
return stream << p.first << " " << p.second;
}
template <typename T> void print(const vector<vector<T>> matrix) {
repall(vec, matrix) print(vec);
}
template <typename T> void print(const vector<T> vec) {
unsigned int len = vec.size();
rep(i, len - 1) cout << vec[i] << ' ';
cout << vec[len - 1] << '\n';
}
template <typename Arg> void print(const Arg arg) { cout << arg << '\n'; }
template <typename Head, typename... Args>
void print(const Head head, const Args... args) {
cout << head << " ";
print(args...);
}
template <typename T> T sum_(vector<T> vec, T init = 0) {
return std::accumulate(all(vec), T(init));
}
void yn(bool tf) { print(tf ? "Yes" : "No"); }
void YN(bool tf) { print(tf ? "YES" : "NO"); }
template <typename T> void init(vector<T> &v) { rep(i, v.size()) cin >> v[i]; }
template <typename T, typename U> void init(vector<T> &v, vector<U> &w) {
assert(v.size() == w.size());
rep(i, v.size()) cin >> v[i] >> w[i];
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
// -------------------------------------------------------------------
// sort 1 2 3 4
// pqr 1 2 3 must impl >
int in(string s) {
int cnt = 0;
rep(i, s.length() - 1) if (s.substr(i, 2) == "AB") cnt++;
return cnt;
}
signed main() {
cin.tie(0), cout.tie(0), ios::sync_with_stdio(false);
int N;
cin >> N;
vector<string> s(N);
rep(i, N) cin >> s[i];
int inlin = 0;
int a = 0, b = 0, ab = 0;
rep(i, N) {
bool frontb = s[i][0] == 'B';
bool backa = s[i].back() == 'A';
if (frontb and backa)
ab++;
else if (frontb)
b++;
else if (backa)
a++;
inlin += in(s[i]);
}
print(inlin + (a + b == 0 ? max(ab - 1, 0LL) : ab + min(a, b)));
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 867,010 | 867,011 | u771524928 | cpp |
p03049 | #include <cstdio>
#include <cstring>
using namespace std;
char s[20];
inline int min(int a, int b) { return a < b ? a : b; }
int main() {
int n;
scanf("%d", &n);
int a = 0, b = 0, ans = 0;
int temp = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", s);
int len = strlen(s);
if (s[0] == 'B')
b++;
if (s[len - 1] == 'A')
a++;
if (s[0] == 'B' && s[len - 1] == 'A')
temp++;
for (int i = 0; i < len - 1; i++) {
if (s[i] == 'A' && s[i + 1] == 'B')
ans++;
}
}
if (a == b && temp == a)
a--;
else
a = min(a, b);
printf("%d\n", ans + a);
return 0;
} | #include <cstdio>
#include <cstring>
using namespace std;
char s[20];
inline int min(int a, int b) { return a < b ? a : b; }
int main() {
int n;
scanf("%d", &n);
int a = 0, b = 0, ans = 0;
int temp = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", s);
int len = strlen(s);
if (s[0] == 'B')
b++;
if (s[len - 1] == 'A')
a++;
if (s[0] == 'B' && s[len - 1] == 'A')
temp++;
for (int i = 0; i < len - 1; i++) {
if (s[i] == 'A' && s[i + 1] == 'B')
ans++;
}
}
if (a == b && temp == a && a != 0)
a--;
else
a = min(a, b);
printf("%d\n", ans + a);
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 867,017 | 867,018 | u855248478 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define all(v) v.begin(), v.end()
const int mod = 1e9 + 7;
const int inf = 2e9;
const ll linf = 9e18;
//'A' = 65, 'Z' = 90, 'a' = 97, 'z' = 122
int main() {
int n;
cin >> n;
vector<string> s(n);
int a = 0, b = 0, ba = 0;
int ans = 0;
rep(i, 0, n) {
cin >> s[i];
int len = s[i].size();
rep(j, 0, len - 1) {
if (s[i].substr(j, 2) == "AB") {
ans++;
}
}
if (s[i][0] == 'B' && s[i][len - 1] != 'A') {
b++;
}
if (s[i][0] != 'B' && s[i][len - 1] == 'A') {
a++;
}
if (s[i][0] == 'B' && s[i][len - 1] == 'A') {
ba++;
}
}
if (a == 0 && b == 0) {
ans += b - 1;
} else {
ans += min(a + ba, b + ba);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define all(v) v.begin(), v.end()
const int mod = 1e9 + 7;
const int inf = 2e9;
const ll linf = 9e18;
//'A' = 65, 'Z' = 90, 'a' = 97, 'z' = 122
int main() {
int n;
cin >> n;
vector<string> s(n);
int a = 0, b = 0, ba = 0;
int ans = 0;
rep(i, 0, n) {
cin >> s[i];
int len = s[i].size();
rep(j, 0, len - 1) {
if (s[i].substr(j, 2) == "AB") {
ans++;
}
}
if (s[i][0] == 'B' && s[i][len - 1] != 'A') {
b++;
}
if (s[i][0] != 'B' && s[i][len - 1] == 'A') {
a++;
}
if (s[i][0] == 'B' && s[i][len - 1] == 'A') {
ba++;
}
}
if (a == 0 && b == 0) {
ans += max(ba - 1, 0);
} else {
ans += min(a + ba, b + ba);
}
cout << ans << endl;
return 0;
}
| [
"assignment.value.change",
"expression.operation.binary.change",
"call.arguments.add"
] | 867,023 | 867,024 | u214304095 | cpp |
p03049 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long count = 0, countA = 0, countB = 0;
long doublecount = 0;
cin >> n;
vector<string> data(n);
for (int i = 0; i < n; i++) {
cin >> data.at(i);
if (data.at(i).at(0) == 'B') {
countB++;
}
int length = data.at(i).length();
if (data.at(i).at(length - 1) == 'A') {
countA++;
}
if (data.at(i).at(0) == 'B' && data.at(i).at(length - 1) == 'A') {
doublecount++;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < data.at(i).length() - 1; j++) {
if (data.at(i).at(j) == 'A') {
if (data.at(i).at(j + 1) == 'B') {
count++;
}
}
}
}
long sum;
if ((doublecount == countA) && (doublecount == countB)) {
sum = count + doublecount - 1;
} else {
sum = count + min(countA, countB);
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long count = 0, countA = 0, countB = 0;
long doublecount = 0;
cin >> n;
vector<string> data(n);
for (int i = 0; i < n; i++) {
cin >> data.at(i);
if (data.at(i).at(0) == 'B') {
countB++;
}
int length = data.at(i).length();
if (data.at(i).at(length - 1) == 'A') {
countA++;
}
if (data.at(i).at(0) == 'B' && data.at(i).at(length - 1) == 'A') {
doublecount++;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < data.at(i).length() - 1; j++) {
if (data.at(i).at(j) == 'A') {
if (data.at(i).at(j + 1) == 'B') {
count++;
}
}
}
}
long sum;
if ((doublecount > 0) && (doublecount == countA) && (doublecount == countB)) {
sum = count + doublecount - 1;
} else {
sum = count + min(countA, countB);
}
cout << sum << endl;
} | [
"control_flow.branch.if.condition.change"
] | 867,027 | 867,028 | u660258448 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.