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 |
|---|---|---|---|---|---|---|---|
p02959 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
long long int *m;
m = new long long int[n + 1];
for (int i = 0; i < n + 1; i++) {
cin >> m[i];
}
long long int *y;
y = new long long int[n];
for (int i = 0; i < n; i++) {
cin >> y[i];
}
int retval = 0;
for (int i = 0; i < n; i++) {
// i
if (y[i] <= m[i]) {
m[i] -= y[i];
retval += y[i];
y[i] = 0;
} else {
retval += m[i];
y[i] -= m[i];
m[i] = 0;
}
// i+1
if (y[i] <= m[i + 1]) {
retval += y[i];
m[i + 1] -= y[i];
y[i] = 0;
} else {
retval += m[i + 1];
y[i] -= m[i + 1];
m[i + 1] = 0;
}
}
cout << retval << endl;
}
| #include <iostream>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int *m;
m = new long long int[n + 1];
for (int i = 0; i < n + 1; i++) {
cin >> m[i];
}
long long int *y;
y = new long long int[n];
for (int i = 0; i < n; i++) {
cin >> y[i];
}
long long int retval = 0;
for (int i = 0; i < n; i++) {
// i
if (y[i] <= m[i]) {
m[i] -= y[i];
retval += y[i];
y[i] = 0;
continue;
} else {
retval += m[i];
y[i] -= m[i];
m[i] = 0;
}
// i+1
if (y[i] <= m[i + 1]) {
retval += y[i];
m[i + 1] -= y[i];
y[i] = 0;
} else {
retval += m[i + 1];
y[i] -= m[i + 1];
m[i + 1] = 0;
}
}
cout << retval << endl;
}
| [
"variable_declaration.type.widen.change"
] | 769,844 | 769,845 | u781317830 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N + 1];
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
int tmp, kill = 0;
for (int i = 0; i < N; i++) {
cin >> tmp;
if (tmp >= A[i]) {
tmp -= A[i];
if (tmp >= A[i + 1]) {
kill += (A[i] + A[i + 1]);
A[i + 1] = 0;
} else {
A[i + 1] -= tmp;
kill += A[i] + tmp;
}
} else {
kill += tmp;
}
}
cout << kill << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N + 1];
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
long long tmp, kill = 0;
for (int i = 0; i < N; i++) {
cin >> tmp;
if (tmp >= A[i]) {
tmp -= A[i];
if (tmp >= A[i + 1]) {
kill += (A[i] + A[i + 1]);
A[i + 1] = 0;
} else {
A[i + 1] -= tmp;
kill += A[i] + tmp;
}
} else {
kill += tmp;
}
}
cout << kill << "\n";
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 769,846 | 769,847 | u069389947 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
//正なら元の値、負なら０を返す関数
long long ramp(long long x) {
if (x >= 0)
return x;
else
return 0;
}
int main() {
long long n;
cin >> n;
vector<long long> a(n + 1);
for (int i = 0; i < n + 1; i++)
cin >> a[i];
//元のモンスターの数
long long s = accumulate(a.begin(), a.end(), 0);
long long tmp;
for (int i = 0; i < n; i++) {
cin >> tmp;
// i番目の勇者が倒した後のモンスターの数
// ramp(tmp-a[i])が余力
a[i + 1] = ramp(a[i + 1] - ramp(tmp - a[i]));
// a[i]>tmpならa[i]-tmp,それ以外は0
a[i] = ramp(a[i] - tmp);
}
//生き残ったモンスターの数
long long e = accumulate(a.begin(), a.end(), 0);
//元－生き残り＝倒した数
s -= e;
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
//正なら元の値、負なら０を返す関数
long long ramp(long long x) {
if (x >= 0)
return x;
else
return 0;
}
int main() {
long long n;
cin >> n;
vector<long long> a(n + 1);
for (int i = 0; i < n + 1; i++)
cin >> a[i];
//元のモンスターの数
long long s = accumulate(a.begin(), a.end(), 0ll);
long long tmp;
for (int i = 0; i < n; i++) {
cin >> tmp;
// i番目の勇者が倒した後のモンスターの数
// ramp(tmp-a[i])が余力
a[i + 1] = ramp(a[i + 1] - ramp(tmp - a[i]));
// a[i]>tmpならa[i]-tmp,それ以外は0
a[i] = ramp(a[i] - tmp);
}
//生き残ったモンスターの数
long long e = accumulate(a.begin(), a.end(), 0ll);
//元－生き残り＝倒した数
s -= e;
cout << s << endl;
} | [
"call.arguments.change"
] | 769,850 | 769,851 | u320241053 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int n;
long long a[100001], b[100000];
int main() {
cin >> n;
for (int i = 0; i < n + 1; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
cin >> b[i];
long long ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= b[i]) {
ans += b[i];
a[i] -= b[i];
b[i] = 0;
} else {
ans += a[i];
b[i] -= a[i];
a[i] = 0;
}
if (a[i + 1] >= b[i]) {
ans += b[i];
a[i + 1] -= b[i];
b[i] = 0;
} else {
ans += b[i + 1];
b[i] -= a[i + 1];
a[i + 1] = 0;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n;
long long a[100001], b[100000];
int main() {
cin >> n;
for (int i = 0; i < n + 1; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
cin >> b[i];
long long ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= b[i]) {
ans += b[i];
a[i] -= b[i];
b[i] = 0;
} else {
ans += a[i];
b[i] -= a[i];
a[i] = 0;
}
if (a[i + 1] >= b[i]) {
ans += b[i];
a[i + 1] -= b[i];
b[i] = 0;
} else {
ans += a[i + 1];
b[i] -= a[i + 1];
a[i + 1] = 0;
}
}
cout << ans << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change"
] | 769,852 | 769,853 | u265392294 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// container util
#define SORT(c) sort((c).begin(), (c).end())
// repetition
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
int main(void) {
int N;
cin >> N;
vector<int> A(N + 1);
vector<int> B(N);
REP(i, N + 1) cin >> A[i];
REP(i, N) cin >> B[i];
int ans = 0;
REP(i, N) {
// A[i]体の全てのモンスターを倒せる
if (A[i] <= B[i]) {
ans += A[i];
B[i] -= A[i];
}
// 街iのモンスターをB[i]だけ倒せる
else if (A[i] > B[i]) {
ans += B[i];
B[i] = 0;
}
//まだ倒せそうなら街i+1も倒しておく
if (B[i] > 0) {
if (A[i + 1] <= B[i]) {
ans += A[i + 1];
A[i + 1] = 0;
} else {
ans += B[i];
A[i + 1] -= B[i];
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// container util
#define SORT(c) sort((c).begin(), (c).end())
// repetition
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
int main(void) {
int N;
cin >> N;
vector<int> A(N + 1);
vector<int> B(N);
REP(i, N + 1) cin >> A[i];
REP(i, N) cin >> B[i];
ll ans = 0;
REP(i, N) {
// A[i]体の全てのモンスターを倒せる
if (A[i] <= B[i]) {
ans += A[i];
B[i] -= A[i];
}
// 街iのモンスターをB[i]だけ倒せる
else if (A[i] > B[i]) {
ans += B[i];
B[i] = 0;
}
//まだ倒せそうなら街i+1も倒しておく
if (B[i] > 0) {
if (A[i + 1] <= B[i]) {
ans += A[i + 1];
A[i + 1] = 0;
} else {
ans += B[i];
A[i + 1] -= B[i];
}
}
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 769,854 | 769,855 | u594140666 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// container util
#define SORT(c) sort((c).begin(), (c).end())
// repetition
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
int main(void) {
int N;
cin >> N;
vector<int> A(N + 1);
vector<int> B(N);
REP(i, N + 1) cin >> A[i];
REP(i, N) cin >> B[i];
int ans = 0;
REP(i, N) {
if (A[i] <= B[i]) {
ans += A[i];
B[i] -= A[i];
}
if (A[i] > B[i]) {
ans += B[i];
B[i] = 0;
}
if (B[i] > 0) {
if (A[i + 1] <= B[i]) {
ans += A[i + 1];
A[i + 1] = 0;
} else {
ans += B[i];
A[i + 1] -= B[i];
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
// container util
#define SORT(c) sort((c).begin(), (c).end())
// repetition
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
int main(void) {
int N;
cin >> N;
vector<int> A(N + 1);
vector<int> B(N);
REP(i, N + 1) cin >> A[i];
REP(i, N) cin >> B[i];
ll ans = 0;
REP(i, N) {
// A[i]体の全てのモンスターを倒せる
if (A[i] <= B[i]) {
ans += A[i];
B[i] -= A[i];
}
// 街iのモンスターをB[i]だけ倒せる
else if (A[i] > B[i]) {
ans += B[i];
B[i] = 0;
}
//まだ倒せそうなら街i+1も倒しておく
if (B[i] > 0) {
if (A[i + 1] <= B[i]) {
ans += A[i + 1];
A[i + 1] = 0;
} else {
ans += B[i];
A[i + 1] -= B[i];
}
}
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change",
"control_flow.branch.else_if.replace.add",
"control_flow.branch.if.replace.remove"
] | 769,856 | 769,855 | u594140666 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long> A(N + 1);
vector<long> B(N);
for (int i = 0; i < N + 1; i++)
cin >> A.at(i);
for (int i = 0; i < N; i++)
cin >> B.at(i);
long ma[100010];
long mb[100010];
if (A.at(0) + A.at(1) < B.at(0)) {
ma[0] = A.at(0);
mb[0] = A.at(1);
} else if (A.at(0) < B.at(0) && A.at(0) + A.at(1) >= B.at(0)) {
ma[0] = A.at(0);
mb[0] = B.at(0) - A.at(0);
} else if (A.at(0) >= B.at(0)) {
ma[0] = B.at(0);
mb[0] = 0;
}
for (int i = 1; i < N; i++) {
if (A.at(i) + A.at(i + 1) - mb[i - 1] < B.at(i)) {
ma[i] = A.at(i) - mb[i - 1];
mb[i] = A.at(i + 1);
} else if (A.at(i) - mb[i - 1] < B.at(i) &&
A.at(i) + A.at(i + 1) - mb[i - 1] >= B.at(i)) {
ma[i] = A.at(i) - mb[i - 1];
mb[i] = B.at(i) - A.at(i) + mb[i - 1];
} else {
ma[i] = B.at(0);
mb[i] = 0;
}
}
long long X = 0;
for (int i = 0; i < N; i++) {
X += ma[i];
X += mb[i];
}
cout << X << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long> A(N + 1);
vector<long> B(N);
for (int i = 0; i < N + 1; i++)
cin >> A.at(i);
for (int i = 0; i < N; i++)
cin >> B.at(i);
long ma[100010];
long mb[100010];
if (A.at(0) + A.at(1) < B.at(0)) {
ma[0] = A.at(0);
mb[0] = A.at(1);
} else if (A.at(0) < B.at(0) && A.at(0) + A.at(1) >= B.at(0)) {
ma[0] = A.at(0);
mb[0] = B.at(0) - A.at(0);
} else if (A.at(0) >= B.at(0)) {
ma[0] = B.at(0);
mb[0] = 0;
}
for (int i = 1; i < N; i++) {
if (A.at(i) + A.at(i + 1) - mb[i - 1] < B.at(i)) {
ma[i] = A.at(i) - mb[i - 1];
mb[i] = A.at(i + 1);
} else if (A.at(i) - mb[i - 1] < B.at(i) &&
A.at(i) + A.at(i + 1) - mb[i - 1] >= B.at(i)) {
ma[i] = A.at(i) - mb[i - 1];
mb[i] = B.at(i) - A.at(i) + mb[i - 1];
} else {
ma[i] = B.at(i);
mb[i] = 0;
}
}
long long X = 0;
for (int i = 0; i < N; i++) {
X += ma[i];
X += mb[i];
}
cout << X << endl;
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"call.arguments.change"
] | 769,857 | 769,858 | u604231488 | cpp |
p02959 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <tuple>
#define INF INT_MAX >> 1
#define SIZE 100010
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, a, b) for (int i = (a); i < (int)(b); i++)
typedef long long ll;
using namespace std;
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
int main(void) {
int n;
cin >> n;
vector<int> a(n + 1), b(n);
rep(i, n + 1) cin >> a[i];
rep(i, n) cin >> b[i];
int ans = 0;
rep(i, n) {
if (a[i] < b[i]) {
ans += a[i];
b[i] -= a[i];
if (a[i + 1] < b[i]) {
ans += a[i + 1];
a[i + 1] = 0;
} else {
ans += b[i];
a[i + 1] -= b[i];
}
} else {
ans += b[i];
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
//#include <tuple>
#define INF INT_MAX >> 1
#define SIZE 100010
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, a, b) for (int i = (a); i < (int)(b); i++)
typedef long long ll;
using namespace std;
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
int main(void) {
int n;
cin >> n;
vector<int> a(n + 1), b(n);
rep(i, n + 1) cin >> a[i];
rep(i, n) cin >> b[i];
ll ans = 0;
rep(i, n) {
if (a[i] < b[i]) {
ans += a[i];
b[i] -= a[i];
if (a[i + 1] < b[i]) {
ans += a[i + 1];
a[i + 1] = 0;
} else {
ans += b[i];
a[i + 1] -= b[i];
}
} else {
ans += b[i];
}
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 769,860 | 769,861 | u117734686 | cpp |
p02959 | #include <iostream>
using namespace std;
const int N = 1e5 + 5;
int a[N], b[N];
// long long a[1e9],b[1e9];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n + 1; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
long long s = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= b[i]) {
s += b[i];
b[i] = 0;
} else if (a[i] < b[i]) {
if (a[i] + a[i + 1] >= b[i]) {
s += b[i];
a[i + 1] = a[i] + a[i + 1] - b[i];
} else {
s += a[i] + a[i + 1];
a[i + 1] = 0;
}
}
}
printf("%d\n", s);
return 0;
} | #include <iostream>
using namespace std;
const int N = 1e5 + 5;
int a[N], b[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n + 1; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
long long s = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= b[i]) {
s += b[i];
b[i] = 0;
} else if (a[i] < b[i]) {
if (a[i] + a[i + 1] >= b[i]) {
s += b[i];
a[i + 1] = a[i] + a[i + 1] - b[i];
} else {
s += a[i] + a[i + 1];
a[i + 1] = 0;
}
}
}
printf("%lld\n", s);
return 0;
}
| [
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 769,863 | 769,864 | u300768980 | cpp |
p02959 | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
//#include"functions.h"
#define pb push_back
#define pf push_front
#define ppb pop_back
#define mp make_pair
#define np next_permutation
#define fi first
#define sc second
#define vi vector<int>
#define vll vector<long long>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define pff pair<float, float>
#define pdd pair<double, double>
#define psi pair<string, int>
#define pis pair<int, string>
#define ppi pair<pii, int>
#define pdi pair<pii, pii>
#define INF 0x7fffffff
#define LLINF 0x7fffffffffffffff
#define EPS 1e-5
#define LDEPS 1e-9
#define MOD 1000000007
#define E 2.7182818284
#define PI 3.1415926535
#define FOR(a, b) for (int a = 0; a < b; a++)
#define FORN(a, m, n) for (int a = m; a < n; a++)
#define REP(a, m, n) for (int a = 0; a < m; a += n)
#define REPN(a, m, n, p) for (int a = m; a < n; a += p)
#define frestream \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define stdfopen(a, b) \
freopen(a, "r", stdin); \
freopen(b, "w", stdout);
#define ifopen(a) freopen(a, "r", stdin);
#define ofopen(a) freopen(a, "w", stdout);
#define sz(a) a.size()
#define all(a) a.begin(), a.end()
#define MOD 1000000007
typedef long long ll;
typedef long double ld;
using namespace std;
int a[100005];
int b[100005];
int main() {
int n;
int ans = 0, sum = 0;
cin >> n;
for (int i = 0; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
if (a[i] <= b[i]) {
// cout<<a[i+1]<<" "<<i<<endl;
ans += min(b[i] - a[i], a[i + 1]);
a[i + 1] -= (b[i] - a[i]);
if (a[i + 1] < 0)
a[i + 1] = 0;
ans += a[i];
// cout<<a[i]<<endl;
a[i] = 0;
} else {
// cout<<b[i]<<endl;
ans += b[i];
a[i] = a[i] - b[i];
}
}
ans += b[n];
cout << min(ans, sum) << endl;
return 0;
} | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
//#include"functions.h"
#define pb push_back
#define pf push_front
#define ppb pop_back
#define mp make_pair
#define np next_permutation
#define fi first
#define sc second
#define vi vector<int>
#define vll vector<long long>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define pff pair<float, float>
#define pdd pair<double, double>
#define psi pair<string, int>
#define pis pair<int, string>
#define ppi pair<pii, int>
#define pdi pair<pii, pii>
#define INF 0x7fffffff
#define LLINF 0x7fffffffffffffff
#define EPS 1e-5
#define LDEPS 1e-9
#define MOD 1000000007
#define E 2.7182818284
#define PI 3.1415926535
#define FOR(a, b) for (int a = 0; a < b; a++)
#define FORN(a, m, n) for (int a = m; a < n; a++)
#define REP(a, m, n) for (int a = 0; a < m; a += n)
#define REPN(a, m, n, p) for (int a = m; a < n; a += p)
#define frestream \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define stdfopen(a, b) \
freopen(a, "r", stdin); \
freopen(b, "w", stdout);
#define ifopen(a) freopen(a, "r", stdin);
#define ofopen(a) freopen(a, "w", stdout);
#define sz(a) a.size()
#define all(a) a.begin(), a.end()
#define MOD 1000000007
typedef long long ll;
typedef long double ld;
using namespace std;
int a[100005];
int b[100005];
int main() {
int n;
ll ans = 0, sum = 0;
cin >> n;
for (int i = 0; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
if (a[i] <= b[i]) {
// cout<<a[i+1]<<" "<<i<<endl;
ans += min(b[i] - a[i], a[i + 1]);
a[i + 1] -= (b[i] - a[i]);
if (a[i + 1] < 0)
a[i + 1] = 0;
ans += a[i];
// cout<<a[i]<<endl;
a[i] = 0;
} else {
// cout<<b[i]<<endl;
ans += b[i];
a[i] = a[i] - b[i];
}
}
ans += b[n];
cout << min(ans, sum) << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 769,873 | 769,874 | u963646695 | cpp |
p02959 | #include <algorithm>
#include <cmath>
#include <cstdio>
using ll = long long;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
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;
}
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
int main() {
int n;
int a[100001], b[100000];
scanf("%d", &n);
REP(i, n + 1) { scanf("%d", &a[i]); }
REP(i, n) { scanf("%d", &b[i]); }
int sum = 0;
FOR(i, 0, n - 1) {
if (a[i] >= b[i]) {
sum += b[i];
a[i] -= b[i];
b[i] = 0;
} else {
sum += a[i];
b[i] -= a[i];
a[i] = 0;
if (a[i + 1] >= b[i]) {
sum += b[i];
a[i + 1] -= b[i];
b[i] = 0;
} else {
sum += a[i + 1];
a[i + 1] = 0;
b[i] -= a[i + 1];
}
}
}
printf("%d\n", sum);
return (0);
} | #include <algorithm>
#include <cmath>
#include <cstdio>
using ll = long long;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
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;
}
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
int main() {
int n;
int a[100001], b[100000];
scanf("%d", &n);
REP(i, n + 1) { scanf("%d", &a[i]); }
REP(i, n) { scanf("%d", &b[i]); }
ll sum = 0;
FOR(i, 0, n - 1) {
if (a[i] >= b[i]) {
sum += b[i];
a[i] -= b[i];
b[i] = 0;
} else {
sum += a[i];
b[i] -= a[i];
a[i] = 0;
if (a[i + 1] >= b[i]) {
sum += b[i];
a[i + 1] -= b[i];
b[i] = 0;
} else {
sum += a[i + 1];
a[i + 1] = 0;
b[i] -= a[i + 1];
}
}
}
printf("%lld\n", sum);
return (0);
} | [
"variable_declaration.type.change",
"literal.string.change",
"call.arguments.change",
"io.output.change"
] | 769,877 | 769,878 | u410392135 | cpp |
p02959 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
void Solve() {
int n;
cin >> n;
vector<int> a, b;
int buf;
for (auto i = 1; i <= n + 1; ++i) {
cin >> buf;
a.push_back(buf);
}
for (auto i = 1; i <= n; ++i) {
cin >> buf;
b.push_back(buf);
}
auto count = 0;
int r = 0;
for (auto i = 0; i != n; ++i) {
count += min(a[i], r);
int m = max(a[i] - r, 0);
count += min(m, b[i]);
r = max(b[i] - m, 0);
}
count += min(a[n], r);
cout << count << endl;
}
int main() {
Solve();
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
void Solve() {
int n;
cin >> n;
vector<int> a, b;
int buf;
for (auto i = 1; i <= n + 1; ++i) {
cin >> buf;
a.push_back(buf);
}
for (auto i = 1; i <= n; ++i) {
cin >> buf;
b.push_back(buf);
}
auto count = 0LL;
int r = 0;
for (auto i = 0; i != n; ++i) {
count += min(a[i], r);
int m = max(a[i] - r, 0);
count += min(m, b[i]);
r = max(b[i] - m, 0);
}
count += min(a[n], r);
cout << count << endl;
}
int main() {
Solve();
return 0;
}
| [
"literal.number.type.widen.change"
] | 769,879 | 769,880 | u276317406 | cpp |
p02959 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
ll l[200000];
int n;
void solve() {
cin >> n;
for (int i = 0; i <= n; i++)
cin >> l[i];
ll ret = 0;
for (int i = 0; i < n; i++) {
ll dec;
cin >> dec;
ll take = min(take, l[i]);
l[i] -= take;
dec -= take;
ret += take;
take = min(take, l[i + 1]);
l[i + 1] -= take;
dec -= take;
ret += take;
}
cout << ret << "\n";
}
void casesolve() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
cout << "Case #" << i << ": ";
solve();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
// casesolve();
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
ll l[200000];
int n;
void solve() {
cin >> n;
for (int i = 0; i <= n; i++)
cin >> l[i];
ll ret = 0;
for (int i = 0; i < n; i++) {
ll dec;
cin >> dec;
ll take = min(dec, l[i]);
l[i] -= take;
dec -= take;
ret += take;
take = min(dec, l[i + 1]);
l[i + 1] -= take;
dec -= take;
ret += take;
}
cout << ret << "\n";
}
void casesolve() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
cout << "Case #" << i << ": ";
solve();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
// casesolve();
}
| [
"identifier.change",
"call.arguments.change",
"assignment.value.change"
] | 769,881 | 769,882 | u109256064 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1], b[n];
for (int i = 0; i < n + 1; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
cin >> b[i];
int c = 0;
for (int i = 0; i < n; i++) {
if (b[i] > a[i]) {
c += a[i];
b[i] -= a[i];
if (b[i] > a[i + 1]) {
c += a[i + 1];
a[i + 1] = 0;
} else {
c += b[i];
a[i + 1] -= b[i];
}
} else {
c += b[i];
}
}
cout << c << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1], b[n];
for (int i = 0; i < n + 1; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
cin >> b[i];
long long c = 0;
for (int i = 0; i < n; i++) {
if (b[i] > a[i]) {
c += a[i];
b[i] -= a[i];
if (b[i] > a[i + 1]) {
c += a[i + 1];
a[i + 1] = 0;
} else {
c += b[i];
a[i + 1] -= b[i];
}
} else {
c += b[i];
}
}
cout << c << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 769,903 | 769,904 | u888514242 | cpp |
p02959 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
inline ll min(ll a, ll b) { return a < b ? a : b; }
const int Max = 1e5 + 12;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N, A[Max], B[Max], ans = 0;
cin >> N;
for (int i = 1; i <= N + 1; ++i) {
cin >> A[i];
}
for (int i = 1; i <= N; ++i) {
cin >> B[i];
}
int i = N;
while (i >= 1) {
ll V = min(A[i + 1], B[i]);
A[i + 1] -= V;
B[i] -= V;
ans += V;
V = min(A[i], B[i]);
A[i] -= V;
B[i] -= V;
ans += V;
--i;
}
cout << ans;
// system("pause");
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
inline ll min(ll a, ll b) { return a < b ? a : b; }
const int Max = 1e5 + 12;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N, A[Max], B[Max];
ll ans = 0;
cin >> N;
for (ll i = 1; i <= N + 1; ++i) {
cin >> A[i];
}
for (ll i = 1; i <= N; ++i) {
cin >> B[i];
}
int i = N;
while (i >= 1) {
int V = min(A[i + 1], B[i]);
A[i + 1] -= V;
B[i] -= V;
ans += V;
V = min(A[i], B[i]);
A[i] -= V;
B[i] -= V;
ans += V;
--i;
}
cout << ans;
// system("pause");
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.change"
] | 769,907 | 769,908 | u992218377 | cpp |
p02959 | #include <algorithm>
#include <array>
#include <cmath>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
namespace io {
// Input
using IS = istream;
IS &in(IS &i) { return i; }
template <class T, class... Ts> IS &in(IS &i, T &a, Ts &...as) {
return in(i >> a, as...);
}
template <class V> IS &operator>>(IS &i, vector<V> &a) {
for_each(a.begin(), a.end(), [&i](auto &e) { i >> e; });
return i;
}
template <class F, class S> IS &operator>>(IS &i, pair<F, S> const &p) {
return in(p.first, p.second);
}
template <class... Ts, size_t... I>
IS &tuple_in(IS &i, tuple<Ts...> &t, index_sequence<I...>) {
return in(i, get<I>(t)...);
}
template <class... Ts> IS &operator>>(IS &i, tuple<Ts...> &t) {
return tuple_in(i, t, make_index_sequence<sizeof...(Ts)>());
}
// Output
using OS = ostream;
OS &out(OS &o) { return o << endl; }
template <class T> OS &out(OS &o, T const &a) { return o << a << endl; }
template <class T, class... Ts> OS &out(OS &o, T const &a, Ts const &...as) {
return out(o << a << " ", as...);
}
template <class F, class S> OS &operator<<(OS &o, pair<F, S> const &p) {
return o << "(" << p.first << " : " << p.second << ")";
}
template <class... Ts> OS &args_out(OS &o, Ts const &...ts);
OS &args_out(OS &o) { return o; }
template <class T> OS &args_out(OS &o, T const &t) { return o << t; }
template <class T0, class T1, class... Ts>
OS &args_out(OS &o, T0 const &t0, T1 const &t1, Ts const &...ts) {
return args_out(o << t0 << ",", t1, ts...);
}
template <class... Ts, size_t... I>
OS &tuple_out(OS &o, tuple<Ts...> const &t, index_sequence<I...>) {
return args_out(o, get<I>(t)...);
}
template <class... Ts> OS &operator<<(OS &o, tuple<Ts...> const &t) {
return tuple_out(o << "(", t, make_index_sequence<sizeof...(Ts)>()) << ")";
}
template <
class C,
class T = typename iterator_traits<typename C::iterator>::value_type,
typename enable_if<!is_same<C, string>::value, nullptr_t>::type = nullptr>
OS &operator<<(OS &o, C const &a) {
return a.empty() ? (o << "[]") : ([&o, &a]() -> OS & {
o << "[" << *a.begin();
for_each(next(a.begin()), a.end(), [&o](auto const &e) { o << "," << e; });
return o << "]";
}());
}
} // namespace io
template <class... Xs> void input(Xs &...xs) { io::in(cin, xs...); }
template <class... Xs> void print(Xs const &...xs) { io::out(cout, xs...); }
#ifdef JUMPAKU_DEBUG
template <class... Xs> void debug(Xs const &...xs) { io::out(cout, xs...); }
#else
template <class... Xs> void debug(Xs const &...xs) {}
#endif
// Hash
namespace hashcode {
template <class... Ts> size_t hash_args(size_t h, Ts const &...ts);
size_t hash_args(size_t h) { return h; }
template <class T, class... Ts>
size_t hash_args(size_t h, T const &t, Ts const &...ts) {
return hash_args(h * 31 + hash<T>{}(t), ts...);
}
template <class... Ts, size_t... I>
size_t hash_tuple(tuple<Ts...> const &t, index_sequence<I...>) {
return hash_args(17, get<I>(t)...);
}
} // namespace hashcode
namespace std {
template <class... Ts> struct hash<tuple<Ts...>> {
size_t operator()(tuple<Ts...> const &t) const {
return hashcode::hash_tuple(t, index_sequence_for<Ts...>());
}
};
template <class T> struct hash<unordered_set<T>> {
size_t operator()(unordered_set<T> const &s) const {
return accumulate(s.begin(), s.end(), 0, [](auto const &a, auto const &e) {
return a + hash<T>{}(e);
});
}
};
} // namespace std
// Types
using ll = long long int;
// Range
vector<ll> range(ll const &begin, ll const &end) {
vector<ll> ret(max(0LL, end - begin));
iota(ret.begin(), ret.end(), begin);
return ret;
}
vector<ll> range(ll const &end) { return range(0, end); }
template <class T = ll> vector<T> vec(size_t n, T &&init = T()) {
return vector<T>(n, init);
}
template <class Itr, class T = typename iterator_traits<Itr>::value_type>
vector<T> vec(Itr begin, Itr end) {
return vector<T>(begin, end);
}
// MOD
ll gcd(ll p, ll q) { return (q == 0) ? p : gcd(q, p % q); }
ll pow(ll a, ll n, ll m) {
if (n == 0)
return 1;
if (n & 1)
return ((a % m) * pow(a, n - 1, m)) % m;
auto b = pow(a, n / 2, m);
return (b * b) % m;
}
ll inv(ll a, ll p) { return pow(a, p - 2, p); }
constexpr ll MOD = 1e9 + 7;
#include <cassert>
int main() {
ll N;
input(N);
auto A = vec(N + 1);
auto B = vec(N);
input(A, B);
debug(N, A, B);
auto ans = 0;
auto idx = range(N);
for_each(idx.begin(), idx.end(), [&ans, &A, &B](auto i) {
auto rm0 = min(A[i], B[i]);
A[i] -= rm0;
B[i] -= rm0;
assert(A[i] >= 0 && B[i] >= 0);
auto rm1 = min(A[i + 1], B[i]);
A[i + 1] -= rm1;
B[i] -= rm1;
assert(A[i + 1] >= 0 && B[i] >= 0);
ans += rm0 + rm1;
});
print(ans);
}
| #include <algorithm>
#include <array>
#include <cmath>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
namespace io {
// Input
using IS = istream;
IS &in(IS &i) { return i; }
template <class T, class... Ts> IS &in(IS &i, T &a, Ts &...as) {
return in(i >> a, as...);
}
template <class V> IS &operator>>(IS &i, vector<V> &a) {
for_each(a.begin(), a.end(), [&i](auto &e) { i >> e; });
return i;
}
template <class F, class S> IS &operator>>(IS &i, pair<F, S> const &p) {
return in(p.first, p.second);
}
template <class... Ts, size_t... I>
IS &tuple_in(IS &i, tuple<Ts...> &t, index_sequence<I...>) {
return in(i, get<I>(t)...);
}
template <class... Ts> IS &operator>>(IS &i, tuple<Ts...> &t) {
return tuple_in(i, t, make_index_sequence<sizeof...(Ts)>());
}
// Output
using OS = ostream;
OS &out(OS &o) { return o << endl; }
template <class T> OS &out(OS &o, T const &a) { return o << a << endl; }
template <class T, class... Ts> OS &out(OS &o, T const &a, Ts const &...as) {
return out(o << a << " ", as...);
}
template <class F, class S> OS &operator<<(OS &o, pair<F, S> const &p) {
return o << "(" << p.first << " : " << p.second << ")";
}
template <class... Ts> OS &args_out(OS &o, Ts const &...ts);
OS &args_out(OS &o) { return o; }
template <class T> OS &args_out(OS &o, T const &t) { return o << t; }
template <class T0, class T1, class... Ts>
OS &args_out(OS &o, T0 const &t0, T1 const &t1, Ts const &...ts) {
return args_out(o << t0 << ",", t1, ts...);
}
template <class... Ts, size_t... I>
OS &tuple_out(OS &o, tuple<Ts...> const &t, index_sequence<I...>) {
return args_out(o, get<I>(t)...);
}
template <class... Ts> OS &operator<<(OS &o, tuple<Ts...> const &t) {
return tuple_out(o << "(", t, make_index_sequence<sizeof...(Ts)>()) << ")";
}
template <
class C,
class T = typename iterator_traits<typename C::iterator>::value_type,
typename enable_if<!is_same<C, string>::value, nullptr_t>::type = nullptr>
OS &operator<<(OS &o, C const &a) {
return a.empty() ? (o << "[]") : ([&o, &a]() -> OS & {
o << "[" << *a.begin();
for_each(next(a.begin()), a.end(), [&o](auto const &e) { o << "," << e; });
return o << "]";
}());
}
} // namespace io
template <class... Xs> void input(Xs &...xs) { io::in(cin, xs...); }
template <class... Xs> void print(Xs const &...xs) { io::out(cout, xs...); }
#ifdef JUMPAKU_DEBUG
template <class... Xs> void debug(Xs const &...xs) { io::out(cout, xs...); }
#else
template <class... Xs> void debug(Xs const &...xs) {}
#endif
// Hash
namespace hashcode {
template <class... Ts> size_t hash_args(size_t h, Ts const &...ts);
size_t hash_args(size_t h) { return h; }
template <class T, class... Ts>
size_t hash_args(size_t h, T const &t, Ts const &...ts) {
return hash_args(h * 31 + hash<T>{}(t), ts...);
}
template <class... Ts, size_t... I>
size_t hash_tuple(tuple<Ts...> const &t, index_sequence<I...>) {
return hash_args(17, get<I>(t)...);
}
} // namespace hashcode
namespace std {
template <class... Ts> struct hash<tuple<Ts...>> {
size_t operator()(tuple<Ts...> const &t) const {
return hashcode::hash_tuple(t, index_sequence_for<Ts...>());
}
};
template <class T> struct hash<unordered_set<T>> {
size_t operator()(unordered_set<T> const &s) const {
return accumulate(s.begin(), s.end(), 0, [](auto const &a, auto const &e) {
return a + hash<T>{}(e);
});
}
};
} // namespace std
// Types
using ll = long long int;
// Range
vector<ll> range(ll const &begin, ll const &end) {
vector<ll> ret(max(0LL, end - begin));
iota(ret.begin(), ret.end(), begin);
return ret;
}
vector<ll> range(ll const &end) { return range(0, end); }
template <class T = ll> vector<T> vec(size_t n, T &&init = T()) {
return vector<T>(n, init);
}
template <class Itr, class T = typename iterator_traits<Itr>::value_type>
vector<T> vec(Itr begin, Itr end) {
return vector<T>(begin, end);
}
// MOD
ll gcd(ll p, ll q) { return (q == 0) ? p : gcd(q, p % q); }
ll pow(ll a, ll n, ll m) {
if (n == 0)
return 1;
if (n & 1)
return ((a % m) * pow(a, n - 1, m)) % m;
auto b = pow(a, n / 2, m);
return (b * b) % m;
}
ll inv(ll a, ll p) { return pow(a, p - 2, p); }
constexpr ll MOD = 1e9 + 7;
#include <cassert>
int main() {
ll N;
input(N);
auto A = vec(N + 1);
auto B = vec(N);
input(A, B);
debug(N, A, B);
auto ans = 0LL;
auto idx = range(N);
for_each(idx.begin(), idx.end(), [&ans, &A, &B](auto i) {
auto rm0 = min(A[i], B[i]);
A[i] -= rm0;
B[i] -= rm0;
assert(A[i] >= 0 && B[i] >= 0);
auto rm1 = min(A[i + 1], B[i]);
A[i + 1] -= rm1;
B[i] -= rm1;
assert(A[i + 1] >= 0 && B[i] >= 0);
ans += rm0 + rm1;
});
print(ans);
}
| [
"literal.number.type.widen.change"
] | 769,911 | 769,912 | u465699806 | cpp |
p02959 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1), b(n);
rep(i, n + 1) cin >> a[i];
rep(i, n) cin >> b[i];
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
int c = std::min(b[i], a[i + 1]);
ans += c;
b[i] -= c;
a[i + 1] -= c;
c = std::min(b[i], a[i]);
ans += c;
b[i] -= c;
a[i] -= c;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1), b(n);
rep(i, n + 1) cin >> a[i];
rep(i, n) cin >> b[i];
long ans = 0;
for (int i = n - 1; i >= 0; i--) {
int c = std::min(b[i], a[i + 1]);
ans += c;
b[i] -= c;
a[i + 1] -= c;
c = std::min(b[i], a[i]);
ans += c;
b[i] -= c;
a[i] -= c;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change"
] | 769,913 | 769,914 | u793801197 | cpp |
p02959 | #include <bits/stdc++.h>
#define REP(i, n) for (decltype(n) i = 0; i < n; i++)
#define ALL(c) c.begin(), c.end()
#define SORT(c) std::sort(ALL(c))
#define RSORT(c) std::sort(ALL(c), std::greater<decltype(c)::value_type>())
using namespace std;
using ll = long long;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9 + 1;
const ll LINF = (ll)1e18 + 1;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
std::cin >> N;
vector<int> A(N + 1), B(N);
REP(i, N + 1) { std::cin >> A[i]; }
REP(i, N) { std::cin >> B[i]; }
B.push_back(0);
int ans = 0;
int carry = 0;
REP(i, N + 1) {
ans += min(A[i], carry + B[i]);
carry = max(B[i] - max(A[i] - carry, 0), 0);
}
std::cout << ans << std::endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (decltype(n) i = 0; i < n; i++)
#define ALL(c) c.begin(), c.end()
#define SORT(c) std::sort(ALL(c))
#define RSORT(c) std::sort(ALL(c), std::greater<decltype(c)::value_type>())
using namespace std;
using ll = long long;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9 + 1;
const ll LINF = (ll)1e18 + 1;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
std::cin >> N;
vector<ll> A(N + 1), B(N);
REP(i, N + 1) { std::cin >> A[i]; }
REP(i, N) { std::cin >> B[i]; }
B.push_back(0);
ll ans = 0;
ll carry = 0;
REP(i, N + 1) {
ans += min(A[i], carry + B[i]);
carry = max(B[i] - max(A[i] - carry, 0LL), 0LL);
}
std::cout << ans << std::endl;
return 0;
}
| [
"variable_declaration.type.change",
"literal.number.type.widen.change"
] | 769,915 | 769,916 | u403800404 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> b(n + 1);
for (int i = 0; i < n + 1; i++)
cin >> a.at(i);
for (int i = 0; i < n; i++)
cin >> b.at(i);
b.at(n) = 0;
int x = 0, tmp = 0;
x += min(a.at(0), b.at(0));
tmp = max(0, b.at(0) - a.at(0));
for (int i = 1; i < n + 1; i++) {
x += min(a.at(i), b.at(i) + tmp);
tmp = max(0, b.at(i) - max(0, a.at(i) - tmp));
}
cout << x;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> b(n + 1);
for (int i = 0; i < n + 1; i++)
cin >> a.at(i);
for (int i = 0; i < n; i++)
cin >> b.at(i);
b.at(n) = 0;
int64_t x = 0;
int tmp = 0;
x += min(a.at(0), b.at(0));
tmp = max(0, b.at(0) - a.at(0));
for (int i = 1; i < n + 1; i++) {
x += min(a.at(i), b.at(i) + tmp);
tmp = max(0, b.at(i) - max(0, a.at(i) - tmp));
}
cout << x;
}
| [
"variable_declaration.type.primitive.change"
] | 769,919 | 769,920 | u059207724 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 2);
vector<int> b(n + 1);
for (int i = 0; i < n + 1; i++)
cin >> a.at(i);
for (int i = 0; i < n; i++)
cin >> b.at(i);
a.at(n + 1) = 0;
b.at(n) = 0;
int x = 0, tmp1 = 0, tmp2 = 0;
tmp1 = min(a.at(0), b.at(0));
x += tmp1;
tmp2 = min(a.at(1), b.at(0) - tmp1);
x += tmp2;
for (int i = 1; i < n + 1; i++) {
tmp1 = min(a.at(i) - tmp2, b.at(i));
x += tmp1;
tmp2 = min(a.at(i + 1), b.at(i) - tmp1);
x += tmp2;
}
cout << x;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 2);
vector<int> b(n + 1);
for (int i = 0; i < n + 1; i++)
cin >> a.at(i);
for (int i = 0; i < n; i++)
cin >> b.at(i);
a.at(n + 1) = 0;
b.at(n) = 0;
int64_t x = 0;
int tmp1 = 0, tmp2 = 0;
tmp1 = min(a.at(0), b.at(0));
x += tmp1;
tmp2 = min(a.at(1), b.at(0) - tmp1);
x += tmp2;
for (int i = 1; i < n + 1; i++) {
tmp1 = min(a.at(i) - tmp2, b.at(i));
x += tmp1;
tmp2 = min(a.at(i + 1), b.at(i) - tmp1);
x += tmp2;
}
cout << x;
}
| [
"variable_declaration.type.primitive.change"
] | 769,921 | 769,922 | u059207724 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1], b[n];
for (int i = 0; i < n + 1; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
double max = 0;
if (b[0] <= a[0]) {
max += b[0];
b[0] = 0;
} else {
max += a[0];
b[0] -= a[0];
}
// a[0~n-1]
for (int i = 1; i < n; i++) {
if (b[i - 1] <= a[i]) { // a[i]が余る
max += b[i - 1];
a[i] -= b[i - 1];
if (b[i] <= a[i]) {
max += b[i];
b[i] = 0;
} else {
max += a[i];
b[i] -= a[i];
}
} else { // a[i]が余らない
max += a[i];
}
}
if (b[n - 1] <= a[n]) {
max += b[n - 1];
} else {
max += a[n];
}
cout << max << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1], b[n];
for (int i = 0; i < n + 1; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
long int max = 0;
if (b[0] <= a[0]) {
max += b[0];
b[0] = 0;
} else {
max += a[0];
b[0] -= a[0];
}
// a[0~n-1]
for (int i = 1; i < n; i++) {
if (b[i - 1] <= a[i]) { // a[i]が余る
max += b[i - 1];
a[i] -= b[i - 1];
if (b[i] <= a[i]) {
max += b[i];
b[i] = 0;
} else {
max += a[i];
b[i] -= a[i];
}
} else { // a[i]が余らない
max += a[i];
}
}
if (b[n - 1] <= a[n]) {
max += b[n - 1];
} else {
max += a[n];
}
cout << max << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 769,928 | 769,929 | u779636842 | cpp |
p02959 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vCityMonster(N + 1, 0);
for (int i = 0; i < N + 1; i++) {
cin >> vCityMonster[i];
}
vector<int> vKONum(N, 0);
for (int i = 0; i < N; i++) {
cin >> vKONum[i];
}
int KONum = 0;
for (int i = 0; i < N; i++) {
// 左を全力で倒す
int deathL = min(vKONum[i], vCityMonster[i]);
KONum += deathL;
vCityMonster[i] -= deathL;
vKONum[i] -= deathL;
// 右を全力で倒す
int deathR = min(vKONum[i], vCityMonster[i + 1]);
KONum += deathR;
vCityMonster[i + 1] -= deathR;
vKONum[i] -= deathR;
}
cout << KONum << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> vCityMonster(N + 1, 0);
for (int i = 0; i < N + 1; i++) {
cin >> vCityMonster[i];
}
vector<int> vKONum(N, 0);
for (int i = 0; i < N; i++) {
cin >> vKONum[i];
}
long KONum = 0;
for (int i = 0; i < N; i++) {
// 左を全力で倒す
int deathL = min(vKONum[i], vCityMonster[i]);
KONum += deathL;
vCityMonster[i] -= deathL;
vKONum[i] -= deathL;
// 右を全力で倒す
int deathR = min(vKONum[i], vCityMonster[i + 1]);
KONum += deathR;
vCityMonster[i + 1] -= deathR;
vKONum[i] -= deathR;
}
cout << KONum << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 769,930 | 769,931 | u376998218 | cpp |
p02959 | #include <algorithm>
#include <iostream>
#include <iterator>
#include <queue>
#include <set>
using namespace std;
int N;
int A[100001];
int _A[100001];
int B[100000];
int _B[100000];
int rsol(int *a, int *b) {
long long int res = 0;
for (int i = N - 1; i >= 0; --i) {
int k2 = min(b[i], a[i + 1]);
res += k2;
int k1 = min(a[i], b[i] - k2);
res += k1;
a[i] -= k1;
}
return res;
}
int lsol(int *a, int *b) {
long long int res = 0;
for (int i = 0; i < N; ++i) {
int k1 = min(b[i], a[i]);
res += k1;
int k2 = min(a[i + 1], b[i] - k1);
res += k2;
a[i + 1] -= k2;
}
return res;
}
int main() {
cin >> N;
for (int i = 0; i < N + 1; ++i) {
cin >> A[i];
}
for (int i = 0; i < N + 1; ++i) {
_A[i] = A[i];
}
for (int i = 0; i < N; ++i) {
cin >> B[i];
}
for (int i = 0; i < N; ++i) {
_B[i] = B[i];
}
cout << max(rsol(A, B), lsol(_A, _B)) << endl;
} | #include <algorithm>
#include <iostream>
#include <iterator>
#include <queue>
#include <set>
using namespace std;
int N;
int A[100001];
int _A[100001];
int B[100000];
int _B[100000];
long long int rsol(int *a, int *b) {
long long int res = 0;
for (int i = N - 1; i >= 0; --i) {
int k2 = min(b[i], a[i + 1]);
res += k2;
int k1 = min(a[i], b[i] - k2);
res += k1;
a[i] -= k1;
}
return res;
}
long long int lsol(int *a, int *b) {
long long int res = 0;
for (int i = 0; i < N; ++i) {
int k1 = min(b[i], a[i]);
res += k1;
int k2 = min(a[i + 1], b[i] - k1);
res += k2;
a[i + 1] -= k2;
}
return res;
}
int main() {
cin >> N;
for (int i = 0; i < N + 1; ++i) {
cin >> A[i];
}
for (int i = 0; i < N + 1; ++i) {
_A[i] = A[i];
}
for (int i = 0; i < N; ++i) {
cin >> B[i];
}
for (int i = 0; i < N; ++i) {
_B[i] = B[i];
}
cout << max(rsol(A, B), lsol(_A, _B)) << endl;
} | [
"variable_declaration.type.widen.change"
] | 769,936 | 769,937 | u585670083 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N + 1], B[N];
for (int i = 0; i <= N; i++)
cin >> A[i];
for (int i = 0; i < N; i++)
cin >> B[i];
int ans = 0;
for (int i = 0; i < N; i++) {
if (B[i] <= A[i] + A[i + 1]) {
ans += B[i];
if (B[i] <= A[i]) {
A[i + 1] = A[i + 1];
} else {
A[i + 1] = A[i] + A[i + 1] - B[i];
}
} else {
ans += A[i] + A[i + 1];
A[i + 1] = 0;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N + 1], B[N];
for (int i = 0; i <= N; i++)
cin >> A[i];
for (int i = 0; i < N; i++)
cin >> B[i];
long ans = 0;
for (int i = 0; i < N; i++) {
if (B[i] <= A[i] + A[i + 1]) {
ans += B[i];
if (B[i] <= A[i]) {
A[i + 1] = A[i + 1];
} else {
A[i + 1] = A[i] + A[i + 1] - B[i];
}
} else {
ans += A[i] + A[i + 1];
A[i + 1] = 0;
}
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change"
] | 769,940 | 769,941 | u616053863 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N + 1], B[N];
for (int i = 0; i <= N; i++)
cin >> A[i];
for (int i = 0; i < N; i++)
cin >> B[i];
int ans = 0;
for (int i = 0; i < N; i++) {
if (B[i] <= A[i] + A[i + 1]) {
ans += B[i];
if (B[i] < A[i]) {
A[i + 1] = A[i + 1];
} else {
A[i + 1] = A[i] + A[i + 1] - B[i];
}
} else {
ans += A[i] + A[i + 1];
A[i + 1] = 0;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N + 1], B[N];
for (int i = 0; i <= N; i++)
cin >> A[i];
for (int i = 0; i < N; i++)
cin >> B[i];
long ans = 0;
for (int i = 0; i < N; i++) {
if (B[i] <= A[i] + A[i + 1]) {
ans += B[i];
if (B[i] <= A[i]) {
A[i + 1] = A[i + 1];
} else {
A[i + 1] = A[i] + A[i + 1] - B[i];
}
} else {
ans += A[i] + A[i + 1];
A[i + 1] = 0;
}
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 769,942 | 769,941 | u616053863 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N + 1], B[N];
for (int i = 0; i <= N; i++)
cin >> A[i];
for (int i = 0; i < N; i++)
cin >> B[i];
int ans = 0;
for (int i = 0; i < N; i++) {
if (B[i] <= A[i] + A[i + 1]) {
ans += B[i];
if (B[i] <= A[i + 1]) {
A[i + 1] = A[i + 1];
} else {
A[i + 1] = A[i] + A[i + 1] - B[i];
}
} else {
ans += A[i] + A[i + 1];
A[i + 1] = 0;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N + 1], B[N];
for (int i = 0; i <= N; i++)
cin >> A[i];
for (int i = 0; i < N; i++)
cin >> B[i];
long ans = 0;
for (int i = 0; i < N; i++) {
if (B[i] <= A[i] + A[i + 1]) {
ans += B[i];
if (B[i] <= A[i]) {
A[i + 1] = A[i + 1];
} else {
A[i + 1] = A[i] + A[i + 1] - B[i];
}
} else {
ans += A[i] + A[i + 1];
A[i + 1] = 0;
}
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 769,943 | 769,941 | u616053863 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N + 1], B[N];
for (int i = 0; i <= N; i++)
cin >> A[i];
for (int i = 0; i < N; i++)
cin >> B[i];
int ans = 0;
for (int i = 0; i < N; i++) {
if (B[i] <= A[i]) {
ans += B[i];
} else {
if (B[i] <= A[i + 1] + A[i]) {
ans += B[i];
A[i + 1] = A[i + 1] + A[i] - B[i];
} else {
ans += A[i] + A[i + 1];
A[i + 1] = 0;
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int A[N + 1], B[N];
for (int i = 0; i <= N; i++)
cin >> A[i];
for (int i = 0; i < N; i++)
cin >> B[i];
long ans = 0;
for (int i = 0; i < N; i++) {
if (B[i] <= A[i]) {
ans += B[i];
} else {
if (B[i] <= A[i + 1] + A[i]) {
ans += B[i];
A[i + 1] = A[i + 1] + A[i] - B[i];
} else {
ans += A[i] + A[i + 1];
A[i + 1] = 0;
}
}
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change"
] | 769,944 | 769,945 | u616053863 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N + 1);
for (int i = 0; i < N + 1; ++i) {
cin >> A.at(i);
}
vector<int> B(N);
for (int i = 0; i < N; ++i) {
cin >> B.at(i);
}
int result = 0;
for (int i = 0; i < N; ++i) {
if (A.at(i) < B.at(i)) {
result += A.at(i);
int x = B.at(i) - A.at(i);
if (A.at(i + 1) < x) {
result += A.at(i + 1);
A.at(i + 1) = 0;
} else {
result += x;
A.at(i + 1) -= x;
}
} else {
result += B.at(i);
}
}
cout << result << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N + 1);
for (int i = 0; i < N + 1; ++i) {
cin >> A.at(i);
}
vector<int> B(N);
for (int i = 0; i < N; ++i) {
cin >> B.at(i);
}
int64_t result = 0;
for (int i = 0; i < N; ++i) {
if (A.at(i) < B.at(i)) {
result += A.at(i);
int x = B.at(i) - A.at(i);
if (A.at(i + 1) < x) {
result += A.at(i + 1);
A.at(i + 1) = 0;
} else {
result += x;
A.at(i + 1) -= x;
}
} else {
result += B.at(i);
}
}
cout << result << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 769,949 | 769,950 | u842596864 | cpp |
p02959 | #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 INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int inputValue() {
int a;
cin >> a;
return a;
};
void inputArray(int *p, int a){REP(i, a){cin >> p[i];
}
}
;
void inputVector(vector<int> *p, int a) {
REP(i, a) {
int input;
cin >> input;
p->push_back(input);
}
}
int main() {
int N = inputValue();
int A[100001];
int B[100000];
REP(i, N + 1)
A[i] = inputValue();
REP(i, N)
B[i] = inputValue();
int c = 0;
int f1 = 0;
int f2 = 0;
REP(i, N) {
f1 = min(A[i] - f2, B[i]);
c += f1;
f2 = min(A[i + 1], B[i] - f1);
c += f2;
}
cout << c << endl;
}
| #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 INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int inputValue() {
int a;
cin >> a;
return a;
};
void inputArray(int *p, int a){REP(i, a){cin >> p[i];
}
}
;
void inputVector(vector<int> *p, int a) {
REP(i, a) {
int input;
cin >> input;
p->push_back(input);
}
}
int main() {
int N = inputValue();
int A[100001];
int B[100000];
REP(i, N + 1)
A[i] = inputValue();
REP(i, N)
B[i] = inputValue();
ll c = 0;
int f1 = 0;
int f2 = 0;
REP(i, N) {
f1 = min(A[i] - f2, B[i]);
c += f1;
f2 = min(A[i + 1], B[i] - f1);
c += f2;
}
cout << c << endl;
}
| [
"variable_declaration.type.change"
] | 769,956 | 769,957 | u413763374 | cpp |
p02959 | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N + 1);
vector<int> B(N);
int counter = 0;
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
for (int i = 0; i < N; i++) {
if (A[i] >= B[i]) {
counter += B[i];
A[i] -= B[i];
B[i] = 0;
} else {
counter += A[i];
B[i] -= A[i];
A[i] = 0;
}
if (A[i + 1] >= B[i]) {
counter += B[i];
A[i + 1] -= B[i];
B[i] = 0;
} else {
counter += A[i + 1];
B[i] -= A[i + 1];
A[i + 1] = 0;
}
}
cout << counter << endl;
return 0;
}
| #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N + 1);
vector<int> B(N);
long counter = 0;
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
for (int i = 0; i < N; i++) {
if (A[i] >= B[i]) {
counter += B[i];
A[i] -= B[i];
B[i] = 0;
} else {
counter += A[i];
B[i] -= A[i];
A[i] = 0;
}
if (A[i + 1] >= B[i]) {
counter += B[i];
A[i + 1] -= B[i];
B[i] = 0;
} else {
counter += A[i + 1];
B[i] -= A[i + 1];
A[i + 1] = 0;
}
}
cout << counter << endl;
}
| [
"variable_declaration.type.primitive.change"
] | 769,962 | 769,963 | u359453826 | cpp |
p02959 | #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
long A[N + 1];
long B[N];
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
int counter = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
counter += A[j + i];
A[j + i] = 0;
} else {
counter += B[i];
A[j + i] -= B[i];
B[i] = 0;
}
}
}
cout << counter << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
long A[N + 1];
long B[N];
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
long counter = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
counter += A[j + i];
A[j + i] = 0;
} else {
counter += B[i];
A[j + i] -= B[i];
B[i] = 0;
}
}
}
cout << counter << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 769,964 | 769,965 | u359453826 | cpp |
p02959 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, k, n) for (int i = (k); i < (int)(n); i++)
#define all(i, n) (i), (i + n)
int dx4[4] = {1, 0, -1, 0};
int dy4[4] = {0, -1, 0, 1};
int dx8[8] = {1, 0, -1, 1, -1, 1, 0, -1};
int dy8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
typedef pair<int, int> P;
typedef pair<string, int> SP;
typedef long long ll;
const int INF = 1e9;
const ll LLINF = 1e18;
const int MAX_V = 1e6 + 1;
const ll mod = 1000000007;
// --------------------------------------
int n;
int a[100004];
int b[100004];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
REP(i, n + 1) cin >> a[i];
REP(i, n) cin >> b[i];
ll ans = 0;
REP(i, n) {
int sb = min(a[i], b[i]);
b[i] -= sb;
a[i] -= sb;
ans += sb;
sb = min(a[i + 1], b[i]);
b[i] -= sb;
a[i - 1] -= sb;
ans += sb;
}
cout << ans << endl;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, k, n) for (int i = (k); i < (int)(n); i++)
#define all(i, n) (i), (i + n)
int dx4[4] = {1, 0, -1, 0};
int dy4[4] = {0, -1, 0, 1};
int dx8[8] = {1, 0, -1, 1, -1, 1, 0, -1};
int dy8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
typedef pair<int, int> P;
typedef pair<string, int> SP;
typedef long long ll;
const int INF = 1e9;
const ll LLINF = 1e18;
const int MAX_V = 1e6 + 1;
const ll mod = 1000000007;
// --------------------------------------
int n;
int a[100004];
int b[100004];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
REP(i, n + 1) cin >> a[i];
REP(i, n) cin >> b[i];
ll ans = 0;
REP(i, n) {
int sb = min(a[i], b[i]);
b[i] -= sb;
a[i] -= sb;
ans += sb;
sb = min(a[i + 1], b[i]);
b[i] -= sb;
a[i + 1] -= sb;
ans += sb;
}
cout << ans << endl;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 769,966 | 769,967 | u494070244 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int N, kekka;
kekka = 0;
cin >> N;
vector<int> A(N + 1);
vector<int> B(N);
rep(i, N + 1) cin >> A[i];
rep(i, N) cin >> B[i];
rep(i, N) {
if (A[i] >= B[i])
kekka += B[i];
else {
if (A[i] + A[i + 1] >= B[i]) {
kekka += B[i];
A[i + 1] += A[i] - B[i];
} else {
kekka += A[i] + A[i + 1];
A[i + 1] = 0;
}
}
}
cout << kekka << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
long long int N, kekka;
kekka = 0;
cin >> N;
vector<long long int> A(N + 1);
vector<long long int> B(N);
rep(i, N + 1) cin >> A[i];
rep(i, N) cin >> B[i];
rep(i, N) {
if (A[i] >= B[i])
kekka += B[i];
else {
if (A[i] + A[i + 1] >= B[i]) {
kekka += B[i];
A[i + 1] += A[i] - B[i];
} else {
kekka += A[i] + A[i + 1];
A[i + 1] = 0;
}
}
}
cout << kekka << endl;
} | [
"variable_declaration.type.widen.change"
] | 769,968 | 769,969 | u170513117 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
vector<int> a(n + 1), b(n);
for (int i = 0; i < n + 1; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
cin >> b[i];
for (int i = 0; i < n; i++) {
if (a[i] + a[i + 1] >= b[i]) {
ans += b[i];
if (b[i] - a[i] >= 0) {
a[i + 1] = a[i + 1] - (b[i] - a[i]);
a[i] = 0;
} else {
a[i] = a[i] - b[i];
}
b[i] = 0;
} else {
ans += a[i] + a[i + 1];
b[i] -= a[i] + a[i + 1];
a[i] = 0;
a[i + 1] = 0;
}
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, ans = 0;
cin >> n;
vector<int> a(n + 1), b(n);
for (int i = 0; i < n + 1; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
cin >> b[i];
for (int i = 0; i < n; i++) {
if (a[i] + a[i + 1] >= b[i]) {
ans += b[i];
if (b[i] - a[i] >= 0) {
a[i + 1] = a[i + 1] - (b[i] - a[i]);
a[i] = 0;
} else {
a[i] = a[i] - b[i];
}
b[i] = 0;
} else {
ans += a[i] + a[i + 1];
b[i] -= a[i] + a[i + 1];
a[i] = 0;
a[i + 1] = 0;
}
}
cout << ans;
return 0;
} | [
"variable_declaration.type.widen.change"
] | 769,974 | 769,975 | u125051909 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (int i = m; i < (n); i++)
#define ALL(c) (c).begin(), (c).end()
using ll = long long;
const ll mod = 1000000007;
const ll INF = 100000000000000000LL;
signed main() {
int n;
cin >> n;
vector<int> A(n + 1), B(n);
rep(i, n + 1) cin >> A[i];
rep(i, n) cin >> B[i];
int cnt = 0;
rep(i, n) {
if (B[i] >= A[i]) {
cnt += A[i];
B[i] -= A[i];
cnt += min(B[i], A[i + 1]);
A[i + 1] = max(A[i + 1] - B[i], 0);
} else
cnt += B[i];
}
cout << cnt << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (int i = m; i < (n); i++)
#define ALL(c) (c).begin(), (c).end()
using ll = long long;
const ll mod = 1000000007;
const ll INF = 100000000000000000LL;
signed main() {
int n;
cin >> n;
vector<int> A(n + 1), B(n);
rep(i, n + 1) cin >> A[i];
rep(i, n) cin >> B[i];
ll cnt = 0;
rep(i, n) {
if (B[i] >= A[i]) {
cnt += A[i];
B[i] -= A[i];
cnt += min(B[i], A[i + 1]);
A[i + 1] = max(A[i + 1] - B[i], 0);
} else
cnt += B[i];
}
cout << cnt << endl;
} | [
"variable_declaration.type.change"
] | 769,978 | 769,979 | u282228874 | cpp |
p02959 |
#include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <tuple>
#include <vector>
using namespace std;
using lint = long long int;
int main() {
/* 入力処理ここから*/
int N;
int *A, *B;
cin >> N;
A = new int[N + 1];
B = new int[N];
for (int i = 0; i < N + 1; i++) {
int n;
cin >> n;
A[i] = n;
}
for (int i = 0; i < N; i++) {
int n;
cin >> n;
B[i] = n;
}
/*入力処理ここまで*/
int totalMonster = 0; // モンスター討伐数カウンタ
for (int i = 0; i < N; i++) {
int sub = min(A[i], B[i]); // iの町で勇者iが討伐できるモンスターの数
A[i] -=
sub; // iの町から、討伐したモンスターを除く（実際にはこの処理をしなくてもよい）
B[i] -= sub; // 勇者の討伐できる数から、討伐数を除く
totalMonster += sub;
// まだ勇者がモンスターを討伐できる場合
if (B[i] > 0) {
sub = min(A[i + 1], B[i]); // i+1の町で勇者iが討伐できるモンスターの数
A[i + 1] -= sub; // i+1の町から、討伐したモンスターを除く
totalMonster += sub;
}
}
cout << totalMonster << endl;
return 0;
} |
#include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <tuple>
#include <vector>
using namespace std;
using lint = long long int;
int main() {
/* 入力処理ここから*/
int N;
int *A, *B;
cin >> N;
A = new int[N + 1];
B = new int[N];
for (int i = 0; i < N + 1; i++) {
int n;
cin >> n;
A[i] = n;
}
for (int i = 0; i < N; i++) {
int n;
cin >> n;
B[i] = n;
}
/*入力処理ここまで*/
lint totalMonster = 0; // モンスター討伐数カウンタ
for (int i = 0; i < N; i++) {
int sub = min(A[i], B[i]); // iの町で勇者iが討伐できるモンスターの数
A[i] -=
sub; // iの町から、討伐したモンスターを除く（実際にはこの処理をしなくてもよい）
B[i] -= sub; // 勇者の討伐できる数から、討伐数を除く
totalMonster += sub;
// まだ勇者がモンスターを討伐できる場合
if (B[i] > 0) {
sub = min(A[i + 1], B[i]); // i+1の町で勇者iが討伐できるモンスターの数
A[i + 1] -= sub; // i+1の町から、討伐したモンスターを除く
totalMonster += sub;
}
}
cout << totalMonster << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 769,980 | 769,981 | u500855421 | cpp |
p02959 | #include <bits/stdc++.h>
#define rep(i, x, n) for (int i = x; i < n; i++)
typedef long long ll;
const int INF = 1e9 + 7;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> A(n + 1);
rep(i, 0, n + 1) cin >> A[i];
vector<int> B(n);
rep(i, 0, n) cin >> B[i];
int count = 0;
rep(i, 0, n) {
int tmp1 = A[i] - B[i];
if (tmp1 >= 0) {
count += B[i];
continue;
}
count += A[i];
int tmp2 = A[i + 1] - abs(tmp1);
if (tmp2 >= 0) {
count += abs(tmp1);
A[i + 1] -= abs(tmp1);
continue;
}
count += A[i + 1];
A[i + 1] = 0;
}
cout << count << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, x, n) for (int i = x; i < n; i++)
typedef long long ll;
const int INF = 1e9 + 7;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> A(n + 1);
rep(i, 0, n + 1) cin >> A[i];
vector<int> B(n);
rep(i, 0, n) cin >> B[i];
ll count = 0;
rep(i, 0, n) {
int tmp1 = A[i] - B[i];
if (tmp1 >= 0) {
count += B[i];
continue;
}
count += A[i];
int tmp2 = A[i + 1] - abs(tmp1);
if (tmp2 >= 0) {
count += abs(tmp1);
A[i + 1] -= abs(tmp1);
continue;
}
count += A[i + 1];
A[i + 1] = 0;
}
cout << count << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 769,982 | 769,983 | u441723963 | cpp |
p02959 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long N;
long long input;
vector<long long> A;
vector<long long> B;
long long i;
int total = 0;
cin >> N;
for (i = 0; i < N + 1; i++) {
cin >> input;
A.push_back(input);
}
for (i = 0; i < N; i++) {
cin >> input;
B.push_back(input);
}
for (i = 0; i < N; i++) {
if ((A[i] - B[i]) >= 0)
total += B[i];
else {
total += A[i];
if ((A[i + 1] - abs(A[i] - B[i])) >= 0) {
total += abs(A[i] - B[i]);
A[i + 1] -= abs(A[i] - B[i]);
}
else {
total += A[i + 1];
A[i + 1] = 0;
}
}
}
cout << total << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long N;
long long input;
vector<long long> A;
vector<long long> B;
long long i;
long long total = 0;
cin >> N;
for (i = 0; i < N + 1; i++) {
cin >> input;
A.push_back(input);
}
for (i = 0; i < N; i++) {
cin >> input;
B.push_back(input);
}
for (i = 0; i < N; i++) {
if ((A[i] - B[i]) >= 0)
total += B[i];
else {
total += A[i];
if ((A[i + 1] - abs(A[i] - B[i])) >= 0) {
total += abs(A[i] - B[i]);
A[i + 1] -= abs(A[i] - B[i]);
}
else {
total += A[i + 1];
A[i + 1] = 0;
}
}
}
cout << total << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 769,986 | 769,987 | u641446860 | cpp |
p02959 | #include <algorithm>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll MOD = 1e9 + 7;
const double EPS = 1e-9;
int main(int argc, const char *argv[]) {
int N;
cin >> N;
vector<int> A(N + 1), B(N);
for (int i = 0; i <= N; i++)
cin >> A[i];
for (int i = 0; i < N; i++)
cin >> B[i];
int Ar, Br, ans, kill1, kill2;
ans = 0;
Ar = A[0];
for (int i = 0; i < N; i++) {
kill1 = min(Ar, B[i]);
Br = max(0, B[i] - kill1);
kill2 = min(A[i + 1], Br);
Ar = max(0, A[i + 1] - kill2);
ans += kill1 + kill2;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 1 << 30;
const ll MOD = 1e9 + 7;
const double EPS = 1e-9;
int main(int argc, const char *argv[]) {
int N;
cin >> N;
vector<ll> A(N + 1), B(N);
for (int i = 0; i <= N; i++)
cin >> A[i];
for (int i = 0; i < N; i++)
cin >> B[i];
ll Ar, Br, ans, kill1, kill2;
ans = 0;
Ar = A[0];
for (int i = 0; i < N; i++) {
kill1 = min(Ar, B[i]);
Br = max(0LL, B[i] - kill1);
kill2 = min(A[i + 1], Br);
Ar = max(0LL, A[i + 1] - kill2);
ans += kill1 + kill2;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.change",
"literal.number.type.widen.change"
] | 769,992 | 769,993 | u320491590 | cpp |
p02959 | #include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> A(N + 1);
for (int i = 0; i < N + 1; ++i) {
std::cin >> A[i];
}
std::vector<int> B(N);
for (int i = 0; i < N; ++i) {
std::cin >> B[i];
}
int total = 0;
for (int i = 0; i < N; ++i) {
int buf = std::min(A[i], B[i]);
total += buf;
A[i] -= buf;
B[i] -= buf;
buf = std::min(A[i + 1], B[i]);
total += buf;
A[i + 1] -= buf;
B[i] -= buf;
}
std::cout << total << std::endl;
return 0;
} | #include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<int> A(N + 1);
for (int i = 0; i < N + 1; ++i) {
std::cin >> A[i];
}
std::vector<int> B(N);
for (int i = 0; i < N; ++i) {
std::cin >> B[i];
}
long long total = 0;
for (int i = 0; i < N; ++i) {
int buf = std::min(A[i], B[i]);
total += buf;
A[i] -= buf;
B[i] -= buf;
buf = std::min(A[i + 1], B[i]);
total += buf;
A[i + 1] -= buf;
B[i] -= buf;
}
std::cout << total << std::endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 769,998 | 769,999 | u526971181 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int a[100005];
int b[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n + 1; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int sum = 0;
for (int i = 0; i < n; i++) {
if (a[i] > b[i]) {
sum = sum + b[i];
// cout << "1 "<<sum << endl;
a[i] = a[i] - b[i];
b[i] = 0;
if (a[i] > b[i + 1]) {
sum = sum + b[i + 1];
b[i + 1] = 0;
// cout <<"2 "<< sum << endl;
} else {
b[i + 1] = b[i + 1] - a[i];
// cout <<" " <<a[i] <<" "<< b[i+1]<<endl;
sum = sum + a[i];
// cout << "3 "<<sum << endl;
}
} else {
sum = sum + a[i];
b[i] = b[i] - a[i];
a[i] = 0;
// cout <<"4 "<< sum << endl;
}
}
n--;
// if(a[n] > b[n + 1]) sum = sum + b[n + 1];
// else sum = sum + a[n];
cout << sum;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int a[100005];
int b[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n + 1; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
long long sum = 0;
for (int i = 0; i < n; i++) {
if (a[i] > b[i]) {
sum = sum + b[i];
// cout << "1 "<<sum << endl;
a[i] = a[i] - b[i];
b[i] = 0;
if (a[i] > b[i + 1]) {
sum = sum + b[i + 1];
b[i + 1] = 0;
// cout <<"2 "<< sum << endl;
} else {
b[i + 1] = b[i + 1] - a[i];
// cout <<" " <<a[i] <<" "<< b[i+1]<<endl;
sum = sum + a[i];
// cout << "3 "<<sum << endl;
}
} else {
sum = sum + a[i];
b[i] = b[i] - a[i];
a[i] = 0;
// cout <<"4 "<< sum << endl;
}
}
n--;
// if(a[n] > b[n + 1]) sum = sum + b[n + 1];
// else sum = sum + a[n];
cout << sum;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 770,015 | 770,016 | u382002817 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, m, t;
m = 0;
cin >> N;
vector<int> c(N + 2);
vector<int> y(N + 2);
for (int i = 0; i < N + 1; i++) {
cin >> c.at(i);
}
for (int i = 0; i < N; i++) {
cin >> y.at(i);
}
for (int i = 0; i < N + 1; i++) {
if (c.at(i) > y.at(i)) {
m += y.at(i);
}
if (c.at(i) <= y.at(i)) {
m += c.at(i);
t = c.at(i + 1) - (y.at(i) - c.at(i));
if (t < 0) {
m += c.at(i + 1);
c.at(i + 1) = 0;
} else {
m += y.at(i) - c.at(i);
c.at(i + 1) = t;
}
}
}
cout << m << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, t;
long m;
m = 0;
cin >> N;
vector<int> c(N + 2);
vector<int> y(N + 2);
for (int i = 0; i < N + 1; i++) {
cin >> c.at(i);
}
for (int i = 0; i < N; i++) {
cin >> y.at(i);
}
for (int i = 0; i < N + 1; i++) {
if (c.at(i) > y.at(i)) {
m += y.at(i);
}
if (c.at(i) <= y.at(i)) {
m += c.at(i);
t = c.at(i + 1) - (y.at(i) - c.at(i));
if (t < 0) {
m += c.at(i + 1);
c.at(i + 1) = 0;
} else {
m += y.at(i) - c.at(i);
c.at(i + 1) = t;
}
}
}
cout << m << endl;
}
| [
"variable_declaration.remove",
"variable_declaration.add"
] | 770,022 | 770,023 | u413886479 | cpp |
p02959 | #include <iostream>
using namespace std;
int N;
int A[10 * 10 * 10 * 10 * 10 + 1];
int B[10 * 10 * 10 * 10 * 10];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
for (int i = 0; i < N + 1; ++i)
cin >> A[i];
for (int j = 0; j < N; ++j)
cin >> B[j];
int res = 0;
int counter = 0;
int beat = 0;
while (counter <= N - 1) {
if (B[counter] >= A[counter]) {
beat += A[counter];
res = B[counter] - A[counter];
if (res <= A[counter + 1]) {
beat += res;
A[counter + 1] = A[counter + 1] - res;
} else {
beat += A[counter + 1];
A[counter + 1] = 0;
}
} else {
beat += B[counter];
}
counter += 1;
}
cout << beat;
} | #include <iostream>
using namespace std;
int N;
int A[10 * 10 * 10 * 10 * 10 + 1];
int B[10 * 10 * 10 * 10 * 10];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
for (int i = 0; i < N + 1; ++i)
cin >> A[i];
for (int j = 0; j < N; ++j)
cin >> B[j];
int res = 0;
int counter = 0;
long long beat = 0;
while (counter <= N - 1) {
if (B[counter] >= A[counter]) {
beat += A[counter];
res = B[counter] - A[counter];
if (res <= A[counter + 1]) {
beat += res;
A[counter + 1] = A[counter + 1] - res;
} else {
beat += A[counter + 1];
A[counter + 1] = 0;
}
} else {
beat += B[counter];
}
counter += 1;
}
cout << beat;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 770,028 | 770,029 | u696988954 | cpp |
p02959 | #include <iostream>
#include <vector>
using namespace std;
int main() {
/*input*/
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> b(n);
for (int i = 0; i < n + 1; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
/*calculaiton*/
vector<int> tmp(n + 1);
for (int i = 0; i < n; i++) {
int sa = a[i] - tmp[i];
if (b[i] >= sa) {
tmp[i] += sa;
if ((b[i] - sa) >= a[i + 1]) {
tmp[i + 1] = a[i + 1];
} else {
tmp[i + 1] = b[i] - sa;
}
} else {
tmp[i] += b[i];
}
}
int ans = 0;
for (int i = 0; i < n + 1; i++) {
ans += tmp[i];
}
/*output*/
cout << ans << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
/*input*/
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> b(n);
for (int i = 0; i < n + 1; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
/*calculaiton*/
vector<long int> tmp(n + 1);
for (int i = 0; i < n; i++) {
int sa = a[i] - tmp[i];
if (b[i] >= sa) {
tmp[i] += sa;
if ((b[i] - sa) >= a[i + 1]) {
tmp[i + 1] = a[i + 1];
} else {
tmp[i + 1] = b[i] - sa;
}
} else {
tmp[i] += b[i];
}
}
long int ans = 0;
for (int i = 0; i < n + 1; i++) {
ans += tmp[i];
}
/*output*/
cout << ans << endl;
}
| [
"variable_declaration.type.widen.change"
] | 770,035 | 770,036 | u637220270 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> b(n);
rep(i, n + 1) { cin >> a.at(i); }
rep(i, n) { cin >> b.at(i); }
int ans = 0;
rep(i, n) {
int tmp = min(a.at(i), b.at(i));
ans += tmp;
a.at(i) -= tmp;
b.at(i) -= tmp;
tmp = min(a.at(i + 1), b.at(i));
ans += tmp;
a.at(i + 1) -= tmp;
b.at(i) -= tmp;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> b(n);
rep(i, n + 1) { cin >> a.at(i); }
rep(i, n) { cin >> b.at(i); }
long long ans = 0;
rep(i, n) {
int tmp = min(a.at(i), b.at(i));
ans += tmp;
a.at(i) -= tmp;
b.at(i) -= tmp;
tmp = min(a.at(i + 1), b.at(i));
ans += tmp;
a.at(i + 1) -= tmp;
b.at(i) -= tmp;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 770,037 | 770,038 | u413207096 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> b(n);
rep(i, n + 1) { cin >> a.at(i); }
rep(i, n) { cin >> b.at(i); }
int ans;
rep(i, n) {
int tmp = min(a.at(i), b.at(i));
ans += tmp;
a.at(i) -= tmp;
b.at(i) -= tmp;
tmp = min(a.at(i + 1), b.at(i));
ans += tmp;
a.at(i + 1) -= tmp;
b.at(i) -= tmp;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> b(n);
rep(i, n + 1) { cin >> a.at(i); }
rep(i, n) { cin >> b.at(i); }
long long ans = 0;
rep(i, n) {
int tmp = min(a.at(i), b.at(i));
ans += tmp;
a.at(i) -= tmp;
b.at(i) -= tmp;
tmp = min(a.at(i + 1), b.at(i));
ans += tmp;
a.at(i + 1) -= tmp;
b.at(i) -= tmp;
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"variable_declaration.value.change"
] | 770,039 | 770,038 | u413207096 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N + 1);
vector<int> B(N);
for (int i = 0; i < N + 1; i++) {
cin >> A.at(i);
}
int c = 0;
for (int i = 0; i < N; i++) {
cin >> B.at(i);
}
for (int j = 0; j < N; j++) {
if (A.at(j) >= B.at(j)) {
c += B.at(j);
} else {
c += A.at(j);
if (A.at(j + 1) > (B.at(j) - A.at(j))) {
c += B.at(j) - A.at(j);
A.at(j + 1) -= B.at(j) - A.at(j);
} else {
c += A.at(j + 1);
A.at(j + 1) = 0;
}
}
}
cout << c << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N + 1);
vector<int> B(N);
for (int i = 0; i < N + 1; i++) {
cin >> A.at(i);
}
long long int c = 0;
for (int i = 0; i < N; i++) {
cin >> B.at(i);
}
for (int j = 0; j < N; j++) {
if (A.at(j) >= B.at(j)) {
c += B.at(j);
} else {
c += A.at(j);
if (A.at(j + 1) > (B.at(j) - A.at(j))) {
c += B.at(j) - A.at(j);
A.at(j + 1) -= B.at(j) - A.at(j);
} else {
c += A.at(j + 1);
A.at(j + 1) = 0;
}
}
}
cout << c << "\n";
} | [
"variable_declaration.type.widen.change"
] | 770,052 | 770,053 | u602544363 | cpp |
p02959 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
std::vector<int> A(N + 10);
std::vector<int> B(N + 10);
for (int i = 0; i < N + 1; ++i)
cin >> A[i];
for (int i = 0; i < N; ++i)
cin >> B[i];
int attackedMonster = 0;
for (int i = 0; i < N; ++i) {
// A[i]
attackedMonster += min(A[i], B[i]);
// A[i+1]
attackedMonster += min(A[i + 1], max((B[i] - A[i]), 0));
A[i + 1] -= min(A[i + 1], max((B[i] - A[i]), 0));
}
cout << attackedMonster << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
std::vector<int> A(N + 10);
std::vector<int> B(N + 10);
for (int i = 0; i < N + 1; ++i)
cin >> A[i];
for (int i = 0; i < N; ++i)
cin >> B[i];
long attackedMonster = 0;
for (int i = 0; i < N; ++i) {
// A[i]
attackedMonster += min(A[i], B[i]);
// A[i+1]
attackedMonster += min(A[i + 1], max((B[i] - A[i]), 0));
A[i + 1] -= min(A[i + 1], max((B[i] - A[i]), 0));
}
cout << attackedMonster << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 770,054 | 770,055 | u568877271 | cpp |
p02959 | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N + 1);
for (int i = 0; i <= N; ++i) {
cin >> A[i];
}
vector<int> B(N);
for (int i = 0; i < N; ++i) {
cin >> B[i];
}
int ans = 0;
for (int i = N; i > 0; --i) {
if (A[i] + A[i - 1] < B[i - 1]) {
ans += A[i] + A[i - 1];
A[i - 1] = 0;
} else {
ans += B[i - 1];
if (A[i] < B[i - 1]) {
A[i - 1] = A[i] + A[i - 1] - B[i - 1];
}
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N + 1);
for (int i = 0; i <= N; ++i) {
cin >> A[i];
}
vector<int> B(N);
for (int i = 0; i < N; ++i) {
cin >> B[i];
}
long long ans = 0;
for (int i = N; i > 0; --i) {
if (A[i] + A[i - 1] < B[i - 1]) {
ans += A[i] + A[i - 1];
A[i - 1] = 0;
} else {
ans += B[i - 1];
if (A[i] < B[i - 1]) {
A[i - 1] = A[i] + A[i - 1] - B[i - 1];
}
}
}
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 770,060 | 770,061 | u701556979 | cpp |
p02959 | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N + 1);
for (int i = 0; i <= N; ++i) {
cin >> A[i];
}
vector<long long> B(N);
for (int i = 0; i < N; ++i) {
cin >> B[i];
}
int ans = 0;
for (int i = 0; i < N; ++i) {
long long t = min(A[i], B[i]);
A[i] -= t;
B[i] -= t;
ans += t;
t = min(A[i + 1], B[i]);
A[i + 1] -= t;
B[i] -= t;
ans += t;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N + 1);
for (int i = 0; i <= N; ++i) {
cin >> A[i];
}
vector<long long> B(N);
for (int i = 0; i < N; ++i) {
cin >> B[i];
}
long long ans = 0;
for (int i = 0; i < N; ++i) {
long long t = min(A[i], B[i]);
A[i] -= t;
B[i] -= t;
ans += t;
t = min(A[i + 1], B[i]);
A[i + 1] -= t;
B[i] -= t;
ans += t;
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 770,062 | 770,063 | u701556979 | cpp |
p02959 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
// container util
//------------------------------------------
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define REACH(i, c) for (typeof((c).end()) i = (c).end(); i != (c).begin(); --i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).begin(), (c).end(), greater<int>())
#define PB(a) push_back(a)
#define PF(a) pop_front(a)
#define MP(a, b) make_pair(a, b)
#define FS first
#define SE second
#define ALL(x) (x).begin(), (x).end()
#define MAX_EL(c) *max_element((c).begin(), (c).end())
#define MIN_EL(c) *min_element((c).begin(), (c).end())
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<long long> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef string str;
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
//------show vector---------
template <typename T> void showV(vector<T> a) {
EACH(i, a) { cerr << *i << ','; }
cerr << endl;
}
//------show matrix---------
template <typename T> void showVV(vector<vector<T>> a) {
EACH(i, a) { showV(*i); }
}
// grobal var
//------------------------------------------
LL dp[2000][2000];
vector<int> divisor(int n) {
vector<int> ret;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
return (ret);
}
int main() {
// magic spell------------------------------
cin.tie(0);
ios::sync_with_stdio(false);
//------------------------------------------
int N;
cin >> N;
int ans = 0;
VI a(N + 1), b(N);
REP(i, N + 1) { cin >> a[i]; }
REP(i, N) { cin >> b[i]; }
REP(i, N) {
int ca = a[i];
int cb = b[i];
if (ca >= cb) {
ans += cb;
} else {
ans += ca;
int cc = min((cb - ca), a[i + 1]);
a[i + 1] -= cc;
ans += cc;
}
}
cout << ans << endl;
return 0;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
// container util
//------------------------------------------
#define REP(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define REACH(i, c) for (typeof((c).end()) i = (c).end(); i != (c).begin(); --i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).begin(), (c).end(), greater<int>())
#define PB(a) push_back(a)
#define PF(a) pop_front(a)
#define MP(a, b) make_pair(a, b)
#define FS first
#define SE second
#define ALL(x) (x).begin(), (x).end()
#define MAX_EL(c) *max_element((c).begin(), (c).end())
#define MIN_EL(c) *min_element((c).begin(), (c).end())
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<long long> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef string str;
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
//------show vector---------
template <typename T> void showV(vector<T> a) {
EACH(i, a) { cerr << *i << ','; }
cerr << endl;
}
//------show matrix---------
template <typename T> void showVV(vector<vector<T>> a) {
EACH(i, a) { showV(*i); }
}
// grobal var
//------------------------------------------
LL dp[2000][2000];
vector<int> divisor(int n) {
vector<int> ret;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n)
ret.push_back(n / i);
}
}
return (ret);
}
int main() {
// magic spell------------------------------
cin.tie(0);
ios::sync_with_stdio(false);
//------------------------------------------
int N;
cin >> N;
LL ans = 0;
VL a(N + 1), b(N);
REP(i, N + 1) { cin >> a[i]; }
REP(i, N) { cin >> b[i]; }
REP(i, N) {
LL ca = a[i];
LL cb = b[i];
if (ca >= cb) {
ans += cb;
} else {
ans += ca;
LL cc = min((cb - ca), a[i + 1]);
a[i + 1] -= cc;
ans += cc;
}
}
cout << ans << endl;
return 0;
} | [
"variable_declaration.type.change"
] | 770,064 | 770,065 | u513290715 | cpp |
p02959 | #include <bits/stdc++.h>
#include <cstdlib>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1], b[n], t = 0, i;
for (i = 0; i <= n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
cin >> b[i];
}
for (i = 0; i < n; i++) {
if (b[i] <= a[i]) {
t += b[i];
} else if (a[i + 1] <= (b[i] - a[i])) {
t += a[i] + a[i + 1];
a[i + 1] = 0;
} else if (a[i + 1] > (b[i] - a[i])) {
t += b[i];
a[i + 1] = a[i + 1] - (b[i] - a[i]);
}
}
cout << t << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <cstdlib>
using namespace std;
int main() {
int n;
cin >> n;
long long int a[n + 1], b[n], t = 0;
int i;
for (i = 0; i <= n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
cin >> b[i];
}
for (i = 0; i < n; i++) {
if (b[i] <= a[i]) {
t += b[i];
} else if (a[i + 1] <= (b[i] - a[i])) {
t += a[i] + a[i + 1];
a[i + 1] = 0;
} else if (a[i + 1] > (b[i] - a[i])) {
t += b[i];
a[i + 1] = a[i + 1] - (b[i] - a[i]);
}
}
cout << t << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 770,066 | 770,067 | u739265934 | cpp |
p02959 | #include <algorithm>
#include <fstream>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define out(str) cout << str << endl
#define ALL(a) (a).begin(), (a).end()
#define INF (1 << 29)
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;
}
int N, ans;
int main() {
cin >> N;
int A[N + 1], B[N];
rep(i, N + 1) cin >> A[i];
rep(i, N) cin >> B[i];
rep(i, N) {
if (A[i] < B[i]) {
ans += A[i];
B[i] -= A[i];
if (A[i + 1] < B[i]) {
ans += A[i + 1];
A[i + 1] = 0;
} else {
ans += B[i];
A[i + 1] -= B[i];
}
} else {
ans += B[i];
}
}
out(ans);
}
| #include <algorithm>
#include <fstream>
#include <iostream>
#include <limits>
#include <math.h>
#include <numeric>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define out(str) cout << str << endl
#define ALL(a) (a).begin(), (a).end()
#define INF (1 << 29)
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;
}
ll N, ans;
int main() {
cin >> N;
ll A[N + 1], B[N];
rep(i, N + 1) cin >> A[i];
rep(i, N) cin >> B[i];
rep(i, N) {
if (A[i] < B[i]) {
ans += A[i];
B[i] -= A[i];
if (A[i + 1] < B[i]) {
ans += A[i + 1];
A[i + 1] = 0;
} else {
ans += B[i];
A[i + 1] -= B[i];
}
} else {
ans += B[i];
}
}
out(ans);
}
| [
"variable_declaration.type.change"
] | 770,075 | 770,076 | u190907730 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> b(n);
for (int i = 0; i < n + 1; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
cin >> b[i];
int beaten = 0;
for (int i = n; i >= 1; i--) {
int diff = min(a[i], b[i - 1]);
int diff2 = min(a[i - 1], abs(b[i - 1] - diff));
beaten += diff;
beaten += diff2;
a[i - 1] -= diff2;
}
cout << beaten << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> b(n);
for (int i = 0; i < n + 1; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
cin >> b[i];
long long beaten1 = 0;
for (int i = n; i >= 1; i--) {
int diff = min(a[i], b[i - 1]);
int diff2 = min(a[i - 1], abs(b[i - 1] - diff));
beaten1 += diff;
beaten1 += diff2;
a[i - 1] -= diff2;
}
cout << beaten1 << endl;
} | [
"assignment.variable.change",
"identifier.change",
"io.output.change"
] | 770,081 | 770,082 | u436741428 | cpp |
p02959 | #include <algorithm>
#include <cctype>
#include <cstdio>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using f32 = float;
using f64 = double;
using f80 = __float80;
using namespace std;
using LL = long long;
using ULL = unsigned long long;
using vi = vector<int>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvi = vector<vi>;
using vs = vector<string>;
using vl = vector<LL>;
using vvl = vector<vl>;
using P = pair<int, int>;
using T = tuple<int, int, int>;
using vp = vector<P>;
#define REP(i, n) for (LL i = 0; i < (int)(n); i++)
#define FOR(i, m, n) for (LL i = m; i < n; i++)
#define SORT(x) sort(x.begin(), x.end())
#define REVE(x) reverse(x.begin(), x.end())
#define all(x) (x).begin(), (x).end()
#define fst first
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pob pop_back
#define sw swap
#define UP(x) transform(x.begin(), x.end(), x.begin(), ::toupper);
#define LOW(x) transform(x.begin(), x.end(), x.begin(), ::tolower);
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
};
};
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int n, a = 0;
cin >> n;
vector<int> t(n + 1);
REP(i, n + 1) cin >> t[i];
vector<int> y(n);
REP(i, n) cin >> y[i];
REP(i, n) {
if (y[i] >= t[i] + t[i + 1]) {
a += t[i] + t[i + 1];
t[i] = 0;
t[i + 1] = 0;
} else if (y[i] >= t[i]) {
a += t[i];
y[i] -= t[i];
t[i] = 0;
a += y[i];
t[i + 1] -= y[i];
y[i] = 0;
} else if (y[i] < t[i]) {
a += y[i];
y[i] = 0;
t[i] -= y[i];
}
}
cout << a;
} | #include <algorithm>
#include <cctype>
#include <cstdio>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using f32 = float;
using f64 = double;
using f80 = __float80;
using namespace std;
using LL = long long;
using ULL = unsigned long long;
using vi = vector<int>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvi = vector<vi>;
using vs = vector<string>;
using vl = vector<LL>;
using vvl = vector<vl>;
using P = pair<int, int>;
using T = tuple<int, int, int>;
using vp = vector<P>;
#define REP(i, n) for (LL i = 0; i < (int)(n); i++)
#define FOR(i, m, n) for (LL i = m; i < n; i++)
#define SORT(x) sort(x.begin(), x.end())
#define REVE(x) reverse(x.begin(), x.end())
#define all(x) (x).begin(), (x).end()
#define fst first
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define pob pop_back
#define sw swap
#define UP(x) transform(x.begin(), x.end(), x.begin(), ::toupper);
#define LOW(x) transform(x.begin(), x.end(), x.begin(), ::tolower);
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
};
};
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
LL n, a = 0;
cin >> n;
vector<LL> t(n + 1);
REP(i, n + 1) cin >> t[i];
vector<LL> y(n);
REP(i, n) cin >> y[i];
REP(i, n) {
if (y[i] >= t[i] + t[i + 1]) {
a += t[i] + t[i + 1];
t[i] = 0;
t[i + 1] = 0;
} else if (y[i] >= t[i]) {
a += t[i];
y[i] -= t[i];
t[i] = 0;
a += y[i];
t[i + 1] -= y[i];
y[i] = 0;
} else if (y[i] < t[i]) {
a += y[i];
y[i] = 0;
t[i] -= y[i];
}
}
cout << a;
} | [
"variable_declaration.type.change"
] | 770,083 | 770,084 | u379928983 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N + 1);
vector<long long> B(N);
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
int ans = 0;
for (int i = 0; i < N + 1; i++) {
if (A[i] < B[i]) {
ans += A[i];
B[i] = B[i] - A[i];
A[i] = 0;
if (B[i] < A[i + 1]) {
ans += B[i];
A[i + 1] = A[i + 1] - B[i];
B[i] = 0;
} else if (B[i] >= A[i + 1]) {
ans += A[i + 1];
B[i] = B[i] - A[i + 1];
A[i + 1] = 0;
}
}
if (A[i] >= B[i]) {
ans += B[i];
A[i] = A[i] - B[i];
B[i] = 0;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N + 1);
vector<long long> B(N);
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
long long ans = 0;
for (int i = 0; i < N; i++) {
if (A[i] < B[i]) {
ans += A[i];
B[i] = B[i] - A[i];
A[i] = 0;
if (B[i] < A[i + 1]) {
ans += B[i];
A[i + 1] = A[i + 1] - B[i];
B[i] = 0;
} else if (B[i] >= A[i + 1]) {
ans += A[i + 1];
B[i] = B[i] - A[i + 1];
A[i + 1] = 0;
}
}
if (A[i] >= B[i]) {
ans += B[i];
A[i] = A[i] - B[i];
B[i] = 0;
}
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 770,087 | 770,086 | u037276799 | cpp |
p02959 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N + 1);
vector<long long> B(N);
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
int ans = 0;
for (int i = 0; i < N + 1; i++) {
if (A[i] < B[i]) {
ans += A[i];
B[i] = B[i] - A[i];
A[i] = 0;
if (B[i] < A[i + 1]) {
ans += B[i];
A[i + 1] = A[i + 1] - B[i];
B[i] = 0;
} else if (B[i] >= A[i + 1]) {
ans += A[i + 1];
B[i] = B[i] - A[i + 1];
A[i + 1] = 0;
}
}
if (A[i] >= B[i]) {
ans += B[i];
A[i] = A[i] - B[i];
B[i] = 0;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N + 1);
vector<long long> B(N);
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
long long ans = 0;
for (int i = 0; i < N; i++) {
if (A[i] < B[i]) {
ans += A[i];
B[i] = B[i] - A[i];
A[i] = 0;
if (B[i] < A[i + 1]) {
ans += B[i];
A[i + 1] = A[i + 1] - B[i];
B[i] = 0;
} else if (B[i] >= A[i + 1]) {
ans += A[i + 1];
B[i] = B[i] - A[i + 1];
A[i + 1] = 0;
}
}
if (A[i] >= B[i]) {
ans += B[i];
A[i] = A[i] - B[i];
B[i] = 0;
}
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 770,088 | 770,086 | u037276799 | cpp |
p02959 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
long long A[100000];
long long B[100000];
int main() {
int N;
cin >> N;
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
long long ans = 0;
for (int i = 0; i < N; i++) {
if (A[i] < B[i]) {
ans += A[i];
B[i] -= A[i];
if (A[i + 1] > B[i]) {
A[i + 1] -= B[i];
ans += B[i];
} else {
ans += A[i + 1];
A[i + 1];
}
} else {
ans += B[i];
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
long long A[100000];
long long B[100000];
int main() {
int N;
cin >> N;
for (int i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
long long ans = 0;
for (int i = 0; i < N; i++) {
if (A[i] < B[i]) {
ans += A[i];
B[i] -= A[i];
if (A[i + 1] > B[i]) {
A[i + 1] -= B[i];
ans += B[i];
} else {
ans += A[i + 1];
A[i + 1] = 0;
}
} else {
ans += B[i];
}
}
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 770,089 | 770,090 | u623349537 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1];
int b[n];
for (int i = 0; i < n + 1; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
int c = 0;
for (int i = 0; i < n; i++) {
c += min(a[i], b[i]);
c += min(a[i + 1], max(a[i], b[i]) - a[i]);
a[i + 1] = a[i + 1] - min(a[i + 1], max(a[i], b[i]) - a[i]);
}
cout << c << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1];
int b[n];
for (int i = 0; i < n + 1; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
long long int c = 0;
for (int i = 0; i < n; i++) {
c += min(a[i], b[i]);
c += min(a[i + 1], max(a[i], b[i]) - a[i]);
a[i + 1] = a[i + 1] - min(a[i + 1], max(a[i], b[i]) - a[i]);
}
cout << c << endl;
} | [
"variable_declaration.type.widen.change"
] | 770,096 | 770,097 | u704064492 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n, ans;
cin >> n;
ans = 0;
int a[n + 1];
int b[n];
rep(i, n + 1) cin >> a[i];
rep(j, n) cin >> b[j];
for (int k = 0; k < n; k++) {
if (b[k] == a[k])
ans = ans + a[k];
else if (b[k] > a[k]) {
ans = ans + a[k];
b[k] = b[k] - a[k];
if (b[k] >= a[k + 1]) {
ans = ans + a[k + 1];
a[k + 1] = 0;
} else {
ans = ans + b[k];
a[k + 1] = a[k + 1] - b[k];
}
}
else
ans = ans + b[k];
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int main() {
int n;
long ans;
cin >> n;
ans = 0;
int a[n + 1];
int b[n];
rep(i, n + 1) cin >> a[i];
rep(j, n) cin >> b[j];
for (int k = 0; k < n; k++) {
if (b[k] == a[k])
ans = ans + a[k];
else if (b[k] > a[k]) {
ans = ans + a[k];
b[k] = b[k] - a[k];
if (b[k] >= a[k + 1]) {
ans = ans + a[k + 1];
a[k + 1] = 0;
} else {
ans = ans + b[k];
a[k + 1] = a[k + 1] - b[k];
}
}
else
ans = ans + b[k];
}
cout << ans << endl;
}
| [
"variable_declaration.type.widen.change"
] | 770,100 | 770,101 | u551813187 | cpp |
p02959 | #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N + 1);
for (int i = 0; i < N + 1; i++) {
cin >> A.at(i);
}
vector<int> B(N);
for (int i = 0; i < N; i++) {
cin >> B.at(i);
}
int cnt = 0;
for (int i = 0; i < N; i++) {
if (A.at(i) <= B.at(i)) {
cnt += A.at(i);
B.at(i) -= A.at(i);
A.at(i) = 0;
} else {
cnt += B.at(i);
A.at(i) -= B.at(i);
B.at(i) = 0;
}
if (A.at(i + 1) <= B.at(i)) {
cnt += A.at(i + 1);
B.at(i) -= A.at(i + 1);
A.at(i + 1) = 0;
} else {
cnt += B.at(i);
A.at(i + 1) -= B.at(i);
B.at(i) = 0;
}
}
cout << cnt << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <math.h>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N + 1);
for (int i = 0; i < N + 1; i++) {
cin >> A.at(i);
}
vector<int> B(N);
for (int i = 0; i < N; i++) {
cin >> B.at(i);
}
long long int cnt = 0;
for (int i = 0; i < N; i++) {
if (A.at(i) <= B.at(i)) {
cnt += A.at(i);
B.at(i) -= A.at(i);
A.at(i) = 0;
} else {
cnt += B.at(i);
A.at(i) -= B.at(i);
B.at(i) = 0;
}
if (A.at(i + 1) <= B.at(i)) {
cnt += A.at(i + 1);
B.at(i) -= A.at(i + 1);
A.at(i + 1) = 0;
} else {
cnt += B.at(i);
A.at(i + 1) -= B.at(i);
B.at(i) = 0;
}
}
cout << cnt << endl;
return 0;
}
| [
"variable_declaration.type.widen.change"
] | 770,102 | 770,103 | u628134373 | cpp |
p02959 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
long A[n + 1];
long B[n];
for (int i = 0; i < n + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
sum += A[j + i];
A[j + i] = 0;
} else {
sum += B[i];
A[j + i] -= B[i];
B[i] = 0;
}
}
}
cout << sum << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
long A[n + 1];
long B[n];
for (int i = 0; i < n + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
long sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
sum += A[j + i];
A[j + i] = 0;
} else {
sum += B[i];
A[j + i] -= B[i];
B[i] = 0;
}
}
}
cout << sum << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 770,104 | 770,105 | u432088501 | cpp |
p02959 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int A[n + 1];
int B[n];
for (int i = 0; i < n + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
sum += A[j + i];
A[j + i] = 0;
} else {
sum += B[i];
A[j + i] -= B[i];
B[i] = 0;
break;
}
}
}
cout << sum << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
long A[n + 1];
long B[n];
for (int i = 0; i < n + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
long sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
sum += A[j + i];
A[j + i] = 0;
} else {
sum += B[i];
A[j + i] -= B[i];
B[i] = 0;
}
}
}
cout << sum << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 770,106 | 770,105 | u432088501 | cpp |
p02959 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int A[n + 1];
int B[n];
for (int i = 0; i < n + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
sum += A[j + i];
A[j + i] = 0;
} else {
sum += B[i];
A[j + i] -= B[i];
B[i] = 0;
}
}
}
cout << sum << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
long A[n + 1];
long B[n];
for (int i = 0; i < n + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
long sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
sum += A[j + i];
A[j + i] = 0;
} else {
sum += B[i];
A[j + i] -= B[i];
B[i] = 0;
}
}
}
cout << sum << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 770,107 | 770,105 | u432088501 | cpp |
p02959 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
long A[n + 1];
long B[n];
for (int i = 0; i < n + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
sum += A[j + i];
A[j + i] = 0;
} else {
sum += B[i];
A[j + i] -= B[i];
B[i] = 0;
}
}
}
cout << sum << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
long A[n + 1];
long B[n];
for (int i = 0; i < n + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
long sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
sum += A[j + i];
A[j + i] = 0;
} else {
sum += B[i];
A[j + i] -= B[i];
B[i] = 0;
}
}
}
cout << sum << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 770,104 | 770,108 | u432088501 | cpp |
p02959 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int A[n + 1];
int B[n];
for (int i = 0; i < n + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
sum += A[j + i];
A[j + i] = 0;
} else {
sum += B[i];
A[j + i] -= B[i];
B[i] = 0;
break;
}
}
}
cout << sum << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
long A[n + 1];
long B[n];
for (int i = 0; i < n + 1; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
long sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (B[i] >= A[j + i]) {
B[i] -= A[j + i];
sum += A[j + i];
A[j + i] = 0;
} else {
sum += B[i];
A[j + i] -= B[i];
B[i] = 0;
}
}
}
cout << sum << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 770,106 | 770,108 | u432088501 | cpp |
p02959 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1);
vector<int> b(n);
for (int i = 0; i < n + 1; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++)
cin >> b[i];
int ans = 0;
for (int i = n - 1; i >= 0; i--) {
int ki = min(a[i + 1], b[i]);
ans += ki;
b[i] -= ki;
if (a[i] > b[i]) {
ans += b[i];
a[i] -= b[i];
} else {
ans += a[i];
a[i] = 0;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> a(n + 1);
vector<long long> b(n);
for (int i = 0; i < n + 1; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++)
cin >> b[i];
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
int ki = min(a[i + 1], b[i]);
ans += ki;
b[i] -= ki;
if (a[i] > b[i]) {
ans += b[i];
a[i] -= b[i];
} else {
ans += a[i];
a[i] = 0;
}
}
cout << ans << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 770,109 | 770,110 | u117348081 | cpp |
p02959 | #include <functional>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N + 1), B(N);
for (size_t i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (size_t i = 0; i < N; i++) {
cin >> B[i];
}
int cnt = 0, p = 0;
for (size_t i = N; i > 0; i--) {
if (A[i] <= p) {
cnt += A[i];
p = B[i - 1];
continue;
}
cnt += p;
A[i] -= p;
if (B[i - 1] <= A[i]) {
cnt += B[i - 1];
p = 0;
continue;
}
cnt += A[i];
B[i - 1] -= A[i];
p = B[i - 1];
}
cnt += (A[0] >= p) ? p : A[0];
cout << cnt << endl;
return 0;
} | #include <functional>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main() {
int N;
cin >> N;
vector<long> A(N + 1), B(N);
for (size_t i = 0; i < N + 1; i++) {
cin >> A[i];
}
for (size_t i = 0; i < N; i++) {
cin >> B[i];
}
long cnt = 0, p = 0;
for (size_t i = N; i > 0; i--) {
if (A[i] <= p) {
cnt += A[i];
p = B[i - 1];
continue;
}
cnt += p;
A[i] -= p;
if (B[i - 1] <= A[i]) {
cnt += B[i - 1];
p = 0;
continue;
}
cnt += A[i];
B[i - 1] -= A[i];
p = B[i - 1];
}
cnt += (A[0] >= p) ? p : A[0];
cout << cnt << endl;
return 0;
} | [
"variable_declaration.type.primitive.change"
] | 770,111 | 770,112 | u022433269 | cpp |
p02959 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<ll> A(N + 1);
vector<ll> B(N);
rep(i, N + 1) { cin >> A[i]; }
rep(i, N) { cin >> B[i]; }
ll sum = 0;
rep(i, N) {
ll diff = A[i] - B[i];
if (diff < 0) {
B[i] = -diff;
diff = A[i + 1] - B[i];
if (diff < 0) {
sum += A[i] + A[i + 1];
A[i + 1] = 0;
} else {
sum += B[i];
A[i + 1] -= B[i];
}
} else {
sum += B[i];
}
// cout << sum << endl;
}
cout << sum << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
int main() {
int N;
cin >> N;
vector<ll> A(N + 1);
vector<ll> B(N);
rep(i, N + 1) { cin >> A[i]; }
rep(i, N) { cin >> B[i]; }
ll sum = 0;
rep(i, N) {
ll diff = A[i] - B[i];
if (diff < 0) {
B[i] = -diff;
diff = A[i + 1] - B[i];
if (diff < 0) {
sum += A[i] + A[i + 1];
A[i + 1] = 0;
} else {
sum += A[i] + B[i];
A[i + 1] -= B[i];
}
} else {
sum += B[i];
}
}
cout << sum << endl;
} | [
"assignment.change"
] | 770,116 | 770,117 | u317806971 | cpp |
p02959 | #include <iostream>
typedef long long LL;
using namespace std;
LL a[100001];
LL b[100000];
int n;
int main() {
LL sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n + 1; i++) {
if (a[i] + a[i + 1] <= b[i]) {
sum += a[i] + a[i + 1];
a[i + 1] = 0;
} else if (a[i] >= b[i]) {
sum += b[i];
} else if ((a[i] < b[i])) {
sum += b[i];
a[i + 1] = a[i] + a[i + 1] - b[i];
}
}
cout << sum << endl;
// system("pause");
return 0;
} | #include <iostream>
typedef long long LL;
using namespace std;
LL a[100001];
LL b[100000];
int n;
int main() {
LL sum = 0;
cin >> n;
for (int i = 0; i < n + 1; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
if (a[i] + a[i + 1] <= b[i]) {
sum += a[i] + a[i + 1];
a[i + 1] = 0;
} else if (a[i] >= b[i]) {
sum += b[i];
} else if ((a[i] < b[i])) {
sum += b[i];
a[i + 1] = a[i] + a[i + 1] - b[i];
}
}
cout << sum << endl;
// system("pause");
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"expression.operation.binary.remove"
] | 770,127 | 770,128 | u838609976 | cpp |
p02960 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
const double PI = acos(-1.0);
const ll MOD = 1000000007;
string S;
ll dp[100010][13];
int input() { cin >> S; }
int solve() {
int N = S.length();
for (int i = 0; i < 13; ++i)
dp[1][i] = 0ll;
if (S[0] == '?') {
for (int j = 0; j < 10; ++j) {
dp[1][j] = 1ll;
}
} else {
int j = S[1] - '0';
dp[1][j] = 1ll;
}
for (int i = 1; i < N; ++i) {
if (S[i] == '?') {
for (int j = 0; j < 13; ++j) {
for (int k = 0; k < 10; ++k) {
dp[i + 1][(j * 10 + k) % 13] += dp[i][j];
dp[i + 1][(j * 10 + k) % 13] %= MOD;
}
}
} else {
int k = S[i] - '0';
for (int j = 0; j < 13; ++j) {
dp[i + 1][(j * 10 + k) % 13] += dp[i][j];
dp[i + 1][(j * 10 + k) % 13] %= MOD;
}
}
}
cout << dp[N][5] << endl;
}
int main() {
cin.tie();
ios::sync_with_stdio(false);
input();
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
const double PI = acos(-1.0);
const ll MOD = 1000000007;
string S;
ll dp[100010][13];
int input() { cin >> S; }
int solve() {
int N = S.length();
for (int i = 0; i < 13; ++i)
dp[1][i] = 0ll;
if (S[0] == '?') {
for (int j = 0; j < 10; ++j) {
dp[1][j] = 1ll;
}
} else {
int j = S[0] - '0';
dp[1][j] = 1ll;
}
// dp[0][0]=1ll;
for (int i = 0; i < N; ++i) {
if (S[i] == '?') {
for (int j = 0; j < 13; ++j) {
for (int k = 0; k < 10; ++k) {
dp[i + 1][(j * 10 + k) % 13] += dp[i][j];
dp[i + 1][(j * 10 + k) % 13] %= MOD;
}
}
} else {
int k = S[i] - '0';
for (int j = 0; j < 13; ++j) {
dp[i + 1][(j * 10 + k) % 13] += dp[i][j];
dp[i + 1][(j * 10 + k) % 13] %= MOD;
}
}
}
cout << dp[N][5] << endl;
// for(int j=0;j<5;++j) {for(int i=0;i<13;++i) cout<<dp[j][i]<<" ";
// cout<<"\n";} cout<<endl;
}
int main() {
cin.tie();
ios::sync_with_stdio(false);
input();
solve();
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 770,144 | 770,145 | u675343092 | cpp |
p02960 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repp(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define repm(i, n) for (int(i) = (n); (i) > 0; (i)--)
#define INF (1ll << 60)
typedef long long lint;
const lint MOD = 1000000007;
const lint MAX = 10000000;
lint fac[MAX], finv[MAX], inv[MAX];
void COMinit() // 二項係数を求める時は前処理としてCOMinit()をする
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (lint i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(lint n, lint k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
lint primary(lint num) {
if (num < 2)
return 0;
else if (num == 2)
return 1;
else if (num % 2 == 0)
return 0; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return 0;
}
}
// 素数である
return 1;
}
lint dp[13][100005];
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
dp[0][0] = 1;
lint mul = 1;
rep(i, s.size()) {
lint x;
if (s[i] != '?') {
x = s[i] - '0';
rep(j, 13) { dp[(j + x * mul) % 13][i + 1] += dp[j][i]; }
} else {
rep(k, 10) {
rep(j, 13) { dp[(j + k * mul) % 13][i + 1] += dp[j][i]; }
}
}
mul *= 10;
mul %= MOD;
rep(m, 13) { dp[m][i + 1] %= MOD; }
}
cout << dp[5][s.size()];
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repp(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define repm(i, n) for (int(i) = (n); (i) > 0; (i)--)
#define INF (1ll << 60)
typedef long long lint;
const lint MOD = 1000000007;
const lint MAX = 10000000;
lint fac[MAX], finv[MAX], inv[MAX];
void COMinit() // 二項係数を求める時は前処理としてCOMinit()をする
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (lint i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(lint n, lint k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
lint primary(lint num) {
if (num < 2)
return 0;
else if (num == 2)
return 1;
else if (num % 2 == 0)
return 0; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
// 素数ではない
return 0;
}
}
// 素数である
return 1;
}
lint dp[13][100005];
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
dp[0][0] = 1;
lint mul = 1;
rep(i, s.size()) {
lint x;
if (s[i] != '?') {
x = s[i] - '0';
rep(j, 13) { dp[(j + x * mul) % 13][i + 1] += dp[j][i]; }
} else {
rep(k, 10) {
rep(j, 13) { dp[(j + k * mul) % 13][i + 1] += dp[j][i]; }
}
}
mul *= 10;
mul %= 13;
rep(m, 13) { dp[m][i + 1] %= MOD; }
}
cout << dp[5][s.size()];
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 770,151 | 770,152 | u768204022 | cpp |
p02960 | /*
* Name : chaitanya
*
* Institute : ANITS,Visakhapatnam
*
*/
#include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
#define inf 1000000000
#pragma GCC optimization("O3")
using namespace std;
const long long int N = 6999999;
#define all(x) begin(x), end(x)
#define ll long long int
const ll mod = 1000000007;
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
ll n = s.length();
ll dp[n][13];
memset(dp, 0, sizeof(dp));
if (s[0] == '?')
for (int i = 0; i < 10; ++i) {
dp[0][i] = 1;
}
else
dp[0][s[0] - '0'] = 1;
for (int i = 1; i < n; ++i) {
ll t = s[i] - '0';
if (s[i] == '?') {
for (int j = 0; j < 10; ++j) {
t = j;
for (int k = 0; k < 13; ++k) {
dp[i][(k * 10 + t) % 13] += dp[i - 1][k];
dp[i][(k * 10 + t) % 13] %= mod;
}
}
} else {
for (int j = 0; j < 13; ++j) {
dp[i][(j * 10 + t) % 13] += dp[i - 1][j];
dp[i][(j * 10 + t) % 13] %= mod;
}
}
}
cout << dp[n - 1][0] << endl;
return 0;
} |
#include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
#define inf 1000000000
#pragma GCC optimization("O3")
using namespace std;
const long long int N = 6999999;
#define all(x) begin(x), end(x)
#define ll long long int
const ll mod = 1000000007;
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
ll n = s.length();
ll dp[n][13];
memset(dp, 0, sizeof(dp));
if (s[0] == '?')
for (int i = 0; i < 10; ++i) {
dp[0][i] = 1;
}
else
dp[0][s[0] - '0'] = 1;
for (int i = 1; i < n; ++i) {
ll t = s[i] - '0';
if (s[i] == '?') {
for (int j = 0; j < 10; ++j) {
t = j;
for (int k = 0; k < 13; ++k) {
dp[i][(k * 10 + t) % 13] += dp[i - 1][k];
dp[i][(k * 10 + t) % 13] %= mod;
}
}
} else {
for (int j = 0; j < 13; ++j) {
dp[i][(j * 10 + t) % 13] += dp[i - 1][j];
dp[i][(j * 10 + t) % 13] %= mod;
}
}
}
cout << dp[n - 1][5] << endl;
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"io.output.change"
] | 770,163 | 770,164 | u866529295 | cpp |
p02960 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define _GLIBCXX_DEBUG
int main() {
int MOD = pow(10, 9) + 7;
string s;
cin >> s;
int l = s.size();
long dp[l + 1][13];
int table10[7];
table10[1] = 1;
rep(i, 5) { table10[i + 2] = (10 * table10[i + 1]) % 13; }
table10[0] = 4;
if (s.at(l - 1) == '?') {
rep(i, 10) { dp[1][i] = 1; }
rep(i, 3) { dp[1][i + 10] = 0; }
} else {
int num = s.at(l - 1) - '0';
rep(i, 13) { dp[1][i] = 0; }
dp[1][num] = 1;
}
for (int i = 2; i < l + 1; i++) {
if (s.at(l - i) == '?') {
for (int j = 0; j < 13; j++) {
dp[i][j] = 0;
for (int k = 0; k < 10; k++) {
int mod1 = table10[i % 6] * k;
dp[i][j] += dp[i - 1][(13 + j - mod1) % 13];
dp[i][j] %= MOD;
}
}
} else {
int num = s.at(l - i) - '0';
int mod1 = (table10[i % 6] * num) % 13;
for (int j = 0; j < 13; j++) {
dp[i][j] = dp[i - 1][(13 + j - mod1) % 13];
}
}
}
cout << dp[l][5] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define _GLIBCXX_DEBUG
int main() {
int MOD = pow(10, 9) + 7;
string s;
cin >> s;
int l = s.size();
long dp[l + 1][13];
int table10[7];
table10[1] = 1;
rep(i, 5) { table10[i + 2] = (10 * table10[i + 1]) % 13; }
table10[0] = 4;
if (s.at(l - 1) == '?') {
rep(i, 10) { dp[1][i] = 1; }
rep(i, 3) { dp[1][i + 10] = 0; }
} else {
int num = s.at(l - 1) - '0';
rep(i, 13) { dp[1][i] = 0; }
dp[1][num] = 1;
}
for (int i = 2; i < l + 1; i++) {
if (s.at(l - i) == '?') {
for (int j = 0; j < 13; j++) {
dp[i][j] = 0;
for (int k = 0; k < 10; k++) {
int mod1 = (table10[i % 6] * k) % 13;
dp[i][j] += dp[i - 1][(13 + j - mod1) % 13];
dp[i][j] %= MOD;
}
}
} else {
int num = s.at(l - i) - '0';
int mod1 = (table10[i % 6] * num) % 13;
for (int j = 0; j < 13; j++) {
dp[i][j] = dp[i - 1][(13 + j - mod1) % 13];
}
}
}
cout << dp[l][5] << endl;
return 0;
}
| [
"assignment.change"
] | 770,187 | 770,188 | u518042385 | cpp |
p02960 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define MOD (1000000007)
using namespace std;
typedef long long int Int;
constexpr Int TEN(int n) { return n == 0 ? 1 : 10 * TEN(n - 1); }
string s;
int dp[100000 + 10][15];
int main(void) {
cin >> s;
int n = s.size();
dp[0][0] = 1;
for (int i = 0; i < n; i++) {
int c;
if (s[i] == '?') {
c = -1;
} else {
c = s[i] - '0';
}
for (int j = 0; j < 10; j++) {
if (c != -1 && c != j)
continue;
for (int ki = 0; ki < 13; ki++) {
dp[i + 1][(ki * 10 + j) % 13] += dp[i][ki];
}
}
for (int j = 0; j < 13; j++) {
dp[i + 1][j] %= MOD;
}
}
cout << dp[n][5] << endl;
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define MOD (1000000007)
using namespace std;
typedef long long int Int;
constexpr Int TEN(int n) { return n == 0 ? 1 : 10 * TEN(n - 1); }
string s;
Int dp[100000 + 10][15];
int main(void) {
cin >> s;
int n = s.size();
dp[0][0] = 1;
for (int i = 0; i < n; i++) {
int c;
if (s[i] == '?') {
c = -1;
} else {
c = s[i] - '0';
}
for (int j = 0; j < 10; j++) {
if (c != -1 && c != j)
continue;
for (int ki = 0; ki < 13; ki++) {
dp[i + 1][(ki * 10 + j) % 13] += dp[i][ki];
}
}
for (int j = 0; j < 13; j++) {
dp[i + 1][j] %= MOD;
}
}
cout << dp[n][5] << endl;
return 0;
}
| [
"variable_declaration.type.change"
] | 770,197 | 770,198 | u498141549 | cpp |
p02960 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
typedef long long ll;
using namespace std;
ll dp[100000][13];
int modpow(int x, int y) {
int res = 1;
while (y > 0) {
if (y & 1)
res = res * x % 13;
x = x * x % 13;
y >>= 1;
}
return res;
}
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
if (s[0] == '?') {
for (int i = 0; i < 9; i++) {
dp[0][i] = 1;
}
} else {
dp[0][s[0] - '0'] = 1;
}
for (int i = 1; i < s.length(); i++) {
if (s[i] == '?') {
for (int j = 0; j < 10; j++) {
for (int k = 0; k < 13; k++) {
int temp = (j * modpow(10, i) + k) % 13;
dp[i][temp] += dp[i - 1][k];
dp[i][temp] %= MOD;
}
}
} else {
for (int j = 0; j < 13; j++) {
int temp = ((s[i] - '0') * modpow(10, i) + j) % 13;
dp[i][temp] += dp[i - 1][j];
dp[i][temp] %= MOD;
}
}
}
cout << dp[s.length() - 1][5] << endl;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
typedef long long ll;
using namespace std;
ll dp[100000][13];
int modpow(int x, int y) {
int res = 1;
while (y > 0) {
if (y & 1)
res = res * x % 13;
x = x * x % 13;
y >>= 1;
}
return res;
}
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
if (s[0] == '?') {
for (int i = 0; i <= 9; i++) {
dp[0][i] = 1;
}
} else {
dp[0][s[0] - '0'] = 1;
}
for (int i = 1; i < s.length(); i++) {
if (s[i] == '?') {
for (int j = 0; j < 10; j++) {
for (int k = 0; k < 13; k++) {
int temp = (j * modpow(10, i) + k) % 13;
dp[i][temp] += dp[i - 1][k];
dp[i][temp] %= MOD;
}
}
} else {
for (int j = 0; j < 13; j++) {
int temp = ((s[i] - '0') * modpow(10, i) + j) % 13;
dp[i][temp] += dp[i - 1][j];
dp[i][temp] %= MOD;
}
}
}
cout << dp[s.length() - 1][5] << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 770,203 | 770,204 | u075296067 | cpp |
p02960 | #include <bits/stdc++.h>
using namespace std;
#define ALL(A) (A).begin(), (A).end()
#define ll long long
const int mod = 1e9 + 7;
int dp[100005][13];
int main(void) {
string s;
cin >> s;
int n = s.size();
dp[0][0] = 1;
int mul = 1; //桁数
// 1?2?3 の場合は 0 -> 3 -> ?3 -> 2?3 -> ...の順に処理していく
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '?') {
for (int k = 0; k < 13; k++) {
for (int j = 0; j < 10; j++) {
// jは新たに追加する数字つまりmul*jを13で割った余りを出せって感じ
dp[n - i][(mul * j + k) % 13] += dp[n - i - 1][k];
dp[n - i][(mul * j + k) % 13] %= mod;
}
}
mul *= 10;
mul %= mod;
} else {
int c = (int)s[i] - '0';
for (int k = 0; k < 13; k++) {
dp[n - i][(mul * c + k) % 13] += dp[n - i - 1][k];
dp[n - i][(mul * c + k) % 13] %= mod;
}
mul *= 10;
mul %= mod;
}
}
cout << dp[n][5] % mod << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ALL(A) (A).begin(), (A).end()
#define ll long long
const int mod = 1e9 + 7;
int dp[100005][13];
int main(void) {
string s;
cin >> s;
int n = s.size();
dp[0][0] = 1;
int mul = 1; //桁数
// 1?2?3 の場合は 0 -> 3 -> ?3 -> 2?3 -> ...の順に処理していく
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '?') {
for (int k = 0; k < 13; k++) {
for (int j = 0; j < 10; j++) {
// jは新たに追加する数字つまりmul*jを13で割った余りを出せって感じ
dp[n - i][(mul * j + k) % 13] += dp[n - i - 1][k];
dp[n - i][(mul * j + k) % 13] %= mod;
}
}
mul *= 10;
mul %= 13;
} else {
int c = (int)s[i] - '0';
for (int k = 0; k < 13; k++) {
dp[n - i][(mul * c + k) % 13] += dp[n - i - 1][k];
dp[n - i][(mul * c + k) % 13] %= mod;
}
mul *= 10;
mul %= 13;
}
}
cout << dp[n][5] % mod << endl;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add"
] | 770,221 | 770,222 | u168774513 | cpp |
p02962 | #include <bits/stdc++.h>
using namespace std;
// kmp をやるための前計算
vector<int> makeTable(const string &s) {
int n = s.size();
vector<int> ret(n + 1);
ret[0] = -1;
int j = -1;
for (int i = 0; i < n; i++) {
while (j >= 0 && s[i] != s[j])
j = ret[j];
ret[i + 1] = ++j;
}
return ret;
}
// str の中に word とマッチする場所のリストを返す
// ret のそれぞれの要素 el は, 「str[el] からの文字列が word
// と一致する」ことを示す
vector<int> kmp(const string &str, const string &word) {
vector<int> table = makeTable(word), ret;
int m = 0, i = 0, n = str.size();
while (m + i < n) {
if (word[i] == str[m + i]) {
if (++i == (int)(word.size())) {
ret.push_back(m);
m = m + i - table[i];
i = table[i];
}
} else {
m = m + i - table[i];
if (i > 0)
i = table[i];
}
}
return ret;
}
int f;
int serch(int k, int N, vector<int> &match, int M, vector<int> &length,
vector<int> &visit) {
if (length[k] != -1) {
return length[k];
} else if (match[k] == 0) {
length[k] = 0;
return 0;
} else {
if (visit[k] == 1) {
f = 1;
} else {
visit[k] = 1;
length[k] = serch((k + M) % N, N, match, M, length, visit) + 1;
}
return length[k];
}
}
int main() {
int N, M, i;
string s, t;
cin >> s;
cin >> t;
N = s.size();
M = t.size();
// if(N >= M){
string ss = s;
while (ss.size() <= 2 * M) {
ss += s;
}
vector<int> match_list = kmp(ss, t);
vector<int> match(N, 0);
for (i = 0; i < match_list.size(); i++) {
if (match_list[i] < N) {
match[match_list[i]] = 1;
}
}
vector<int> length(N, -1), visit(N, 0);
f = 0;
int ans = -1;
for (i = 0; i < N; i++) {
ans = max(ans, serch(i, N, match, M, length, visit));
}
if (f == 1) {
printf("-1\n");
} else {
printf("%d\n", ans);
}
/* }
else{
string tt = t + t;
vector<int> match_list = kmp(tt, s);
vector<int> match(M, 0);
for(i = 0; i < match_list.size(); i++){
if(match_list[i] < M){
match[match_list[i]] = 1;
}
}
vector<int> length(M, -1), visit(M, 0);
f = 0;
int ans = -1;
for(i = 0; i < M; i++){
ans = max(ans, serch(i, M, match, N, length, visit));
}
if(f == 1){
printf("-1\n");
}
else{
printf("%d\n", (N * ans) / M);
}
}
*/
return 0;
} | #include <bits/stdc++.h>
using namespace std;
// kmp をやるための前計算
vector<int> makeTable(const string &s) {
int n = s.size();
vector<int> ret(n + 1);
ret[0] = -1;
int j = -1;
for (int i = 0; i < n; i++) {
while (j >= 0 && s[i] != s[j])
j = ret[j];
ret[i + 1] = ++j;
}
return ret;
}
// str の中に word とマッチする場所のリストを返す
// ret のそれぞれの要素 el は, 「str[el] からの文字列が word
// と一致する」ことを示す
vector<int> kmp(const string &str, const string &word) {
vector<int> table = makeTable(word), ret;
int m = 0, i = 0, n = str.size();
while (m + i < n) {
if (word[i] == str[m + i]) {
if (++i == (int)(word.size())) {
ret.push_back(m);
m = m + i - table[i];
i = table[i];
}
} else {
m = m + i - table[i];
if (i > 0)
i = table[i];
}
}
return ret;
}
int f;
int serch(int k, int N, vector<int> &match, int M, vector<int> &length,
vector<int> &visit) {
if (length[k] != -1) {
return length[k];
} else if (match[k] == 0) {
length[k] = 0;
return 0;
} else {
if (visit[k] == 1) {
f = 1;
} else {
visit[k] = 1;
length[k] = serch((k + M) % N, N, match, M, length, visit) + 1;
}
return length[k];
}
}
int main() {
int N, M, i;
string s, t;
cin >> s;
cin >> t;
N = s.size();
M = t.size();
string ss = s + s;
while (ss.size() <= 2 * M) {
ss += s;
}
vector<int> match_list = kmp(ss, t);
vector<int> match(N, 0);
for (i = 0; i < match_list.size(); i++) {
if (match_list[i] < N) {
match[match_list[i]] = 1;
}
}
vector<int> length(N, -1), visit(N, 0);
f = 0;
int ans = -1;
for (i = 0; i < N; i++) {
ans = max(ans, serch(i, N, match, M, length, visit));
}
if (f == 1) {
printf("-1\n");
} else {
printf("%d\n", ans);
}
return 0;
} | [
"assignment.change"
] | 770,229 | 770,230 | u208608367 | cpp |
p02962 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int maxn = 2e6 + 5;
typedef long long ll;
const ll mod = 191981019260817247;
ll base = 233;
ll pw[maxn], ha[maxn];
inline ll mul(ll a, ll b) {
ll k = (ll)((long double)a * b / mod);
ll r = a * b - mod * k;
if (r < 0)
r += mod;
if (r >= mod)
r -= mod;
return r;
}
inline ll geth(int l, int r) {
return (ha[r] - mul(pw[r - l + 1], ha[l - 1]) + mod) % mod;
}
vector<int> adj[maxn];
int d[maxn];
int n, m, len;
char s[maxn], t[maxn];
int id[maxn];
queue<int> q;
int main() {
scanf("%s", s + 1);
scanf("%s", t + 1);
n = strlen(s + 1);
m = strlen(t + 1);
len = n;
while (len < m * 2) {
for (int i = 1; i <= n; i++) {
s[++len] = s[i];
}
}
pw[0] = 1;
for (int i = 1; i <= len; i++) {
pw[i] = mul(pw[i - 1], base);
ha[i] = (mul(ha[i - 1], base) + s[i]) % mod;
}
ll hat = 0;
for (int i = 1; i <= m; i++) {
hat = (mul(hat, base) + t[i]) % mod;
}
for (int i = 1; i <= n; i++) {
int r = i + m - 1;
if (hat == geth(i, r)) {
int tp = r % n + 1;
adj[i].push_back(tp);
id[tp]++;
}
}
for (int i = 1; i <= n; i++) {
if (id[i] == 0) {
q.push(i);
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
id[v]--;
d[v] = max(d[u] + 1, d[v]);
if (id[v] == 0) {
q.push(v);
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, d[i]);
if (id[i] != 0) {
cout << "-1" << endl;
return 0;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int maxn = 2e6 + 5;
typedef long long ll;
const ll mod = 191981019260817247;
ll base = 233;
ll pw[maxn], ha[maxn];
inline ll mul(ll a, ll b) {
ll k = (ll)((long double)a * b / mod);
ll r = a * b - mod * k;
if (r < 0)
r += mod;
if (r >= mod)
r -= mod;
return r;
}
inline ll geth(int l, int r) {
return (ha[r] - mul(pw[r - l + 1], ha[l - 1]) + mod) % mod;
}
vector<int> adj[maxn];
int d[maxn];
int n, m, len;
char s[maxn], t[maxn];
int id[maxn];
queue<int> q;
int main() {
scanf("%s", s + 1);
scanf("%s", t + 1);
n = strlen(s + 1);
m = strlen(t + 1);
len = n;
while (len < m + n) {
for (int i = 1; i <= n; i++) {
s[++len] = s[i];
}
}
pw[0] = 1;
for (int i = 1; i <= len; i++) {
pw[i] = mul(pw[i - 1], base);
ha[i] = (mul(ha[i - 1], base) + s[i]) % mod;
}
ll hat = 0;
for (int i = 1; i <= m; i++) {
hat = (mul(hat, base) + t[i]) % mod;
}
for (int i = 1; i <= n; i++) {
int r = i + m - 1;
if (hat == geth(i, r)) {
int tp = r % n + 1;
adj[i].push_back(tp);
id[tp]++;
}
}
for (int i = 1; i <= n; i++) {
if (id[i] == 0) {
q.push(i);
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
id[v]--;
d[v] = max(d[u] + 1, d[v]);
if (id[v] == 0) {
q.push(v);
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, d[i]);
if (id[i] != 0) {
cout << "-1" << endl;
return 0;
}
}
cout << ans << endl;
return 0;
} | [] | 770,561 | 770,563 | u894379040 | cpp |
p02962 | /*input
*/
#include <bits/stdc++.h>
#define up(i, a, b) for (int(i) = (a); (i) <= (b); ++(i))
#define down(i, b, a) for (int(i) = (b); i >= (a); --i)
#define debug(x) cerr << (x) << '\n';
#define bits(x, i) ((x >> i) & 1)
#define mid ((l + r) / 2)
#define pr pair<int, int>
using namespace std;
const int N = 1500005;
int p[N];
int nxt[500005];
int ans[500005];
int ok[500005];
string s, t, tmp;
void KMP() {
int n = tmp.size();
int t_size = t.size();
int len = max(s.size(), t.size()) * 2;
while (s.size() < len)
s += tmp;
s = t + "#" + s;
len = s.size();
// cout << s << '\n';
for (int i = 1; i < len; ++i) {
int j = p[i - 1];
while (j && s[i] != s[j])
j = p[j - 1];
if (s[i] == s[j])
j++;
p[i] = j;
}
memset(nxt, -1, sizeof(nxt));
for (int i = len - n; i < len; ++i) {
if (p[i] == t_size)
nxt[(i - t_size + 1) % n] = (i + 1) % n;
}
// for(int i=0;i<n;++i) cout << nxt[i] << '\n';
int res = 0, cnt = 0;
bool cycle = 0;
for (int i = 0; i < n; ++i) {
if (!ok[i] && nxt[i] != -1) {
int j = i;
ok[j] = ++cnt;
ans[cnt] = 0;
while (nxt[j] != -1) {
j = nxt[j];
ans[cnt]++;
if (ok[j]) {
if (ok[j] == cnt || ans[ok[j]] == -1) {
ans[cnt] = -1;
cycle = 1;
} else
ans[cnt] += ans[ok[j]];
break;
}
ok[j] = cnt;
}
res = max(res, ans[cnt]);
}
}
// for(int i=0;i<n;++i) cout << ok[i] << ' ';
cout << (!cycle ? res : -1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> tmp >> t;
KMP();
}
| /*input
*/
#include <bits/stdc++.h>
#define up(i, a, b) for (int(i) = (a); (i) <= (b); ++(i))
#define down(i, b, a) for (int(i) = (b); i >= (a); --i)
#define debug(x) cerr << (x) << '\n';
#define bits(x, i) ((x >> i) & 1)
#define mid ((l + r) / 2)
#define pr pair<int, int>
using namespace std;
const int N = 2000005;
int p[N];
int nxt[500005];
int ans[500005];
int ok[500005];
string s, t, tmp;
void KMP() {
int n = tmp.size();
int t_size = t.size();
int len = max(tmp.size(), t.size()) * 2;
while (s.size() < len)
s += tmp;
s = t + "#" + s;
len = s.size();
// cout << s << '\n';
for (int i = 1; i < len; ++i) {
int j = p[i - 1];
while (j && s[i] != s[j])
j = p[j - 1];
if (s[i] == s[j])
j++;
p[i] = j;
}
memset(nxt, -1, sizeof(nxt));
for (int i = len - n; i < len; ++i) {
if (p[i] == t_size)
nxt[(i - t_size + 1) % n] = (i + 1) % n;
}
// for(int i=0;i<n;++i) cout << nxt[i] << '\n';
int res = 0, cnt = 0;
bool cycle = 0;
for (int i = 0; i < n; ++i) {
if (!ok[i] && nxt[i] != -1) {
int j = i;
ok[j] = ++cnt;
ans[cnt] = 0;
while (nxt[j] != -1) {
j = nxt[j];
ans[cnt]++;
if (ok[j]) {
if (ok[j] == cnt || ans[ok[j]] == -1) {
ans[cnt] = -1;
cycle = 1;
} else
ans[cnt] += ans[ok[j]];
break;
}
ok[j] = cnt;
}
res = max(res, ans[cnt]);
}
}
// for(int i=0;i<n;++i) cout << ok[i] << ' ';
cout << (!cycle ? res : -1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> tmp >> t;
KMP();
}
| [
"literal.number.change",
"variable_declaration.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 770,578 | 770,577 | u767911011 | cpp |
p02962 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, l, r) for (ll i = (l); i < (r); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) FOR(i, 1, n + 1)
#define RFOR(i, l, r) for (ll i = (l); i >= (r); --i)
#define RREP(i, n) RFOR(i, n - 1, 0)
#define RREPS(i, n) RFOR(i, n, 1)
#define pb push_back
#define eb emplace_back
#define SZ(x) ((ll)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
template <class T = ll> using V = vector<T>;
template <class T = ll> using VV = V<V<T>>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
inline void Yes(bool b = true) { cout << (b ? "Yes" : "No") << '\n'; }
inline void YES(bool b = true) { cout << (b ? "YES" : "NO") << '\n'; }
inline void err(bool b = true) {
if (b) {
cout << -1 << '\n';
exit(0);
}
}
template <class T> inline void fin(bool b = true, T e = 0) {
if (b) {
cout << e << '\n';
exit(0);
}
}
template <class T> T Roundup_div(T x, T y) { return (x + (y - 1)) / y; }
const ll INF = 1e18;
template <typename T> T pow(T a, long long n, T e = 1) {
T ret = e;
while (n) {
if (n & 1)
ret *= a;
a *= a;
n >>= 1;
}
return ret;
}
class RollingHash {
const ll mod = 1e9 + 7;
const ll base = 1007;
V<> hash, power;
public:
RollingHash(const string &s) {
ll n = SZ(s);
hash.assign(n + 1, 0);
power.assign(n + 1, 1);
REP(i, n) {
hash[i + 1] = (hash[i] * base + s[i]) % mod;
power[i + 1] = (power[i] * base) % mod;
}
}
inline ll get(ll l, ll r) const {
ll res = hash[r] - hash[l] * power[r - l] % mod;
if (res < 0)
res += mod;
return res;
}
inline ll s_hash() { return get(0, SZ(hash) - 1); }
inline ll getLCP(int a, int b) const {
ll len = min(SZ(hash) - a, SZ(hash) - b);
ll ok = 0, ng = len;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (get(a, a + mid) != get(b, b + mid))
ng = mid;
else
ok = mid;
}
return ok;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s, t;
cin >> s >> t;
string _ = s;
while (SZ(s) < SZ(t))
s += _;
s += s + s;
RollingHash RH(s);
auto check = [&](ll mid) {
string u = "";
REP(i, mid) u += t;
RollingHash mew(u);
ll c = mew.s_hash();
REP(i, SZ(s) - SZ(t)) {
if (RH.get(i, i + SZ(t)) == c)
return true;
}
return false;
};
ll k = Roundup_div(SZ(s), SZ(t));
ll ok = 0, ng = k;
while (abs(ok - ng) > 1) {
ll m = ok + ng / 2;
if (check(m))
ng = m;
else
ok = m;
}
cout << (ok == k - 1 ? -1 : ok) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, l, r) for (ll i = (l); i < (r); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) FOR(i, 1, n + 1)
#define RFOR(i, l, r) for (ll i = (l); i >= (r); --i)
#define RREP(i, n) RFOR(i, n - 1, 0)
#define RREPS(i, n) RFOR(i, n, 1)
#define pb push_back
#define eb emplace_back
#define SZ(x) ((ll)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
template <class T = ll> using V = vector<T>;
template <class T = ll> using VV = V<V<T>>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
inline void Yes(bool b = true) { cout << (b ? "Yes" : "No") << '\n'; }
inline void YES(bool b = true) { cout << (b ? "YES" : "NO") << '\n'; }
inline void err(bool b = true) {
if (b) {
cout << -1 << '\n';
exit(0);
}
}
template <class T> inline void fin(bool b = true, T e = 0) {
if (b) {
cout << e << '\n';
exit(0);
}
}
template <class T> T Roundup_div(T x, T y) { return (x + (y - 1)) / y; }
const ll INF = 1e18;
template <typename T> T pow(T a, long long n, T e = 1) {
T ret = e;
while (n) {
if (n & 1)
ret *= a;
a *= a;
n >>= 1;
}
return ret;
}
class RollingHash {
const ll mod = 1e9 + 7;
const ll base = 1007;
V<> hash, power;
public:
RollingHash(const string &s) {
ll n = SZ(s);
hash.assign(n + 1, 0);
power.assign(n + 1, 1);
REP(i, n) {
hash[i + 1] = (hash[i] * base + s[i]) % mod;
power[i + 1] = (power[i] * base) % mod;
}
}
inline ll get(ll l, ll r) const {
ll res = hash[r] - hash[l] * power[r - l] % mod;
if (res < 0)
res += mod;
return res;
}
inline ll s_hash() { return get(0, SZ(hash) - 1); }
inline ll getLCP(int a, int b) const {
ll len = min(SZ(hash) - a, SZ(hash) - b);
ll ok = 0, ng = len;
while (abs(ok - ng) > 1) {
ll mid = (ok + ng) / 2;
if (get(a, a + mid) != get(b, b + mid))
ng = mid;
else
ok = mid;
}
return ok;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s, t;
cin >> s >> t;
string _ = s;
while (SZ(s) < SZ(t))
s += _;
s += s + s;
RollingHash RH(s);
auto check = [&](ll mid) {
string u = "";
REP(i, mid) u += t;
RollingHash mew(u);
ll c = mew.s_hash();
REP(i, SZ(s) - SZ(u)) {
if (RH.get(i, i + SZ(u)) == c)
return true;
}
return false;
};
ll k = Roundup_div(SZ(s), SZ(t));
ll ok = 0, ng = k;
while (abs(ok - ng) > 1) {
ll m = (ok + ng) / 2;
if (check(m))
ok = m;
else
ng = m;
}
cout << (ok == k - 1 ? -1 : ok) << endl;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change",
"control_flow.branch.else.remove",
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add",
"assignment.add"
] | 770,605 | 770,604 | u342075214 | cpp |
p02962 | #include <bits/stdc++.h>
using namespace std;
#define boost \
ios::sync_with_stdio(false); \
cin.tie(nullptr)
#define int long long
#include "string"
vector<int> preffix(string s) {
int n = s.size();
vector<int> pi(n, 0);
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 and s[i] != s[j])
j = pi[j - 1];
if (s[i] == s[j])
pi[i] = j + 1;
}
return pi;
}
int kmp(string t, string p) {
vector<int> ans;
int n = t.size();
int m = p.size();
vector<int> pi = preffix(p);
int j = 0;
for (int i = 0; i < n; i++) {
while (j > 0 and t[i] != p[j])
j = pi[j - 1];
if (t[i] == p[j]) {
j++;
if (j == m) {
ans.push_back(i - j + 1);
j = pi[j - 1];
}
}
}
return ans.size();
}
int solve(string s, string t) {
int l = 0, r = s.size() / t.size() + 1, ans = 0;
while (l <= r) {
int m = (l + r) / 2;
string tt = "";
for (int i = 0; i < m; i++)
tt += t;
if (kmp(s, tt) > 0) {
ans = m;
l = m + 1;
} else
r = m - 1;
}
return ans;
}
int32_t main() {
boost;
string S, T;
cin >> S >> T;
string s = S;
while (s.size() <= S.size() + T.size())
s += S;
s += S;
int ans1 = solve(s, T);
s += s;
int ans2 = solve(s, T);
if (ans1 != ans2)
cout << -1 << endl;
else
cout << ans2 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define boost \
ios::sync_with_stdio(false); \
cin.tie(nullptr)
#define int long long
#include "string"
vector<int> preffix(string &s) {
int n = s.size();
vector<int> pi(n, 0);
for (int i = 1; i < n; i++) {
int j = pi[i - 1];
while (j > 0 and s[i] != s[j])
j = pi[j - 1];
if (s[i] == s[j])
pi[i] = j + 1;
}
return pi;
}
int kmp(string &t, string &p) {
vector<int> ans;
int n = t.size();
int m = p.size();
vector<int> pi = preffix(p);
int j = 0;
for (int i = 0; i < n; i++) {
while (j > 0 and t[i] != p[j])
j = pi[j - 1];
if (t[i] == p[j]) {
j++;
if (j == m) {
ans.push_back(i - j + 1);
j = pi[j - 1];
}
}
}
return ans.size();
}
int solve(string &s, string &t) {
int l = 1, r = s.size() / t.size() + 1, ans = 0;
while (l <= r) {
int m = (l + r) / 2;
string tt = "";
for (int i = 0; i < m; i++)
tt += t;
if (kmp(s, tt) > 0) {
ans = m;
l = m + 1;
} else
r = m - 1;
}
return ans;
}
int32_t main() {
boost;
string S, T;
cin >> S >> T;
string s = S;
while (s.size() <= S.size() + T.size())
s += S;
s += S;
int ans1 = solve(s, T);
s += s;
int ans2 = solve(s, T);
if (ans1 != ans2)
cout << -1 << endl;
else
cout << ans2 << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 770,613 | 770,615 | u371555975 | cpp |
p02962 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
typedef long double ld;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define F first
#define S second
constexpr char ln = '\n';
const int mx = 200010;
const ll mod = 1e9 + 7;
vector<int> Z_algorithm(string S) {
int c = 0, n = S.size();
//接頭辞の長さを保存する配列を返す。
// i = 1からやるとする。
// Z[1]には赤下線が存在しないので、「溢れるor共通部分がない」のところにまずいく。
//実装上、上のような挙動をしてもらうため、Z[0]=n;は[1, n -
//1]まで計算が終わった後に入れる。 cは、赤下線の左端の位置。
vector<int> Z(n, 0);
for (int i = 1; i < n; i++) {
int l = i - c;
//今着目してる部分が赤下線の左端から何個分離れているかをlに入れる。
if (i + Z[l] < c + Z[c]) {
//この条件を満たすのは、「青下線が赤下線に収まる」。
//この時、すでに計算されてるなのでそれを流用する。
Z[i] = Z[l];
} else {
//この条件を満たすのは、「赤下線から青下線が溢れる」or「赤下線と青下線の共通部分がない」。
int j = max(0, c + Z[c] - i);
// c + Z[c] - i > 0の時、これは「溢れる」が該当する。
//溢れてるのなら、収まる分は計算せずに、溢れた分(j番目から)だけ愚直に突き合わせればよい。
//そもそも共通部分がないならば、全部突き合わせる。この時、式からj =
//0;となるとわかる。
//愚直に突き合せてる部分
while (i + j < n && S[j] == S[i + j])
j++;
Z[i] = j;
//今の見てるiで、赤下線に完全に含まれなくなったので、今のiを赤下線の左端として、次のiをまた計算する。
c = i;
}
}
//最後にこれを忘れずに
Z[0] = n;
return Z;
}
int main() {
string s, T, Q;
cin >> s >> T;
int sn = s.size();
while (Q.size() < T.size()) {
Q += s;
}
int n = Q.size(), m = T.size();
Q += Q;
auto z = Z_algorithm(T + "+" + Q);
vector<int> chain(n, -1);
for (int i = 0; i < n; i++) {
if (chain[i] != -1)
continue;
int pos = i;
int cnt = 0;
while (z[m + 1 + pos] == m) {
cnt++;
pos = (pos + m) % n;
if (pos == i) {
cout << -1 << ln;
return 0; // loop
}
if (chain[pos] >= 0) {
cnt += chain[pos];
break;
}
chain[pos] = 0;
}
chain[pos] = cnt;
}
ll ans = *max_element(chain.begin(), chain.end());
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
typedef long double ld;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define F first
#define S second
constexpr char ln = '\n';
const int mx = 200010;
const ll mod = 1e9 + 7;
vector<int> Z_algorithm(string S) {
int c = 0, n = S.size();
//接頭辞の長さを保存する配列を返す。
// i = 1からやるとする。
// Z[1]には赤下線が存在しないので、「溢れるor共通部分がない」のところにまずいく。
//実装上、上のような挙動をしてもらうため、Z[0]=n;は[1, n -
//1]まで計算が終わった後に入れる。 cは、赤下線の左端の位置。
vector<int> Z(n, 0);
for (int i = 1; i < n; i++) {
int l = i - c;
//今着目してる部分が赤下線の左端から何個分離れているかをlに入れる。
if (i + Z[l] < c + Z[c]) {
//この条件を満たすのは、「青下線が赤下線に収まる」。
//この時、すでに計算されてるなのでそれを流用する。
Z[i] = Z[l];
} else {
//この条件を満たすのは、「赤下線から青下線が溢れる」or「赤下線と青下線の共通部分がない」。
int j = max(0, c + Z[c] - i);
// c + Z[c] - i > 0の時、これは「溢れる」が該当する。
//溢れてるのなら、収まる分は計算せずに、溢れた分(j番目から)だけ愚直に突き合わせればよい。
//そもそも共通部分がないならば、全部突き合わせる。この時、式からj =
//0;となるとわかる。
//愚直に突き合せてる部分
while (i + j < n && S[j] == S[i + j])
j++;
Z[i] = j;
//今の見てるiで、赤下線に完全に含まれなくなったので、今のiを赤下線の左端として、次のiをまた計算する。
c = i;
}
}
//最後にこれを忘れずに
Z[0] = n;
return Z;
}
int main() {
string s, T, Q;
cin >> s >> T;
int sn = s.size();
while (Q.size() < T.size()) {
Q += s;
}
int n = Q.size(), m = T.size();
Q += Q;
auto z = Z_algorithm(T + "+" + Q);
vector<int> chain(n, -1);
for (int i = 0; i < n; i++) {
if (chain[i] != -1)
continue;
int pos = i;
int cnt = 0;
while (z[m + 1 + pos] == m) {
cnt++;
pos = (pos + m) % n;
if (pos == i) {
cout << -1 << ln;
return 0; // loop
}
if (chain[pos] >= 0) {
cnt += chain[pos];
break;
}
chain[pos] = 0;
}
chain[i] = cnt;
}
ll ans = *max_element(chain.begin(), chain.end());
cout << ans << endl;
return 0;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 770,633 | 770,637 | u980909653 | cpp |
p02962 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
void Z_algo(string &S, vector<int> &v) {
int N = S.size();
v = vector<int>(N, 0);
v[0] = N;
int i = 1, j = 0;
while (i < N) {
while (i + j < N && S[j] == S[i + j]) {
j++;
}
v[i] = j;
// cout << i << " " << j << endl;
int k = 1;
while (i + k < N && k + v[k] < v[i]) {
v[i + k] = v[k];
k++;
}
i += k;
j = max(j - k, 0);
}
return;
}
int main() {
string s, t;
cin >> s >> t;
int N = s.size(), M = t.size();
string u = t;
u += "$";
for (int i = 0; i < (2 * M + N) / N; i++) {
u += s;
}
vector<int> table;
Z_algo(u, table);
vector<int> pre(N);
for (int i = 0; i < N; i++) {
pre[i] = table[M + 1 + i];
}
vector<bool> use(N, false);
int ans = 0;
for (int i = 0; i < N; i++) {
if (use[i])
continue;
if (pre[i] == M) {
continue;
}
use[i] = true;
int j = (i + M) % N;
while (j != i && pre[j] < M && !use[j]) {
use[j] = true;
j += M;
j %= N;
}
if (j == i)
continue;
int cnt = 0;
while (j != i && pre[j] == M && !use[j]) {
cnt++;
use[j] = true;
j += M;
j %= N;
}
ans = max(ans, cnt);
}
if (count(use.begin(), use.end(), true) != N) {
cout << -1 << endl;
return 0;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
void Z_algo(string &S, vector<int> &v) {
int N = S.size();
v = vector<int>(N, 0);
v[0] = N;
int i = 1, j = 0;
while (i < N) {
while (i + j < N && S[j] == S[i + j]) {
j++;
}
v[i] = j;
// cout << i << " " << j << endl;
int k = 1;
while (i + k < N && k + v[k] < v[i]) {
v[i + k] = v[k];
k++;
}
i += k;
j = max(j - k, 0);
}
return;
}
int main() {
string s, t;
cin >> s >> t;
int N = s.size(), M = t.size();
string u = t;
u += "$";
for (int i = 0; i < (2 * M + 2 * N) / N; i++) {
u += s;
}
vector<int> table;
Z_algo(u, table);
vector<int> pre(N);
for (int i = 0; i < N; i++) {
pre[i] = table[M + 1 + i];
}
vector<bool> use(N, false);
int ans = 0;
for (int i = 0; i < N; i++) {
if (use[i])
continue;
if (pre[i] == M) {
continue;
}
use[i] = true;
int j = (i + M) % N;
while (j != i && pre[j] < M && !use[j]) {
use[j] = true;
j += M;
j %= N;
}
if (j == i)
continue;
int cnt = 0;
while (j != i && pre[j] == M && !use[j]) {
cnt++;
use[j] = true;
j += M;
j %= N;
}
ans = max(ans, cnt);
}
if (count(use.begin(), use.end(), true) != N) {
cout << -1 << endl;
return 0;
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 770,656 | 770,658 | u548834738 | cpp |
p02962 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using vc = vector<char>;
using vvc = vector<vc>;
using pll = pair<ll, ll>;
using stkll = vector<pll>;
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
#define rep(i, n) for (ll i = 0; i < (n); i++)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
#ifndef ONLINE_JUDGE
#define debug(x) cerr << #x << ": " << x << endl;
#else
#define debug(x)
#endif
//
// ローリングハッシュ
//
// verified:
// ABC 141 E - Who Says a Pun?
// https://atcoder.jp/contests/abc141/tasks/abc141_e
//
struct RollingHash {
static const int base1 = 1007, base2 = 2009;
static const int mod1 = 1000000007, mod2 = 1000000009;
vector<long long> hash1, hash2, power1, power2;
// construct
RollingHash(const string &S) {
int n = (int)S.size();
hash1.assign(n + 1, 0);
hash2.assign(n + 1, 0);
power1.assign(n + 1, 1);
power2.assign(n + 1, 1);
for (int i = 0; i < n; ++i) {
hash1[i + 1] = (hash1[i] * base1 + S[i]) % mod1;
hash2[i + 1] = (hash2[i] * base2 + S[i]) % mod2;
power1[i + 1] = (power1[i] * base1) % mod1;
power2[i + 1] = (power2[i] * base2) % mod2;
}
}
// get hash of S[left:right]
inline pair<long long, long long> get(int l, int r) const {
long long res1 = hash1[r] - hash1[l] * power1[r - l] % mod1;
if (res1 < 0)
res1 += mod1;
long long res2 = hash2[r] - hash2[l] * power2[r - l] % mod2;
if (res2 < 0)
res2 += mod2;
return {res1, res2};
}
// get lcp of S[a:] and S[b:]
inline int getLCP(int a, int b) const {
int len = min((int)hash1.size() - a, (int)hash1.size() - b);
int low = 0, high = len;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (get(a, a + mid) != get(b, b + mid))
high = mid;
else
low = mid;
}
return low;
}
// get lcp of S[a:] and T[b:]
inline int getLCP(const RollingHash &T, int a, int b) const {
int len = min((int)hash1.size() - a, (int)hash1.size() - b);
int low = 0, high = len;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (get(a, a + mid) != T.get(b, b + mid))
high = mid;
else
low = mid;
}
return low;
}
};
string s, t, s1;
ll n, m;
bool ok[550000];
ll longest[550000];
ll calc_longest(ll i, ll dep = 0) {
if (dep > n)
return -1;
if (longest[i] != -1)
return longest[i];
if (!ok[i])
return longest[i] = 0;
longest[i] = calc_longest((i + m) % n, dep + 1);
if (longest[i] == -1)
return -1;
return longest[i] += 1;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
cin >> s >> t;
n = s.size(), m = t.size();
while (s1.size() < 2 * t.size())
s1 += s;
fill(longest, longest + 550000, -1);
RollingHash rh1(s1), rh2(t);
rep(i, n) if (rh1.get(i, i + m) == rh2.get(0, m)) ok[i] = true;
ll ans = 0;
rep(i, n) {
longest[i] = calc_longest(i);
if (longest[i] == -1) {
cout << -1 << endl;
return 0;
}
chmax(ans, longest[i]);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using vc = vector<char>;
using vvc = vector<vc>;
using pll = pair<ll, ll>;
using stkll = vector<pll>;
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
#define rep(i, n) for (ll i = 0; i < (n); i++)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
#ifndef ONLINE_JUDGE
#define debug(x) cerr << #x << ": " << x << endl;
#else
#define debug(x)
#endif
//
// ローリングハッシュ
//
// verified:
// ABC 141 E - Who Says a Pun?
// https://atcoder.jp/contests/abc141/tasks/abc141_e
//
struct RollingHash {
static const int base1 = 1007, base2 = 2009;
static const int mod1 = 1000000007, mod2 = 1000000009;
vector<long long> hash1, hash2, power1, power2;
// construct
RollingHash(const string &S) {
int n = (int)S.size();
hash1.assign(n + 1, 0);
hash2.assign(n + 1, 0);
power1.assign(n + 1, 1);
power2.assign(n + 1, 1);
for (int i = 0; i < n; ++i) {
hash1[i + 1] = (hash1[i] * base1 + S[i]) % mod1;
hash2[i + 1] = (hash2[i] * base2 + S[i]) % mod2;
power1[i + 1] = (power1[i] * base1) % mod1;
power2[i + 1] = (power2[i] * base2) % mod2;
}
}
// get hash of S[left:right]
inline pair<long long, long long> get(int l, int r) const {
long long res1 = hash1[r] - hash1[l] * power1[r - l] % mod1;
if (res1 < 0)
res1 += mod1;
long long res2 = hash2[r] - hash2[l] * power2[r - l] % mod2;
if (res2 < 0)
res2 += mod2;
return {res1, res2};
}
// get lcp of S[a:] and S[b:]
inline int getLCP(int a, int b) const {
int len = min((int)hash1.size() - a, (int)hash1.size() - b);
int low = 0, high = len;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (get(a, a + mid) != get(b, b + mid))
high = mid;
else
low = mid;
}
return low;
}
// get lcp of S[a:] and T[b:]
inline int getLCP(const RollingHash &T, int a, int b) const {
int len = min((int)hash1.size() - a, (int)hash1.size() - b);
int low = 0, high = len;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (get(a, a + mid) != T.get(b, b + mid))
high = mid;
else
low = mid;
}
return low;
}
};
string s, t, s1;
ll n, m;
bool ok[550000];
ll longest[550000];
ll calc_longest(ll i, ll dep = 0) {
if (dep > n)
return -1;
if (longest[i] != -1)
return longest[i];
if (!ok[i])
return longest[i] = 0;
longest[i] = calc_longest((i + m) % n, dep + 1);
if (longest[i] == -1)
return -1;
return longest[i] += 1;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
cin >> s >> t;
n = s.size(), m = t.size();
while (s1.size() < 2 * max(n, m))
s1 += s;
fill(longest, longest + 550000, -1);
RollingHash rh1(s1), rh2(t);
rep(i, n) if (rh1.get(i, i + m) == rh2.get(0, m)) ok[i] = true;
ll ans = 0;
rep(i, n) {
longest[i] = calc_longest(i);
if (longest[i] == -1) {
cout << -1 << endl;
return 0;
}
chmax(ans, longest[i]);
}
cout << ans << endl;
} | [
"control_flow.loop.condition.change",
"call.arguments.add"
] | 770,718 | 770,719 | u318785595 | cpp |
p02962 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using piii = pair<pair<int, int>, int>;
using pll = pair<ll, ll>;
using pli = pair<ll, int>;
using pil = pair<int, ll>;
using uint = unsigned int;
template <typename T> using Graph = vector<vector<T>>;
const int MOD = 1e9 + 7;
const ld PI = acosl(-1);
struct RollingHash {
static const ull mod1 = (1ULL << 61) - 1, mod2 = (1ULL << 31) - 1;
static const ull base1 = 9733, base2 = 9973;
static const ull p1 = mod1 * 3, p2 = mod2 * 2;
int N;
vector<ull> hash1, hash2, power1, power2;
RollingHash(string &S) {
N = S.length();
hash1.assign(N + 1, 0);
hash2.assign(N + 1, 0);
power1.assign(N + 1, 1);
power2.assign(N + 1, 1);
for (int i = 0; i < N; ++i) {
hash1[i + 1] = calcmod1(mul1(hash1[i], base1) + S[i]);
hash2[i + 1] = calcmod2(mul2(hash2[i], base2) + S[i]);
power1[i + 1] = calcmod1(mul1(power1[i], base1));
power2[i + 1] = calcmod2(mul2(power2[i], base2));
}
}
inline ull mul1(ull a, ull b) {
ull au = a >> 31, ad = a & mod2;
ull bu = b >> 31, bd = b & mod2;
ull c = au * bd + ad * bu;
ull cu = c >> 30, cd = c & (mod2 >> 1);
return 2 * au * bu + ad * bd + cu + (cd << 31);
}
inline ull mul2(ull a, ull b) {
ull c = a * b;
ull cu = c >> 31, cd = c & mod2;
return cu + cd;
}
inline ull calcmod1(ull a) {
ull au = a >> 61, ad = a & mod1;
ull res = au + ad;
if (res >= mod1)
res -= mod1;
return res;
}
inline ull calcmod2(ull a) {
while (a >= mod2)
a -= mod2;
return a;
}
inline pair<ull, ull> get(int l, int r) {
ull res1 = calcmod1(hash1[r] + p1 - mul1(hash1[l], power1[r - l]));
ull res2 = calcmod2(hash2[r] + p2 - mul2(hash2[l], power2[r - l]));
return {res1, res2};
}
inline void search(string &T, vector<int> &G) {
int Slen = G.size();
int Tlen = T.length();
pair<ull, ull> t_hash = {0, 0};
for (int i = 0; i < Tlen; ++i) {
t_hash.first = calcmod1(mul1(t_hash.first, base1) + T[i]);
t_hash.second = calcmod2(mul2(t_hash.second, base2) + T[i]);
}
for (int i = 0; i + Tlen <= N; ++i) {
pair<ull, ull> s_hash = get(i, i + Tlen);
if (s_hash == t_hash)
G[i % Slen] = (i + Tlen) % Slen;
}
}
};
vector<int> cnt;
vector<bool> seen;
int dfs(int v, vector<int> &G) {
if (v == -1)
return -1;
if (seen[v])
return (cnt[v] == -1 ? 1e9 : cnt[v]);
seen[v] = true;
return cnt[v] = dfs(G[v], G) + 1;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
int slen = s.length(), tlen = t.length();
while (s.length() < tlen)
s += s;
RollingHash rhs(s);
vector<int> G(slen, -1);
rhs.search(t, G);
int ans = 0;
cnt.resize(slen, -1);
seen.resize(slen);
for (int i = 0; i < slen; ++i) {
if (seen[i])
continue;
ans = max(ans, dfs(i, G));
}
cout << (ans < 1e9 ? ans : -1) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using piii = pair<pair<int, int>, int>;
using pll = pair<ll, ll>;
using pli = pair<ll, int>;
using pil = pair<int, ll>;
using uint = unsigned int;
template <typename T> using Graph = vector<vector<T>>;
const int MOD = 1e9 + 7;
const ld PI = acosl(-1);
struct RollingHash {
static const ull mod1 = (1ULL << 61) - 1, mod2 = (1ULL << 31) - 1;
static const ull base1 = 9733, base2 = 9973;
static const ull p1 = mod1 * 3, p2 = mod2 * 2;
int N;
vector<ull> hash1, hash2, power1, power2;
RollingHash(string &S) {
N = S.length();
hash1.assign(N + 1, 0);
hash2.assign(N + 1, 0);
power1.assign(N + 1, 1);
power2.assign(N + 1, 1);
for (int i = 0; i < N; ++i) {
hash1[i + 1] = calcmod1(mul1(hash1[i], base1) + S[i]);
hash2[i + 1] = calcmod2(mul2(hash2[i], base2) + S[i]);
power1[i + 1] = calcmod1(mul1(power1[i], base1));
power2[i + 1] = calcmod2(mul2(power2[i], base2));
}
}
inline ull mul1(ull a, ull b) {
ull au = a >> 31, ad = a & mod2;
ull bu = b >> 31, bd = b & mod2;
ull c = au * bd + ad * bu;
ull cu = c >> 30, cd = c & (mod2 >> 1);
return 2 * au * bu + ad * bd + cu + (cd << 31);
}
inline ull mul2(ull a, ull b) {
ull c = a * b;
ull cu = c >> 31, cd = c & mod2;
return cu + cd;
}
inline ull calcmod1(ull a) {
ull au = a >> 61, ad = a & mod1;
ull res = au + ad;
if (res >= mod1)
res -= mod1;
return res;
}
inline ull calcmod2(ull a) {
while (a >= mod2)
a -= mod2;
return a;
}
inline pair<ull, ull> get(int l, int r) {
ull res1 = calcmod1(hash1[r] + p1 - mul1(hash1[l], power1[r - l]));
ull res2 = calcmod2(hash2[r] + p2 - mul2(hash2[l], power2[r - l]));
return {res1, res2};
}
inline void search(string &T, vector<int> &G) {
int Slen = G.size();
int Tlen = T.length();
pair<ull, ull> t_hash = {0, 0};
for (int i = 0; i < Tlen; ++i) {
t_hash.first = calcmod1(mul1(t_hash.first, base1) + T[i]);
t_hash.second = calcmod2(mul2(t_hash.second, base2) + T[i]);
}
for (int i = 0; i + Tlen <= N; ++i) {
pair<ull, ull> s_hash = get(i, i + Tlen);
if (s_hash == t_hash)
G[i % Slen] = (i + Tlen) % Slen;
}
}
};
vector<int> cnt;
vector<bool> seen;
int dfs(int v, vector<int> &G) {
if (v == -1)
return -1;
if (seen[v])
return (cnt[v] == -1 ? 1e9 : cnt[v]);
seen[v] = true;
return cnt[v] = dfs(G[v], G) + 1;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
int slen = s.length(), tlen = t.length();
while (s.length() < slen + tlen)
s += s;
RollingHash rhs(s);
vector<int> G(slen, -1);
rhs.search(t, G);
int ans = 0;
cnt.resize(slen, -1);
seen.resize(slen);
for (int i = 0; i < slen; ++i) {
if (seen[i])
continue;
ans = max(ans, dfs(i, G));
}
cout << (ans < 1e9 ? ans : -1) << endl;
return 0;
}
| [
"control_flow.loop.condition.change"
] | 770,720 | 770,721 | u463243362 | cpp |
p02962 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef pair<ll, ll> P;
typedef vector<P> vpl;
typedef tuple<ll, ll, ll> tapu;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (int i = (a); i < (b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1 << 30;
const ll linf = 1LL << 62;
const int MAX = 510000;
ll dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const double pi = acos(-1);
const double eps = 1e-7;
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <typename T1, typename T2> inline void print2(T1 a, T2 b) {
cout << a << " " << b << "\n";
}
template <typename T1, typename T2, typename T3>
inline void print3(T1 a, T2 b, T3 c) {
cout << a << " " << b << " " << c << "\n";
}
const int mod = 1e9 + 7;
// const int mod = 998244353;
vector<int> z_algorithm(const string &s) {
vector<int> prefix(s.size());
for (int i = 1, j = 0; i < s.size(); i++) {
if (i + prefix[i - j] < j + prefix[j]) {
prefix[i] = prefix[i - j];
} else {
int k = max(0, j + prefix[j] - i);
while (i + k < s.size() && s[k] == s[i + k])
++k;
prefix[i] = k;
j = i;
}
}
prefix[0] = (int)s.size();
return prefix;
}
vector<int> z;
vl rec(505050, -1);
ll n, m;
ll dfs(ll now, ll start, bool st) {
if (rec[now] != -1)
return rec[now];
ll res = 0;
if (!st && now == start) {
return rec[now] = inf;
}
if (z[now + m + 1] == m) {
res = dfs((now + m) % n, start, false) + 1;
}
return rec[now] = res;
}
int main() {
string s, t;
cin >> s >> t;
n = s.size();
m = t.size();
string u = s;
while (s.size() < 3 * m)
s += u;
u = t;
u.push_back('#');
u += s;
z = z_algorithm(u);
ll ans = 0;
rep(i, n) { chmax(ans, dfs(i, i, true)); }
if (ans < inf)
cout << ans << endl;
else
cout << -1 << endl;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef pair<ll, ll> P;
typedef vector<P> vpl;
typedef tuple<ll, ll, ll> tapu;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (int i = (a); i < (b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1 << 30;
const ll linf = 1LL << 62;
const int MAX = 510000;
ll dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const double pi = acos(-1);
const double eps = 1e-7;
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <typename T1, typename T2> inline void print2(T1 a, T2 b) {
cout << a << " " << b << "\n";
}
template <typename T1, typename T2, typename T3>
inline void print3(T1 a, T2 b, T3 c) {
cout << a << " " << b << " " << c << "\n";
}
const int mod = 1e9 + 7;
// const int mod = 998244353;
vector<int> z_algorithm(const string &s) {
vector<int> prefix(s.size());
for (int i = 1, j = 0; i < s.size(); i++) {
if (i + prefix[i - j] < j + prefix[j]) {
prefix[i] = prefix[i - j];
} else {
int k = max(0, j + prefix[j] - i);
while (i + k < s.size() && s[k] == s[i + k])
++k;
prefix[i] = k;
j = i;
}
}
prefix[0] = (int)s.size();
return prefix;
}
vector<int> z;
vl rec(505050, -1);
ll n, m;
ll dfs(ll now, ll start, bool st) {
if (rec[now] != -1)
return rec[now];
ll res = 0;
if (!st && now == start) {
return rec[now] = inf;
}
if (z[now + m + 1] == m) {
res = dfs((now + m) % n, start, false) + 1;
}
return rec[now] = res;
}
int main() {
string s, t;
cin >> s >> t;
n = s.size();
m = t.size();
string u = s;
while (s.size() < 2 * m)
s += u;
s += s;
u = t;
u.push_back('#');
u += s;
z = z_algorithm(u);
ll ans = 0;
rep(i, n) { chmax(ans, dfs(i, i, true)); }
if (ans < inf)
cout << ans << endl;
else
cout << -1 << endl;
} | [
"literal.number.change",
"control_flow.loop.condition.change",
"assignment.add"
] | 770,730 | 770,731 | u242679311 | cpp |
p02962 | #include <bits/stdc++.h>
#define all(vec) vec.begin(), vec.end()
#define pb push_back
#define eb emplace_back
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
template <class T> using V = vector<T>;
constexpr ll INF = (1LL << 30) - 1LL;
constexpr ll MOD = 1e9 + 7;
constexpr int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
template <class T> void chmin(T &a, T b) { a = min(a, b); }
template <class T> void chmax(T &a, T b) { a = max(a, b); }
void ok() { cerr << "ok" << endl; }
using ull = uint64_t;
const int bases[64] = {257, 262, 266, 275, 276, 281, 285, 290, 296, 302, 306,
310, 311, 313, 323, 333, 344, 345, 350, 357, 367, 370,
373, 402, 423, 425, 431, 440, 442, 443, 454, 457, 458,
462, 471, 478, 481, 487, 489, 492, 499, 501, 502, 503,
506, 514, 524, 532, 535, 541, 550, 552, 557, 559, 562,
563, 567, 570, 571, 580, 592, 597, 604, 612};
const ull rmod = 0x1fffffffffffffff;
const ull base = bases[chrono::duration_cast<chrono::microseconds>(
chrono::system_clock::now().time_since_epoch())
.count() &
63];
const ull mask30 = (1UL << 30) - 1, mask31 = (1UL << 31) - 1;
struct RollingHash {
vector<ull> hash, pow;
inline ull mul(const ull &a, const ull &b) const {
ull mid = (a & mask31) * (b >> 31) + (a >> 31) * (b & mask31);
ull res = (a >> 31) * (b >> 31) * 2 + (mid >> 30) + ((mid & mask30) << 31);
res += (a & mask31) * (b & mask31);
res = (res >> 61) + (res & rmod);
if (res >= rmod)
res -= rmod;
return res;
}
RollingHash(const string &s) {
hash.resize(s.length() + 1);
pow.resize(s.length() + 1);
pow[0] = 1;
for (int i = 0; i < s.length(); i++) {
hash[i + 1] = mul(hash[i], base) + s[i];
pow[i + 1] = mul(pow[i], base);
if (hash[i + 1] >= rmod)
hash[i + 1] -= rmod;
}
}
ull get(int l, int r) { //[l,r]
ull res = hash[r + 1] + rmod - mul(hash[l + 1], pow[r - l]);
if (res >= rmod)
res -= rmod;
return res;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
int n = s.length(), m = t.length();
while (s.length() < n + m) {
s += s;
}
RollingHash hs(s), ht(t);
vector<int> f(n), vis(n, -1);
for (int i = 0; i < n; i++) {
if (hs.get(i, i + m - 1) == ht.get(0, m - 1)) {
f[i] = 1;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!f[i] || vis[i] != -1) {
continue;
}
int co = 0, id = i;
vector<int> v;
while (1) {
v.push_back(id);
co++;
id += m;
id %= n;
if (f[id]) {
if (id == i) {
cout << -1 << endl;
return 0;
}
if (vis[id] != -1) {
co += vis[id];
break;
}
vis[id] = 0;
} else {
break;
}
}
vis[i] = co;
chmax(ans, co);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define all(vec) vec.begin(), vec.end()
#define pb push_back
#define eb emplace_back
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
template <class T> using V = vector<T>;
constexpr ll INF = (1LL << 30) - 1LL;
constexpr ll MOD = 1e9 + 7;
constexpr int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
template <class T> void chmin(T &a, T b) { a = min(a, b); }
template <class T> void chmax(T &a, T b) { a = max(a, b); }
void ok() { cerr << "ok" << endl; }
using ull = uint64_t;
const int bases[64] = {257, 262, 266, 275, 276, 281, 285, 290, 296, 302, 306,
310, 311, 313, 323, 333, 344, 345, 350, 357, 367, 370,
373, 402, 423, 425, 431, 440, 442, 443, 454, 457, 458,
462, 471, 478, 481, 487, 489, 492, 499, 501, 502, 503,
506, 514, 524, 532, 535, 541, 550, 552, 557, 559, 562,
563, 567, 570, 571, 580, 592, 597, 604, 612};
const ull rmod = 0x1fffffffffffffff;
const ull base = bases[chrono::duration_cast<chrono::microseconds>(
chrono::system_clock::now().time_since_epoch())
.count() &
63];
const ull mask30 = (1UL << 30) - 1, mask31 = (1UL << 31) - 1;
struct RollingHash {
vector<ull> hash, pow;
inline ull mul(const ull &a, const ull &b) const {
ull mid = (a & mask31) * (b >> 31) + (a >> 31) * (b & mask31);
ull res = (a >> 31) * (b >> 31) * 2 + (mid >> 30) + ((mid & mask30) << 31);
res += (a & mask31) * (b & mask31);
res = (res >> 61) + (res & rmod);
if (res >= rmod)
res -= rmod;
return res;
}
RollingHash(const string &s) {
hash.resize(s.length() + 1);
pow.resize(s.length() + 1);
pow[0] = 1;
for (int i = 0; i < s.length(); i++) {
hash[i + 1] = mul(hash[i], base) + s[i];
pow[i + 1] = mul(pow[i], base);
if (hash[i + 1] >= rmod)
hash[i + 1] -= rmod;
}
}
ull get(int l, int r) { //[l,r]
ull res = hash[r + 1] + rmod - mul(hash[l], pow[r + 1 - l]);
if (res >= rmod)
res -= rmod;
return res;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
int n = s.length(), m = t.length();
while (s.length() < n + m) {
s += s;
}
RollingHash hs(s), ht(t);
vector<int> f(n), vis(n, -1);
for (int i = 0; i < n; i++) {
if (hs.get(i, i + m - 1) == ht.get(0, m - 1)) {
f[i] = 1;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!f[i] || vis[i] != -1) {
continue;
}
int co = 0, id = i;
vector<int> v;
while (1) {
v.push_back(id);
co++;
id += m;
id %= n;
if (f[id]) {
if (id == i) {
cout << -1 << endl;
return 0;
}
if (vis[id] != -1) {
co += vis[id];
break;
}
vis[id] = 0;
} else {
break;
}
}
vis[i] = co;
chmax(ans, co);
}
cout << ans << endl;
}
| [
"expression.operation.binary.remove"
] | 770,732 | 770,733 | u924339359 | cpp |
p02962 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
class Solution {
public:
int solve(string &s, string &t) {
string S = s;
while (S.length() < t.length()) {
S += s;
}
int n = S.length();
S += S;
int m = t.length();
vector<int> next(m + 1, -1);
for (int i = 0, j = -1; i < n; ++i) {
while (j != -1 && t[j] != t[i]) {
j = next[j];
}
next[i + 1] = ++j;
}
vector<int> pos;
for (int i = 0, j = 0; i < S.length(); ++i) {
if (S[i] == t[j]) {
if (++j == m) {
int beg = i - m + 1;
pos.push_back(beg % n);
j = next[j];
}
} else {
while (j != -1 && S[i] != t[j]) {
j = next[j];
}
if (j == -1) {
j = 0;
} else {
--i;
}
}
}
vector<vector<int>> graph(n);
vector<int> degrees(n, 0);
vector<bool> ok(n, false);
for (auto x : pos) {
ok[x] = true;
}
for (int i = 0; i < n; ++i) {
if (ok[i]) {
int j = (i + m) % n;
if (ok[j]) {
graph[i].push_back(j);
degrees[j] += 1;
}
}
}
vector<int> ord;
for (int i = 0; i < n; ++i) {
if (degrees[i] == 0) {
ord.push_back(i);
}
}
for (int i = 0; i < ord.size(); ++i) {
int u = ord[i];
for (auto v : graph[u]) {
if (--degrees[v] == 0) {
ord.push_back(v);
}
}
}
for (int i = 0; i < n; ++i) {
if (degrees[i] != 0) {
return -1;
}
}
reverse(ord.begin(), ord.end());
vector<int> dp(n, 0);
for (auto u : ord) {
if (!ok[u]) {
continue;
}
int ans = 0;
for (auto v : graph[u]) {
ans = max(ans, dp[v]);
}
ans += 1;
dp[u] = ans;
}
int res = *max_element(dp.begin(), dp.end());
return res;
}
};
int main(int argc, char **argv) {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
string t;
cin >> s >> t;
Solution sol;
cout << sol.solve(s, t) << "\n";
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
class Solution {
public:
int solve(string &s, string &t) {
string S = s;
while (S.length() < t.length()) {
S += s;
}
int n = S.length();
S += S;
int m = t.length();
vector<int> next(m + 1, -1);
for (int i = 0, j = -1; i < m; ++i) {
while (j != -1 && t[j] != t[i]) {
j = next[j];
}
next[i + 1] = ++j;
}
vector<int> pos;
for (int i = 0, j = 0; i < S.length(); ++i) {
if (S[i] == t[j]) {
if (++j == m) {
int beg = i - m + 1;
pos.push_back(beg % n);
j = next[j];
}
} else {
while (j != -1 && S[i] != t[j]) {
j = next[j];
}
if (j == -1) {
j = 0;
} else {
--i;
}
}
}
vector<vector<int>> graph(n);
vector<int> degrees(n, 0);
vector<bool> ok(n, false);
for (auto x : pos) {
ok[x] = true;
}
for (int i = 0; i < n; ++i) {
if (ok[i]) {
int j = (i + m) % n;
if (ok[j]) {
graph[i].push_back(j);
degrees[j] += 1;
}
}
}
vector<int> ord;
for (int i = 0; i < n; ++i) {
if (degrees[i] == 0) {
ord.push_back(i);
}
}
for (int i = 0; i < ord.size(); ++i) {
int u = ord[i];
for (auto v : graph[u]) {
if (--degrees[v] == 0) {
ord.push_back(v);
}
}
}
for (int i = 0; i < n; ++i) {
if (degrees[i] != 0) {
return -1;
}
}
reverse(ord.begin(), ord.end());
vector<int> dp(n, 0);
for (auto u : ord) {
if (!ok[u]) {
continue;
}
int ans = 0;
for (auto v : graph[u]) {
ans = max(ans, dp[v]);
}
ans += 1;
dp[u] = ans;
}
int res = *max_element(dp.begin(), dp.end());
return res;
}
};
int main(int argc, char **argv) {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
string t;
cin >> s >> t;
Solution sol;
cout << sol.solve(s, t) << "\n";
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 770,734 | 770,735 | u459402168 | cpp |
p02962 | #include <algorithm>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s, t;
cin >> s;
cin >> t;
int slen = s.length(), tlen = t.length();
s = t + '#' + s;
for (int i = 0; i < t.length(); i++) {
s += s[tlen + 1 + i % s.length()];
}
int z[s.length()];
z[0] = 0;
int j0 = 0, j1 = 0;
for (int i = 1; i < s.length(); i++) {
if (i > j0) {
j0 = j1 = i;
}
if (i + z[i - j0] < j1) {
z[i] = z[i - j0];
} else {
j0 = i;
while (j1 < s.length() && s[j1] == s[j1 - j0]) {
j1++;
}
z[i] = j1 - j0;
}
}
return 0;
bool v[slen];
memset(v, false, sizeof(v));
int ans = 0;
for (int i = 0; i < slen; i++) {
if (!v[i] && z[tlen + 1 + i] == tlen) {
int x = i;
int cnt = 0;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = ((x - tlen) % slen + slen) % slen;
}
if (v[x]) {
cout << -1 << endl;
return 0;
}
x = (i + tlen) % slen;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = (x + tlen) % slen;
}
ans = max(ans, cnt);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s, t;
cin >> s;
cin >> t;
int slen = s.length(), tlen = t.length();
s = t + '#' + s;
for (int i = 0; i < t.length(); i++) {
s += s[tlen + 1 + i % s.length()];
}
int z[s.length()];
z[0] = 0;
int j0 = 0, j1 = 0;
for (int i = 1; i < s.length(); i++) {
if (i >= j1) {
j0 = j1 = i;
}
if (i + z[i - j0] < j1) {
z[i] = z[i - j0];
} else {
j0 = i;
while (j1 < s.length() && s[j1] == s[j1 - j0]) {
j1++;
}
z[i] = j1 - j0;
}
}
bool v[slen];
memset(v, false, sizeof(v));
int ans = 0;
for (int i = 0; i < slen; i++) {
if (!v[i] && z[tlen + 1 + i] == tlen) {
int x = i;
int cnt = 0;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = ((x - tlen) % slen + slen) % slen;
}
if (v[x]) {
cout << -1 << endl;
return 0;
}
x = (i + tlen) % slen;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = (x + tlen) % slen;
}
ans = max(ans, cnt);
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 770,781 | 770,782 | u587665681 | cpp |
p02962 | #include <algorithm>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s, t;
cin >> s;
cin >> t;
int slen = s.length(), tlen = t.length();
s = t + '#' + s;
for (int i = 0; i < t.length(); i++) {
s += s[tlen + 1 + i % s.length()];
}
return 0;
int z[s.length()];
z[0] = 0;
int j0 = 0, j1 = 0;
for (int i = 1; i < s.length(); i++) {
if (i > j0) {
j0 = j1 = i;
}
if (i + z[i - j0] < j1) {
z[i] = z[i - j0];
} else {
j0 = i;
while (j1 < s.length() && s[j1] == s[j1 - j0]) {
j1++;
}
z[i] = j1 - j0;
}
}
bool v[slen];
memset(v, false, sizeof(v));
int ans = 0;
for (int i = 0; i < slen; i++) {
if (!v[i] && z[tlen + 1 + i] == tlen) {
int x = i;
int cnt = 0;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = ((x - tlen) % slen + slen) % slen;
}
if (v[x]) {
cout << -1 << endl;
return 0;
}
x = (i + tlen) % slen;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = (x + tlen) % slen;
}
ans = max(ans, cnt);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s, t;
cin >> s;
cin >> t;
int slen = s.length(), tlen = t.length();
s = t + '#' + s;
for (int i = 0; i < t.length(); i++) {
s += s[tlen + 1 + i % s.length()];
}
int z[s.length()];
z[0] = 0;
int j0 = 0, j1 = 0;
for (int i = 1; i < s.length(); i++) {
if (i >= j1) {
j0 = j1 = i;
}
if (i + z[i - j0] < j1) {
z[i] = z[i - j0];
} else {
j0 = i;
while (j1 < s.length() && s[j1] == s[j1 - j0]) {
j1++;
}
z[i] = j1 - j0;
}
}
bool v[slen];
memset(v, false, sizeof(v));
int ans = 0;
for (int i = 0; i < slen; i++) {
if (!v[i] && z[tlen + 1 + i] == tlen) {
int x = i;
int cnt = 0;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = ((x - tlen) % slen + slen) % slen;
}
if (v[x]) {
cout << -1 << endl;
return 0;
}
x = (i + tlen) % slen;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = (x + tlen) % slen;
}
ans = max(ans, cnt);
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 770,783 | 770,782 | u587665681 | cpp |
p02962 | #include <algorithm>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s, t;
cin >> s;
cin >> t;
int slen = s.length(), tlen = t.length();
s = t + '#' + s;
for (int i = 0; i < t.length(); i++) {
s += s[i % s.length()];
}
int z[s.length()];
z[0] = 0;
int j0 = 0, j1 = 0;
for (int i = 1; i < s.length(); i++) {
if (i > j0) {
j0 = j1 = i;
}
if (i + z[i - j0] < j1) {
z[i] = z[i - j0];
} else {
j0 = i;
while (j1 < s.length() && s[j1] == s[j1 - j0]) {
j1++;
}
z[i] = j1 - j0;
}
}
bool v[slen];
memset(v, false, sizeof(v));
int ans = 0;
for (int i = 0; i < slen; i++) {
if (!v[i] && z[tlen + 1 + i] == tlen) {
int x = i;
int cnt = 0;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = ((x - tlen) % slen + slen) % slen;
}
if (v[x]) {
cout << -1 << endl;
return 0;
}
x = (i + tlen) % slen;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = (x + tlen) % slen;
}
ans = max(ans, cnt);
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main() {
ios::sync_with_stdio(false);
string s, t;
cin >> s;
cin >> t;
int slen = s.length(), tlen = t.length();
s = t + '#' + s;
for (int i = 0; i < t.length(); i++) {
s += s[tlen + 1 + i % s.length()];
}
int z[s.length()];
z[0] = 0;
int j0 = 0, j1 = 0;
for (int i = 1; i < s.length(); i++) {
if (i >= j1) {
j0 = j1 = i;
}
if (i + z[i - j0] < j1) {
z[i] = z[i - j0];
} else {
j0 = i;
while (j1 < s.length() && s[j1] == s[j1 - j0]) {
j1++;
}
z[i] = j1 - j0;
}
}
bool v[slen];
memset(v, false, sizeof(v));
int ans = 0;
for (int i = 0; i < slen; i++) {
if (!v[i] && z[tlen + 1 + i] == tlen) {
int x = i;
int cnt = 0;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = ((x - tlen) % slen + slen) % slen;
}
if (v[x]) {
cout << -1 << endl;
return 0;
}
x = (i + tlen) % slen;
while (!v[x] && z[tlen + 1 + x] == tlen) {
v[x] = true;
cnt++;
x = (x + tlen) % slen;
}
ans = max(ans, cnt);
}
}
cout << ans << endl;
return 0;
}
| [
"assignment.change",
"control_flow.loop.for.condition.change"
] | 770,785 | 770,782 | u587665681 | cpp |
p02962 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define IFOR(i, m, n) for (ll i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(v) (v).begin(), (v).end()
#define SZ(x) ll(x.size())
vector<ll> Zalgo(const string &S) {
ll N = SZ(S);
vector<ll> res(N);
res[0] = N;
ll i = 1, j = 0;
while (i < N) {
while (i + j < N && S[j] == S[i + j])
++j;
res[i] = j;
if (j == 0) {
++i;
continue;
}
ll k = 1;
while (i + k < N && k + res[k] < j)
res[i + k] = res[k], ++k;
i += k, j -= k;
}
return res;
}
int main() {
string s, t;
cin >> s >> t;
ll m = SZ(s), n = SZ(t);
string u = s;
while (SZ(u) < 2 * n) {
u = u + s;
}
u = t + u;
auto lcp = Zalgo(u);
vector<vector<ll>> to(m);
vector<ll> deg(m, 0);
REP(i, m) {
if (lcp[i + n] >= n) {
ll j = (i + n) % m;
to[i].push_back(j);
deg[j]++;
}
}
stack<ll> st;
REP(i, m) if (deg[i] == 0) st.push(i);
// dp[i] = 頂点iを始点とするパス長の最大値
vector<ll> topo, dp(m, 0);
while (!st.empty()) {
ll cv = st.top();
st.pop();
topo.push_back(cv);
FOREACH(nv, to[cv]) {
deg[nv]--;
dp[nv] = max(dp[nv], dp[cv] + 1);
if (deg[nv] == 0)
st.push(nv);
}
}
//トポロジカルソート列に全頂点が格納されていない場合，閉路がある
if (SZ(topo) != m) {
cout << -1 << endl;
return 0;
}
cout << *max_element(ALL(dp)) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define FOR(i, m, n) for (ll i = m; i < n; i++)
#define IFOR(i, m, n) for (ll i = n - 1; i >= m; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(v) (v).begin(), (v).end()
#define SZ(x) ll(x.size())
vector<ll> Zalgo(const string &S) {
ll N = SZ(S);
vector<ll> res(N);
res[0] = N;
ll i = 1, j = 0;
while (i < N) {
while (i + j < N && S[j] == S[i + j])
++j;
res[i] = j;
if (j == 0) {
++i;
continue;
}
ll k = 1;
while (i + k < N && k + res[k] < j)
res[i + k] = res[k], ++k;
i += k, j -= k;
}
return res;
}
int main() {
string s, t;
cin >> s >> t;
ll m = SZ(s), n = SZ(t);
string u = s;
while (SZ(u) <= m + n - 1) {
u = u + u;
}
u = t + u;
auto lcp = Zalgo(u);
vector<vector<ll>> to(m);
vector<ll> deg(m, 0);
REP(i, m) {
if (lcp[i + n] >= n) {
ll j = (i + n) % m;
to[i].push_back(j);
deg[j]++;
}
}
stack<ll> st;
REP(i, m) if (deg[i] == 0) st.push(i);
// dp[i] = 頂点iを始点とするパス長の最大値
vector<ll> topo, dp(m, 0);
while (!st.empty()) {
ll cv = st.top();
st.pop();
topo.push_back(cv);
FOREACH(nv, to[cv]) {
deg[nv]--;
dp[nv] = max(dp[nv], dp[cv] + 1);
if (deg[nv] == 0)
st.push(nv);
}
}
//トポロジカルソート列に全頂点が格納されていない場合，閉路がある
if (SZ(topo) != m) {
cout << -1 << endl;
return 0;
}
cout << *max_element(ALL(dp)) << endl;
return 0;
} | [
"control_flow.loop.condition.change",
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 770,827 | 770,826 | u708550576 | cpp |
p02962 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define DEBUG_ //!!提出時にコメントアウト!!
#ifdef DEBUG_
#define dump(x) cerr << #x << " = " << (x) << endl;
#else
#define dump(x) ;
#endif
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define SZ(x) ((int)(x).size())
#define pb push_back
#define eb emplace_back
//#define int long long
typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
template <typename T> std::string printVector(const std::vector<T> &data) {
std::stringstream ss;
std::ostream_iterator<T> out_it(ss, ", ");
ss << "[";
std::copy(data.begin(), data.end() - 1, out_it);
ss << data.back() << "]";
return ss.str();
}
const int MOD = 1e9 + 7;
const LL LINF = 1001002003004005006ll;
const int INF = 1001001001;
struct RollingHash {
static const int base1 = 1007, base2 = 2009, base3 = 1997;
static const int mod1 = 1000000007, mod2 = 1000000009, mod3 = 1000000087;
vector<long long> hash1, hash2, hash3, power1, power2, power3;
// construct
RollingHash(const string &S) {
int n = (int)S.size();
hash1.assign(n + 1, 0);
hash2.assign(n + 1, 0);
hash3.assign(n + 1, 0);
power1.assign(n + 1, 1);
power2.assign(n + 1, 1);
power3.assign(n + 1, 1);
for (int i = 0; i < n; ++i) {
hash1[i + 1] = (hash1[i] * base1 + S[i]) % mod1;
hash2[i + 1] = (hash2[i] * base2 + S[i]) % mod2;
hash3[i + 1] = (hash3[i] * base3 + S[i]) % mod3;
power1[i + 1] = (power1[i] * base1) % mod1;
power2[i + 1] = (power2[i] * base2) % mod2;
power3[i + 1] = (power3[i] * base3) % mod3;
}
}
// get hash of S[left:right]
// inline pair<long long, long long> get(int l, int r) const {
inline tuple<long long, long long, long long> get(int l, int r) const {
long long res1 = hash1[r] - hash1[l] * power1[r - l] % mod1;
if (res1 < 0)
res1 += mod1;
long long res2 = hash2[r] - hash2[l] * power2[r - l] % mod2;
if (res2 < 0)
res2 += mod2;
long long res3 = hash3[r] - hash3[l] * power3[r - l] % mod3;
if (res3 < 0)
res3 += mod3;
return make_tuple(res1, res2, res3);
}
};
struct TopologicalSort {
vector<vector<int>> E;
TopologicalSort(int N) { E.resize(N); }
void add_edge(int a, int b) { E[a].push_back(b); }
bool visit(int v, vector<int> &order, vector<int> &color) {
color[v] = 1;
for (int u : E[v]) {
if (color[u] == 2)
continue;
if (color[u] == 1)
return false;
if (!visit(u, order, color))
return false;
}
order.push_back(v);
color[v] = 2;
return true;
}
bool sort(vector<int> &order) {
int n = E.size();
vector<int> color(n);
for (int u = 0; u < n; u++) {
if (!color[u] && !visit(u, order, color))
return false;
}
reverse(order.begin(), order.end());
return true;
}
};
int dp[5123456] = {};
signed main(int argc, char const *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
string S, T;
cin >> S >> T;
string tS = S;
int slen = S.length();
int tlen = T.length();
while (tS.length() < 3 * T.length())
tS += S;
RollingHash sh(tS);
RollingHash th(T);
VI match(slen);
REP(i, slen) {
if (sh.get(i, i + tlen) == th.get(0, tlen))
match[i] = 1;
}
TopologicalSort toposo(slen);
REP(i, slen) {
if (match[i]) {
// dump(i)
toposo.add_edge(i, (i + tlen) % slen);
// cerr << "add "<< i << " " << (i+tlen)%slen << endl;
}
}
VI ord;
bool res = toposo.sort(ord);
if (res == false) {
cout << -1 << endl;
} else {
int ans = 0;
for (int cu : ord) {
ans = max(ans, dp[cu]);
for (int to : toposo.E[cu]) {
dp[to] = max(dp[to], dp[cu] + 1);
}
}
cout << ans << endl;
}
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define DEBUG_ //!!提出時にコメントアウト!!
#ifdef DEBUG_
#define dump(x) cerr << #x << " = " << (x) << endl;
#else
#define dump(x) ;
#endif
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define SZ(x) ((int)(x).size())
#define pb push_back
#define eb emplace_back
//#define int long long
typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
template <typename T> std::string printVector(const std::vector<T> &data) {
std::stringstream ss;
std::ostream_iterator<T> out_it(ss, ", ");
ss << "[";
std::copy(data.begin(), data.end() - 1, out_it);
ss << data.back() << "]";
return ss.str();
}
const int MOD = 1e9 + 7;
const LL LINF = 1001002003004005006ll;
const int INF = 1001001001;
struct RollingHash {
static const int base1 = 1007, base2 = 2009, base3 = 1997;
static const int mod1 = 1000000007, mod2 = 1000000009, mod3 = 1000000087;
vector<long long> hash1, hash2, hash3, power1, power2, power3;
// construct
RollingHash(const string &S) {
int n = (int)S.size();
hash1.assign(n + 1, 0);
hash2.assign(n + 1, 0);
hash3.assign(n + 1, 0);
power1.assign(n + 1, 1);
power2.assign(n + 1, 1);
power3.assign(n + 1, 1);
for (int i = 0; i < n; ++i) {
hash1[i + 1] = (hash1[i] * base1 + S[i]) % mod1;
hash2[i + 1] = (hash2[i] * base2 + S[i]) % mod2;
hash3[i + 1] = (hash3[i] * base3 + S[i]) % mod3;
power1[i + 1] = (power1[i] * base1) % mod1;
power2[i + 1] = (power2[i] * base2) % mod2;
power3[i + 1] = (power3[i] * base3) % mod3;
}
}
// get hash of S[left:right]
// inline pair<long long, long long> get(int l, int r) const {
inline tuple<long long, long long, long long> get(int l, int r) const {
long long res1 = hash1[r] - hash1[l] * power1[r - l] % mod1;
if (res1 < 0)
res1 += mod1;
long long res2 = hash2[r] - hash2[l] * power2[r - l] % mod2;
if (res2 < 0)
res2 += mod2;
long long res3 = hash3[r] - hash3[l] * power3[r - l] % mod3;
if (res3 < 0)
res3 += mod3;
return make_tuple(res1, res2, res3);
}
};
struct TopologicalSort {
vector<vector<int>> E;
TopologicalSort(int N) { E.resize(N); }
void add_edge(int a, int b) { E[a].push_back(b); }
bool visit(int v, vector<int> &order, vector<int> &color) {
color[v] = 1;
for (int u : E[v]) {
if (color[u] == 2)
continue;
if (color[u] == 1)
return false;
if (!visit(u, order, color))
return false;
}
order.push_back(v);
color[v] = 2;
return true;
}
bool sort(vector<int> &order) {
int n = E.size();
vector<int> color(n);
for (int u = 0; u < n; u++) {
if (!color[u] && !visit(u, order, color))
return false;
}
reverse(order.begin(), order.end());
return true;
}
};
int dp[5123456] = {};
signed main(int argc, char const *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
string S, T;
cin >> S >> T;
string tS = S;
int slen = S.length();
int tlen = T.length();
while (tS.length() < 3 * T.length())
tS += S;
tS += S;
RollingHash sh(tS);
RollingHash th(T);
VI match(slen);
REP(i, slen) {
if (sh.get(i, i + tlen) == th.get(0, tlen))
match[i] = 1;
}
TopologicalSort toposo(slen);
REP(i, slen) {
if (match[i]) {
// dump(i)
toposo.add_edge(i, (i + tlen) % slen);
// cerr << "add "<< i << " " << (i+tlen)%slen << endl;
}
}
VI ord;
bool res = toposo.sort(ord);
if (res == false) {
cout << -1 << endl;
} else {
int ans = 0;
for (int cu : ord) {
ans = max(ans, dp[cu]);
for (int to : toposo.E[cu]) {
dp[to] = max(dp[to], dp[cu] + 1);
}
}
cout << ans << endl;
}
}
| [
"assignment.add"
] | 770,852 | 770,853 | u077025302 | cpp |
p02962 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define DEBUG_ //!!提出時にコメントアウト!!
#ifdef DEBUG_
#define dump(x) cerr << #x << " = " << (x) << endl;
#else
#define dump(x) ;
#endif
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define SZ(x) ((int)(x).size())
#define pb push_back
#define eb emplace_back
//#define int long long
typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
template <typename T> std::string printVector(const std::vector<T> &data) {
std::stringstream ss;
std::ostream_iterator<T> out_it(ss, ", ");
ss << "[";
std::copy(data.begin(), data.end() - 1, out_it);
ss << data.back() << "]";
return ss.str();
}
const int MOD = 1e9 + 7;
const LL LINF = 1001002003004005006ll;
const int INF = 1001001001;
struct RollingHash {
static const int base1 = 1007, base2 = 2009, base3 = 1997;
static const int mod1 = 1000000007, mod2 = 1000000009, mod3 = 1000000087;
vector<long long> hash1, hash2, hash3, power1, power2, power3;
// construct
RollingHash(const string &S) {
int n = (int)S.size();
hash1.assign(n + 1, 0);
hash2.assign(n + 1, 0);
hash3.assign(n + 1, 0);
power1.assign(n + 1, 1);
power2.assign(n + 1, 1);
power3.assign(n + 1, 1);
for (int i = 0; i < n; ++i) {
hash1[i + 1] = (hash1[i] * base1 + S[i]) % mod1;
hash2[i + 1] = (hash2[i] * base2 + S[i]) % mod2;
hash3[i + 1] = (hash3[i] * base3 + S[i]) % mod3;
power1[i + 1] = (power1[i] * base1) % mod1;
power2[i + 1] = (power2[i] * base2) % mod2;
power3[i + 1] = (power3[i] * base3) % mod3;
}
}
// get hash of S[left:right]
// inline pair<long long, long long> get(int l, int r) const {
inline tuple<long long, long long, long long> get(int l, int r) const {
long long res1 = hash1[r] - hash1[l] * power1[r - l] % mod1;
if (res1 < 0)
res1 += mod1;
long long res2 = hash2[r] - hash2[l] * power2[r - l] % mod2;
if (res2 < 0)
res2 += mod2;
long long res3 = hash3[r] - hash3[l] * power3[r - l] % mod3;
if (res3 < 0)
res3 += mod3;
return make_tuple(res1, res2, res3);
}
};
struct TopologicalSort {
vector<vector<int>> E;
TopologicalSort(int N) { E.resize(N); }
void add_edge(int a, int b) { E[a].push_back(b); }
bool visit(int v, vector<int> &order, vector<int> &color) {
color[v] = 1;
for (int u : E[v]) {
if (color[u] == 2)
continue;
if (color[u] == 1)
return false;
if (!visit(u, order, color))
return false;
}
order.push_back(v);
color[v] = 2;
return true;
}
bool sort(vector<int> &order) {
int n = E.size();
vector<int> color(n);
for (int u = 0; u < n; u++) {
if (!color[u] && !visit(u, order, color))
return false;
}
reverse(order.begin(), order.end());
return true;
}
};
int dp[512345] = {};
signed main(int argc, char const *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
string S, T;
cin >> S >> T;
string tS = S;
int slen = S.length();
int tlen = T.length();
while (tS.length() < 3 * T.length())
tS += S;
RollingHash sh(tS);
RollingHash th(T);
VI match(slen);
REP(i, slen) {
if (sh.get(i, i + tlen) == th.get(0, tlen))
match[i] = 1;
}
TopologicalSort toposo(slen);
REP(i, slen) {
if (match[i]) {
// dump(i)
toposo.add_edge(i, (i + tlen) % slen);
// cerr << "add "<< i << " " << (i+tlen)%slen << endl;
}
}
VI ord;
bool res = toposo.sort(ord);
if (res == false) {
cout << -1 << endl;
} else {
int ans = 0;
for (int cu : ord) {
ans = max(ans, dp[cu]);
for (int to : toposo.E[cu]) {
dp[to] = max(dp[to], dp[cu] + 1);
}
}
cout << ans << endl;
}
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define DEBUG_ //!!提出時にコメントアウト!!
#ifdef DEBUG_
#define dump(x) cerr << #x << " = " << (x) << endl;
#else
#define dump(x) ;
#endif
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define SZ(x) ((int)(x).size())
#define pb push_back
#define eb emplace_back
//#define int long long
typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
template <typename T> std::string printVector(const std::vector<T> &data) {
std::stringstream ss;
std::ostream_iterator<T> out_it(ss, ", ");
ss << "[";
std::copy(data.begin(), data.end() - 1, out_it);
ss << data.back() << "]";
return ss.str();
}
const int MOD = 1e9 + 7;
const LL LINF = 1001002003004005006ll;
const int INF = 1001001001;
struct RollingHash {
static const int base1 = 1007, base2 = 2009, base3 = 1997;
static const int mod1 = 1000000007, mod2 = 1000000009, mod3 = 1000000087;
vector<long long> hash1, hash2, hash3, power1, power2, power3;
// construct
RollingHash(const string &S) {
int n = (int)S.size();
hash1.assign(n + 1, 0);
hash2.assign(n + 1, 0);
hash3.assign(n + 1, 0);
power1.assign(n + 1, 1);
power2.assign(n + 1, 1);
power3.assign(n + 1, 1);
for (int i = 0; i < n; ++i) {
hash1[i + 1] = (hash1[i] * base1 + S[i]) % mod1;
hash2[i + 1] = (hash2[i] * base2 + S[i]) % mod2;
hash3[i + 1] = (hash3[i] * base3 + S[i]) % mod3;
power1[i + 1] = (power1[i] * base1) % mod1;
power2[i + 1] = (power2[i] * base2) % mod2;
power3[i + 1] = (power3[i] * base3) % mod3;
}
}
// get hash of S[left:right]
// inline pair<long long, long long> get(int l, int r) const {
inline tuple<long long, long long, long long> get(int l, int r) const {
long long res1 = hash1[r] - hash1[l] * power1[r - l] % mod1;
if (res1 < 0)
res1 += mod1;
long long res2 = hash2[r] - hash2[l] * power2[r - l] % mod2;
if (res2 < 0)
res2 += mod2;
long long res3 = hash3[r] - hash3[l] * power3[r - l] % mod3;
if (res3 < 0)
res3 += mod3;
return make_tuple(res1, res2, res3);
}
};
struct TopologicalSort {
vector<vector<int>> E;
TopologicalSort(int N) { E.resize(N); }
void add_edge(int a, int b) { E[a].push_back(b); }
bool visit(int v, vector<int> &order, vector<int> &color) {
color[v] = 1;
for (int u : E[v]) {
if (color[u] == 2)
continue;
if (color[u] == 1)
return false;
if (!visit(u, order, color))
return false;
}
order.push_back(v);
color[v] = 2;
return true;
}
bool sort(vector<int> &order) {
int n = E.size();
vector<int> color(n);
for (int u = 0; u < n; u++) {
if (!color[u] && !visit(u, order, color))
return false;
}
reverse(order.begin(), order.end());
return true;
}
};
int dp[5123456] = {};
signed main(int argc, char const *argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
string S, T;
cin >> S >> T;
string tS = S;
int slen = S.length();
int tlen = T.length();
while (tS.length() < 3 * T.length())
tS += S;
tS += S;
RollingHash sh(tS);
RollingHash th(T);
VI match(slen);
REP(i, slen) {
if (sh.get(i, i + tlen) == th.get(0, tlen))
match[i] = 1;
}
TopologicalSort toposo(slen);
REP(i, slen) {
if (match[i]) {
// dump(i)
toposo.add_edge(i, (i + tlen) % slen);
// cerr << "add "<< i << " " << (i+tlen)%slen << endl;
}
}
VI ord;
bool res = toposo.sort(ord);
if (res == false) {
cout << -1 << endl;
} else {
int ans = 0;
for (int cu : ord) {
ans = max(ans, dp[cu]);
for (int to : toposo.E[cu]) {
dp[to] = max(dp[to], dp[cu] + 1);
}
}
cout << ans << endl;
}
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.add"
] | 770,854 | 770,853 | u077025302 | cpp |
p02962 | #include <bits/stdc++.h>
#define fr(i, n) for (int i = 0; i < (n); ++i)
#define foor(i, a, b) for (int i = (a); i <= (b); ++i)
#define rf(i, n) for (int i = (n); i--;)
#define roof(i, b, a) for (int i = (b); i >= (a); --i)
#define elsif else if
#define all(x) x.begin(), x.end()
#define Sort(x) sort(all(x))
#define Reverse(x) reverse(all(x))
#define PQ priority_queue
#define NP(x) next_permutation(all(x))
#define M_PI 3.14159265358979323846
#define popcount __builtin_popcount
using namespace std;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef unsigned long long ull;
typedef vector<ull> vu;
typedef vector<vu> vvu;
typedef double dbl;
typedef vector<dbl> vd;
typedef vector<vd> vvd;
typedef string str;
typedef vector<str> vs;
typedef vector<vs> vvs;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef map<int, int> mii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef map<ll, ll> mll;
typedef pair<dbl, dbl> pdd;
typedef vector<pdd> vpdd;
typedef map<dbl, dbl> mdd;
typedef pair<str, str> pss;
typedef vector<pss> vpss;
typedef map<str, str> mss;
typedef pair<int, ll> pil;
typedef vector<pil> vpil;
typedef map<int, ll> mil;
typedef pair<ll, int> pli;
typedef vector<pli> vpli;
typedef map<ll, int> mli;
typedef pair<dbl, int> pdi;
typedef vector<pdi> vpdi;
typedef map<dbl, int> mdi;
template <typename T> vector<T> &operator<<(vector<T> &v, const T t) {
v.push_back(t);
return v;
}
template <typename T> multiset<T> &operator<<(multiset<T> &m, const T t) {
m.insert(t);
return m;
}
template <typename T> set<T> &operator<<(set<T> &s, const T t) {
s.insert(t);
return s;
}
template <typename T> stack<T> &operator<<(stack<T> &s, const T t) {
s.push(t);
return s;
}
template <typename T> stack<T> &operator>>(stack<T> &s, T &t) {
t = s.top();
s.pop();
return s;
}
template <typename T> queue<T> &operator<<(queue<T> &q, const T t) {
q.push(t);
return q;
}
template <typename T> queue<T> &operator>>(queue<T> &q, T &t) {
t = q.front();
q.pop();
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator<<(PQ<T, vector<T>, U> &q, const T t) {
q.push(t);
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator>>(PQ<T, vector<T>, U> &q, T &t) {
t = q.top();
q.pop();
return q;
}
template <typename T, typename U>
istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
istream &operator>>(istream &s, _Bit_reference b) {
int a;
s >> a;
assert(a == 0 || a == 1);
b = a;
return s;
}
template <typename T> istream &operator>>(istream &s, vector<T> &v) {
fr(i, v.size()) { s >> v[i]; }
return s;
}
template <typename T, typename U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
// template<typename T>ostream&operator<<(ostream&s,const vector<T>v){for(auto
// a:v){s<<a<<"\n";}return s;}
template <typename T> ostream &operator<<(ostream &s, const vector<T> v) {
fr(i, v.size()) { i ? s << " " << v[i] : s << v[i]; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const deque<T> d) {
fr(i, d.size()) { i ? s << " " << d[i] : s << d[i]; }
return s;
}
template <typename T> _Bit_reference operator&=(_Bit_reference b, T t) {
return b = b & t;
}
template <typename T> _Bit_reference operator^=(_Bit_reference b, T t) {
return b = b ^ t;
}
template <typename T> _Bit_reference operator|=(_Bit_reference b, T t) {
return b = b | t;
}
template <typename T, typename U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return {a.first + b.first, a.second + b.second};
}
template <typename T, typename U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return {a.first - b.first, a.second - b.second};
}
template <typename T, typename U>
pair<T, U> &operator+=(pair<T, U> &a, pair<T, U> b) {
return a = a + b;
}
template <typename T, typename U>
pair<T, U> &operator-=(pair<T, U> &a, pair<T, U> b) {
return a = a - b;
}
void print(void) { cout << "\n"; }
void Print(void) { cout << endl; }
template <typename T> void print(T t) { cout << t << "\n"; }
template <typename T> void Print(T t) { cout << t << endl; }
template <typename T, typename... U> void print(T &&t, U &&...u) {
cout << t << " ";
print(forward<U>(u)...);
}
template <typename T, typename... U> void Print(T &&t, U &&...u) {
cout << t << " ";
Print(forward<U>(u)...);
}
bool YN(bool b) {
print(b ? "YES" : "NO");
return b;
}
bool PI(bool b) {
print(b ? "POSSIBLE" : "IMPOSSIBLE");
return b;
}
bool Yn(bool b) {
print(b ? "Yes" : "No");
return b;
}
bool Pi(bool b) {
print(b ? "Possible" : "Impossible");
return b;
}
bool yn(bool b) {
print(b ? "yes" : "no");
return b;
}
bool pi(bool b) {
print(b ? "possible" : "impossible");
return b;
}
const int e5 = 1e5;
const int e9 = 1e9;
const int MD = 1e9 + 7;
const ll e18 = 1e18;
template <typename T> str to_string(const T &n) {
ostringstream s;
s << n;
return s.str();
}
template <typename T> T &chmax(T &a, T b) { return a = max(a, b); }
template <typename T> T &chmin(T &a, T b) { return a = min(a, b); }
template <typename T, typename U>
vector<pair<T, U>> dijkstra(const vector<vector<pair<T, U>>> &E, const U s,
const T inf) {
using P = pair<T, U>;
vector<P> d;
fr(i, E.size()) { d << P{inf, i}; }
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
template <typename T, typename U>
map<U, pair<T, U>> dijkstra(map<U, vector<pair<T, U>>> E, const U s,
const T inf) {
using P = pair<T, U>;
map<U, P> d;
for (pair<U, vector<P>> e : E) {
d[e.first] = P{inf, e.first};
}
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
ll maxflow(vector<mil> &E, int s, int t) {
ll z = 0;
vi b(E.size(), -1);
for (int i = 0;; ++i) {
static auto dfs = [&](int v, ll f, auto &dfs) -> ll {
if (v == t)
return f;
b[v] = i;
for (auto &p : E[v]) {
if (b[p.first] < i && p.second) {
if (ll r = dfs(p.first, min(f, p.second), dfs)) {
p.second -= r;
E[p.first][v] += r;
return r;
}
}
}
return 0;
};
ll x = dfs(s, ll(1e18), dfs);
z += x;
if (x == 0)
return z;
}
}
template <typename T> T distsq(pair<T, T> a, pair<T, T> b) {
return (a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second);
}
template <typename T> T max(const vector<T> a) {
assert(a.size());
T m = a[0];
for (T e : a) {
m = max(m, e);
}
return m;
}
template <typename T> T min(const vector<T> a) {
assert(a.size());
T m = a[0];
for (T e : a) {
m = min(m, e);
}
return m;
}
template <typename T> T gcd(const T a, const T b) {
return a ? gcd(b % a, a) : b;
}
template <typename T> T gcd(const vector<T> a) {
T g = a[0];
for (T e : a) {
g = gcd(g, e);
}
return g;
}
template <typename T> vector<T> LIS(const vector<T> A) {
vector<T> B;
for (T a : A) {
auto it = lower_bound(all(B), a);
if (it == B.end()) {
B << a;
} else {
*it = a;
}
}
return B;
}
template <typename T> vector<T> LCS(vector<T> A, vector<T> B) {
int N = A.size(), M = B.size();
vector<vector<pair<int, pii>>> d(N + 1, vector<pair<int, pii>>(M + 1));
fr(i, N) {
fr(j, M) {
if (A[i] == B[j]) {
d[i + 1][j + 1] = {d[i][j].first + 1, {i, j}};
} else {
d[i + 1][j + 1] = max(d[i][j + 1], d[i + 1][j]);
}
}
}
vector<T> r;
for (pii p = {N, M}; d[p.first][p.second].first;
p = d[p.first][p.second].second) {
r << A[d[p.first][p.second].second.first];
}
Reverse(r);
return r;
}
str LCS(str S, str T) {
vector<char> s =
LCS(vector<char>(S.begin(), S.end()), vector<char>(T.begin(), T.end()));
return str(s.begin(), s.end());
}
template <typename T> vector<pair<T, T>> ConvexHull(vector<pair<T, T>> V) {
if (V.size() <= 3) {
return V;
}
Sort(V);
rf(i, V.size() - 1) V << V[i];
vector<pair<T, T>> r;
for (pair<T, T> p : V) {
int s = r.size();
while (s >= 2 &&
(p.second - r[s - 1].second) * (p.first - r[s - 2].first) <
(p.second - r[s - 2].second) * (p.first - r[s - 1].first)) {
r.pop_back();
--s;
}
r << p;
}
r.pop_back();
return r;
}
class UnionFind {
vi p, s;
void extend(int N) {
foor(i, p.size(), N) {
p << i;
s << 1;
}
}
public:
UnionFind(void) {}
UnionFind(int N) { extend(N - 1); }
int find(int i) {
extend(i);
return p[i] = p[i] == i ? i : find(p[i]);
}
void unite(int a, int b) {
extend(a);
extend(b);
if ((a = find(a)) != (b = find(b))) {
if (s[a] > s[b]) {
swap(a, b);
}
s[b] += s[a];
p[a] = b;
}
}
void unite(pii p) { return unite(p.first, p.second); }
bool same(int a, int b) {
extend(a);
extend(b);
return find(a) == find(b);
}
bool same(pii p) { return same(p.first, p.second); }
int size(int x) {
extend(x);
return s[find(x)];
}
};
ll MST(vector<pair<ll, pii>> &E) {
Sort(E);
UnionFind uf;
ll z = 0;
for (auto &e : E) {
if (!uf.same(e.second)) {
z += e.first;
uf.unite(e.second);
}
}
return z;
}
ll strmod(const str &s, const int m) {
ll x = 0;
fr(i, s.size()) { x = (x * 10 + s[i] - 48) % m; }
return x;
}
vvl mul(const vvl &A, const vvl &B, const int m) {
vvl C;
fr(y, A.size()) { C << vl(B[y].size()); }
fr(y, C.size()) {
fr(x, C[y].size()) {
fr(i, A[0].size()) { (C[y][x] += A[y][i] * B[i][x]) %= m; }
}
}
return C;
}
vvl pow(const vvl &A, const ll n, const int m) {
vvl B;
fr(y, A.size()) { B << vl(A.size()); }
if (n == 0) {
fr(i, B.size()) { B[i][i] = 1; }
}
elsif(n % 2) { B = mul(A, pow(A, n - 1, m), m); }
else {
vvl C = pow(A, n / 2, m);
B = mul(C, C, m);
}
return B;
}
ll pow(const ll a, const ll n, const int m) {
ll t;
return n ? (n & 1 ? a >= 0 ? a % m : (m - (-a % m)) % m : 1) *
(t = pow(a, n >> 1, m), t * t % m) % m
: !!a;
}
ll inv(const ll x, const int p) {
assert(x != 0);
return pow(x, p - 2, p);
}
ll inv(const ll x) { return inv(x, MD); }
vpll fact(const int n, const int p) {
assert(n < p);
vpll v(n + 1);
v[0].first = 1;
foor(i, 1, n) { v[i].first = v[i - 1].first * i % p; }
v[n].second = inv(v[n].first, p);
roof(i, n, 1) { v[i - 1].second = v[i].second * i % p; }
return v;
}
class Combination {
const vpll f;
const int M;
public:
Combination(int n, int m) : f(fact(n, m)), M(m) {}
Combination(int n) : Combination(n, MD) {}
ll P(int n, int k) {
return n < 0 || k < 0 || n < k ? 0ll : f[n].first * f[n - k].second % M;
}
ll C(int n, int k) { return k < 0 ? 0 : P(n, k) * f[k].second % M; }
ll H(int n, int k) { return n == 0 && k == 0 ? 1ll : C(n + k - 1, k); }
ll F(int n) { return n < 0 ? 0 : f[n].first; }
};
ll C2(const int n) { return (ll)n * ~-n / 2; }
ll sum(const vi a) {
ll s = 0;
for (int e : a) {
s += e;
}
return s;
}
ll sum(const vl a) {
ll s = 0;
for (ll e : a) {
s += e;
}
return s;
}
template <typename T> int MSB(T N) {
int r = -1;
for (; N > 0; N /= 2) {
++r;
}
return r;
}
template <typename T> class SegmentTree {
vector<T> S;
T (*const op)(T a, T b);
const T zero;
const int B;
public:
SegmentTree(int N, T (*f)(T a, T b), const T zero)
: S(1 << MSB(N - 1) + 2, zero), op(f), zero(zero),
B(1 << MSB(N - 1) + 1) {}
SegmentTree(vector<T> v, T (*f)(T a, T b), const T zero)
: SegmentTree(v.size(), f, zero) {
fr(i, v.size()) { S[S.size() / 2 + i] = v[i]; }
roof(i, S.size() / 2 - 1, 1) { S[i] = op(S[i * 2], S[i * 2 + 1]); }
}
T calc(int l, int r) {
l += B;
r += B;
if (l > r) {
return zero;
}
if (l == r) {
return S[l];
}
T L = S[l], R = S[r];
for (; l / 2 < r / 2; l /= 2, r /= 2) {
if (l % 2 == 0) {
L = op(L, S[l + 1]);
}
if (r % 2 == 1) {
R = op(S[r - 1], R);
}
}
return op(L, R);
}
void replace(int i, T x) {
for (S[i += B] = x; i != 1; i /= 2) {
if (i % 2) {
S[i / 2] = op(S[i - 1], S[i]);
} else {
S[i / 2] = op(S[i], S[i + 1]);
}
}
}
void add(int i, T x) { replace(i, op(S[B + i], x)); }
T top() { return S[1]; }
T get(int i) { return S[i + B]; }
};
ll BITsum(vl &B, int i) {
ll z = 0;
while (i > 0) {
z += B[i];
i -= i & -i;
}
return z;
}
void BITadd(vl &B, int i, ll x) {
while (i < B.size()) {
B[i] += x;
i += i & -i;
}
}
ll fib(const ll n, const int m) {
ll a, b, c, d, A, B, C, D;
a = 1;
b = 0;
c = 0;
d = 1;
rf(i, 63) {
A = a * a + b * c;
B = a * b + b * d;
C = c * a + d * c;
D = c * b + d * d;
if (n >> i & 1) {
a = A;
b = B;
c = C;
d = D;
A = a + b;
B = a;
C = c + d;
D = c;
}
a = A % m;
b = B % m;
c = C % m;
d = D % m;
}
return b;
}
vi primes(int n) {
vb b(n + 1);
vi p;
foor(i, 2, n) {
if (!b[i]) {
p << i;
for (int j = 2 * i; j <= n; j += i) {
b[j] = true;
}
}
}
return p;
}
vb isprime(const int n) {
vb v(n + 1, true);
v[0] = v[1] = false;
foor(i, 2, n) {
if (v[i]) {
for (int j = 2 * i; j <= n; j += i) {
v[j] = false;
}
}
}
return v;
}
class LCA {
vvi par;
vi dep;
public:
LCA(vvi &E, int root) : par(MSB(E.size()) + 1, vi(E.size())), dep(E.size()) {
function<void(int, int)> dfs = [&](int i, int p) {
for (int j : E[i])
if (j != p) {
par[0][j] = i;
dep[j] = dep[i] + 1;
dfs(j, i);
}
};
par[0][root] = root;
dfs(root, root);
fr(i, par.size() - 1) {
fr(j, par[0].size()) { par[i + 1][j] = par[i][par[i][j]]; }
}
}
int operator()(int a, int b) {
if (dep[a] > dep[b])
swap(a, b);
for (int t = dep[b] - dep[a], i = 0; t; t >>= 1, ++i) {
if (t & 1) {
b = par[i][b];
}
}
if (a == b)
return a;
rf(i, par.size()) {
if (par[i][a] != par[i][b]) {
a = par[i][a];
b = par[i][b];
}
}
return par[0][a];
}
};
vpii factor(int N) {
vpii r;
for (int i = 2; i * i <= N; ++i) {
if (N % i == 0) {
r << pii{i, 0};
while (N % i == 0) {
N /= i;
++r.back().second;
}
}
}
if (N > 1) {
r << pii{N, 1};
}
return r;
}
vl divisors(ll n) {
vl r;
ll m = sqrt(n);
foor(i, 1, m) if (n % i == 0) r << ll(i);
rf(i, r.size() - (m * m == n)) r << n / r[i];
return r;
}
vi SuffixArray(str S) {
int N = S.size();
vi rank(N + 1), tmp(N + 1), sa(N + 1);
fr(i, N) {
sa[i] = i;
rank[i] = S[i];
}
sa[N] = N;
rank[N] = -1;
int k;
auto cmp = [&](int &a, int &b) -> bool {
if (rank[a] != rank[b])
return rank[a] < rank[b];
return (a + k <= N ? rank[a + k] : -1) < (b + k <= N ? rank[b + k] : -1);
};
for (k = 1; k <= N; k *= 2) {
sort(all(sa), cmp);
tmp[sa[0]] = 0;
foor(i, 1, N) { tmp[sa[i]] = tmp[sa[i - 1]] + cmp(sa[i - 1], sa[i]); }
rank = tmp;
}
return sa;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
str S, T;
cin >> S >> T;
int N = S.size(), M = T.size();
vvl H(3, vl(N + M));
vl B = {123457, 123567, 124567}, m = {998244353, MD, e9 + 9}, P(3), h(3);
fr(i, 3) {
P[i] = pow(B[i], M, m[i]);
int k = 0;
fr(j, N + M - 1) {
H[i][j + 1] = (H[i][j] * B[i] + S[k]) % m[i];
if (++k == N)
k = 0;
}
fr(j, M) { h[i] = (h[i] * B[i] + T[j]) % m[i]; }
}
vvi E(N);
int k = 0;
fr(j, N) {
if ((H[0][j + M] - H[0][j] * P[0] % m[0] + m[0]) % m[0] == h[0] &&
(H[1][j + M] - H[1][j] * P[1] % m[1] + m[1]) % m[1] == h[1] &&
(H[2][j + M] - H[2][j] * P[2] % m[2] + m[2]) % m[2] == h[2]) {
E[j] << k;
E[k] << j;
}
if (++k == N)
k = 0;
}
vb b(N);
function<int(int, int)> f = [&](int i, int p) {
if (b[i]) {
print(-1);
exit(0);
}
b[i] = true;
int x = 0;
for (int j : E[i])
if (j != p) {
x += 1 + f(j, i);
}
return x;
};
int z = 0;
fr(i, N) {
if (!b[i]) {
chmax(z, f(i, -1));
}
}
print(z);
return 0;
}
| #include <bits/stdc++.h>
#define fr(i, n) for (int i = 0; i < (n); ++i)
#define foor(i, a, b) for (int i = (a); i <= (b); ++i)
#define rf(i, n) for (int i = (n); i--;)
#define roof(i, b, a) for (int i = (b); i >= (a); --i)
#define elsif else if
#define all(x) x.begin(), x.end()
#define Sort(x) sort(all(x))
#define Reverse(x) reverse(all(x))
#define PQ priority_queue
#define NP(x) next_permutation(all(x))
#define M_PI 3.14159265358979323846
#define popcount __builtin_popcount
using namespace std;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef unsigned long long ull;
typedef vector<ull> vu;
typedef vector<vu> vvu;
typedef double dbl;
typedef vector<dbl> vd;
typedef vector<vd> vvd;
typedef string str;
typedef vector<str> vs;
typedef vector<vs> vvs;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef map<int, int> mii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef map<ll, ll> mll;
typedef pair<dbl, dbl> pdd;
typedef vector<pdd> vpdd;
typedef map<dbl, dbl> mdd;
typedef pair<str, str> pss;
typedef vector<pss> vpss;
typedef map<str, str> mss;
typedef pair<int, ll> pil;
typedef vector<pil> vpil;
typedef map<int, ll> mil;
typedef pair<ll, int> pli;
typedef vector<pli> vpli;
typedef map<ll, int> mli;
typedef pair<dbl, int> pdi;
typedef vector<pdi> vpdi;
typedef map<dbl, int> mdi;
template <typename T> vector<T> &operator<<(vector<T> &v, const T t) {
v.push_back(t);
return v;
}
template <typename T> multiset<T> &operator<<(multiset<T> &m, const T t) {
m.insert(t);
return m;
}
template <typename T> set<T> &operator<<(set<T> &s, const T t) {
s.insert(t);
return s;
}
template <typename T> stack<T> &operator<<(stack<T> &s, const T t) {
s.push(t);
return s;
}
template <typename T> stack<T> &operator>>(stack<T> &s, T &t) {
t = s.top();
s.pop();
return s;
}
template <typename T> queue<T> &operator<<(queue<T> &q, const T t) {
q.push(t);
return q;
}
template <typename T> queue<T> &operator>>(queue<T> &q, T &t) {
t = q.front();
q.pop();
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator<<(PQ<T, vector<T>, U> &q, const T t) {
q.push(t);
return q;
}
template <typename T, typename U>
PQ<T, vector<T>, U> &operator>>(PQ<T, vector<T>, U> &q, T &t) {
t = q.top();
q.pop();
return q;
}
template <typename T, typename U>
istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
istream &operator>>(istream &s, _Bit_reference b) {
int a;
s >> a;
assert(a == 0 || a == 1);
b = a;
return s;
}
template <typename T> istream &operator>>(istream &s, vector<T> &v) {
fr(i, v.size()) { s >> v[i]; }
return s;
}
template <typename T, typename U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
// template<typename T>ostream&operator<<(ostream&s,const vector<T>v){for(auto
// a:v){s<<a<<"\n";}return s;}
template <typename T> ostream &operator<<(ostream &s, const vector<T> v) {
fr(i, v.size()) { i ? s << " " << v[i] : s << v[i]; }
return s;
}
template <typename T> ostream &operator<<(ostream &s, const deque<T> d) {
fr(i, d.size()) { i ? s << " " << d[i] : s << d[i]; }
return s;
}
template <typename T> _Bit_reference operator&=(_Bit_reference b, T t) {
return b = b & t;
}
template <typename T> _Bit_reference operator^=(_Bit_reference b, T t) {
return b = b ^ t;
}
template <typename T> _Bit_reference operator|=(_Bit_reference b, T t) {
return b = b | t;
}
template <typename T, typename U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return {a.first + b.first, a.second + b.second};
}
template <typename T, typename U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return {a.first - b.first, a.second - b.second};
}
template <typename T, typename U>
pair<T, U> &operator+=(pair<T, U> &a, pair<T, U> b) {
return a = a + b;
}
template <typename T, typename U>
pair<T, U> &operator-=(pair<T, U> &a, pair<T, U> b) {
return a = a - b;
}
void print(void) { cout << "\n"; }
void Print(void) { cout << endl; }
template <typename T> void print(T t) { cout << t << "\n"; }
template <typename T> void Print(T t) { cout << t << endl; }
template <typename T, typename... U> void print(T &&t, U &&...u) {
cout << t << " ";
print(forward<U>(u)...);
}
template <typename T, typename... U> void Print(T &&t, U &&...u) {
cout << t << " ";
Print(forward<U>(u)...);
}
bool YN(bool b) {
print(b ? "YES" : "NO");
return b;
}
bool PI(bool b) {
print(b ? "POSSIBLE" : "IMPOSSIBLE");
return b;
}
bool Yn(bool b) {
print(b ? "Yes" : "No");
return b;
}
bool Pi(bool b) {
print(b ? "Possible" : "Impossible");
return b;
}
bool yn(bool b) {
print(b ? "yes" : "no");
return b;
}
bool pi(bool b) {
print(b ? "possible" : "impossible");
return b;
}
const int e5 = 1e5;
const int e9 = 1e9;
const int MD = 1e9 + 7;
const ll e18 = 1e18;
template <typename T> str to_string(const T &n) {
ostringstream s;
s << n;
return s.str();
}
template <typename T> T &chmax(T &a, T b) { return a = max(a, b); }
template <typename T> T &chmin(T &a, T b) { return a = min(a, b); }
template <typename T, typename U>
vector<pair<T, U>> dijkstra(const vector<vector<pair<T, U>>> &E, const U s,
const T inf) {
using P = pair<T, U>;
vector<P> d;
fr(i, E.size()) { d << P{inf, i}; }
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
template <typename T, typename U>
map<U, pair<T, U>> dijkstra(map<U, vector<pair<T, U>>> E, const U s,
const T inf) {
using P = pair<T, U>;
map<U, P> d;
for (pair<U, vector<P>> e : E) {
d[e.first] = P{inf, e.first};
}
PQ<P, vector<P>, greater<P>> pq;
pq << (d[s] = P{0, s});
while (pq.size()) {
P a = pq.top();
pq.pop();
U v = a.second;
if (d[v].first >= a.first) {
for (P e : E[v]) {
if (d[v].first + e.first < d[e.second].first) {
d[e.second] = P{d[v].first + e.first, v};
pq << P{d[v].first + e.first, e.second};
}
}
}
}
return d;
}
ll maxflow(vector<mil> &E, int s, int t) {
ll z = 0;
vi b(E.size(), -1);
for (int i = 0;; ++i) {
static auto dfs = [&](int v, ll f, auto &dfs) -> ll {
if (v == t)
return f;
b[v] = i;
for (auto &p : E[v]) {
if (b[p.first] < i && p.second) {
if (ll r = dfs(p.first, min(f, p.second), dfs)) {
p.second -= r;
E[p.first][v] += r;
return r;
}
}
}
return 0;
};
ll x = dfs(s, ll(1e18), dfs);
z += x;
if (x == 0)
return z;
}
}
template <typename T> T distsq(pair<T, T> a, pair<T, T> b) {
return (a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second);
}
template <typename T> T max(const vector<T> a) {
assert(a.size());
T m = a[0];
for (T e : a) {
m = max(m, e);
}
return m;
}
template <typename T> T min(const vector<T> a) {
assert(a.size());
T m = a[0];
for (T e : a) {
m = min(m, e);
}
return m;
}
template <typename T> T gcd(const T a, const T b) {
return a ? gcd(b % a, a) : b;
}
template <typename T> T gcd(const vector<T> a) {
T g = a[0];
for (T e : a) {
g = gcd(g, e);
}
return g;
}
template <typename T> vector<T> LIS(const vector<T> A) {
vector<T> B;
for (T a : A) {
auto it = lower_bound(all(B), a);
if (it == B.end()) {
B << a;
} else {
*it = a;
}
}
return B;
}
template <typename T> vector<T> LCS(vector<T> A, vector<T> B) {
int N = A.size(), M = B.size();
vector<vector<pair<int, pii>>> d(N + 1, vector<pair<int, pii>>(M + 1));
fr(i, N) {
fr(j, M) {
if (A[i] == B[j]) {
d[i + 1][j + 1] = {d[i][j].first + 1, {i, j}};
} else {
d[i + 1][j + 1] = max(d[i][j + 1], d[i + 1][j]);
}
}
}
vector<T> r;
for (pii p = {N, M}; d[p.first][p.second].first;
p = d[p.first][p.second].second) {
r << A[d[p.first][p.second].second.first];
}
Reverse(r);
return r;
}
str LCS(str S, str T) {
vector<char> s =
LCS(vector<char>(S.begin(), S.end()), vector<char>(T.begin(), T.end()));
return str(s.begin(), s.end());
}
template <typename T> vector<pair<T, T>> ConvexHull(vector<pair<T, T>> V) {
if (V.size() <= 3) {
return V;
}
Sort(V);
rf(i, V.size() - 1) V << V[i];
vector<pair<T, T>> r;
for (pair<T, T> p : V) {
int s = r.size();
while (s >= 2 &&
(p.second - r[s - 1].second) * (p.first - r[s - 2].first) <
(p.second - r[s - 2].second) * (p.first - r[s - 1].first)) {
r.pop_back();
--s;
}
r << p;
}
r.pop_back();
return r;
}
class UnionFind {
vi p, s;
void extend(int N) {
foor(i, p.size(), N) {
p << i;
s << 1;
}
}
public:
UnionFind(void) {}
UnionFind(int N) { extend(N - 1); }
int find(int i) {
extend(i);
return p[i] = p[i] == i ? i : find(p[i]);
}
void unite(int a, int b) {
extend(a);
extend(b);
if ((a = find(a)) != (b = find(b))) {
if (s[a] > s[b]) {
swap(a, b);
}
s[b] += s[a];
p[a] = b;
}
}
void unite(pii p) { return unite(p.first, p.second); }
bool same(int a, int b) {
extend(a);
extend(b);
return find(a) == find(b);
}
bool same(pii p) { return same(p.first, p.second); }
int size(int x) {
extend(x);
return s[find(x)];
}
};
ll MST(vector<pair<ll, pii>> &E) {
Sort(E);
UnionFind uf;
ll z = 0;
for (auto &e : E) {
if (!uf.same(e.second)) {
z += e.first;
uf.unite(e.second);
}
}
return z;
}
ll strmod(const str &s, const int m) {
ll x = 0;
fr(i, s.size()) { x = (x * 10 + s[i] - 48) % m; }
return x;
}
vvl mul(const vvl &A, const vvl &B, const int m) {
vvl C;
fr(y, A.size()) { C << vl(B[y].size()); }
fr(y, C.size()) {
fr(x, C[y].size()) {
fr(i, A[0].size()) { (C[y][x] += A[y][i] * B[i][x]) %= m; }
}
}
return C;
}
vvl pow(const vvl &A, const ll n, const int m) {
vvl B;
fr(y, A.size()) { B << vl(A.size()); }
if (n == 0) {
fr(i, B.size()) { B[i][i] = 1; }
}
elsif(n % 2) { B = mul(A, pow(A, n - 1, m), m); }
else {
vvl C = pow(A, n / 2, m);
B = mul(C, C, m);
}
return B;
}
ll pow(const ll a, const ll n, const int m) {
ll t;
return n ? (n & 1 ? a >= 0 ? a % m : (m - (-a % m)) % m : 1) *
(t = pow(a, n >> 1, m), t * t % m) % m
: !!a;
}
ll inv(const ll x, const int p) {
assert(x != 0);
return pow(x, p - 2, p);
}
ll inv(const ll x) { return inv(x, MD); }
vpll fact(const int n, const int p) {
assert(n < p);
vpll v(n + 1);
v[0].first = 1;
foor(i, 1, n) { v[i].first = v[i - 1].first * i % p; }
v[n].second = inv(v[n].first, p);
roof(i, n, 1) { v[i - 1].second = v[i].second * i % p; }
return v;
}
class Combination {
const vpll f;
const int M;
public:
Combination(int n, int m) : f(fact(n, m)), M(m) {}
Combination(int n) : Combination(n, MD) {}
ll P(int n, int k) {
return n < 0 || k < 0 || n < k ? 0ll : f[n].first * f[n - k].second % M;
}
ll C(int n, int k) { return k < 0 ? 0 : P(n, k) * f[k].second % M; }
ll H(int n, int k) { return n == 0 && k == 0 ? 1ll : C(n + k - 1, k); }
ll F(int n) { return n < 0 ? 0 : f[n].first; }
};
ll C2(const int n) { return (ll)n * ~-n / 2; }
ll sum(const vi a) {
ll s = 0;
for (int e : a) {
s += e;
}
return s;
}
ll sum(const vl a) {
ll s = 0;
for (ll e : a) {
s += e;
}
return s;
}
template <typename T> int MSB(T N) {
int r = -1;
for (; N > 0; N /= 2) {
++r;
}
return r;
}
template <typename T> class SegmentTree {
vector<T> S;
T (*const op)(T a, T b);
const T zero;
const int B;
public:
SegmentTree(int N, T (*f)(T a, T b), const T zero)
: S(1 << MSB(N - 1) + 2, zero), op(f), zero(zero),
B(1 << MSB(N - 1) + 1) {}
SegmentTree(vector<T> v, T (*f)(T a, T b), const T zero)
: SegmentTree(v.size(), f, zero) {
fr(i, v.size()) { S[S.size() / 2 + i] = v[i]; }
roof(i, S.size() / 2 - 1, 1) { S[i] = op(S[i * 2], S[i * 2 + 1]); }
}
T calc(int l, int r) {
l += B;
r += B;
if (l > r) {
return zero;
}
if (l == r) {
return S[l];
}
T L = S[l], R = S[r];
for (; l / 2 < r / 2; l /= 2, r /= 2) {
if (l % 2 == 0) {
L = op(L, S[l + 1]);
}
if (r % 2 == 1) {
R = op(S[r - 1], R);
}
}
return op(L, R);
}
void replace(int i, T x) {
for (S[i += B] = x; i != 1; i /= 2) {
if (i % 2) {
S[i / 2] = op(S[i - 1], S[i]);
} else {
S[i / 2] = op(S[i], S[i + 1]);
}
}
}
void add(int i, T x) { replace(i, op(S[B + i], x)); }
T top() { return S[1]; }
T get(int i) { return S[i + B]; }
};
ll BITsum(vl &B, int i) {
ll z = 0;
while (i > 0) {
z += B[i];
i -= i & -i;
}
return z;
}
void BITadd(vl &B, int i, ll x) {
while (i < B.size()) {
B[i] += x;
i += i & -i;
}
}
ll fib(const ll n, const int m) {
ll a, b, c, d, A, B, C, D;
a = 1;
b = 0;
c = 0;
d = 1;
rf(i, 63) {
A = a * a + b * c;
B = a * b + b * d;
C = c * a + d * c;
D = c * b + d * d;
if (n >> i & 1) {
a = A;
b = B;
c = C;
d = D;
A = a + b;
B = a;
C = c + d;
D = c;
}
a = A % m;
b = B % m;
c = C % m;
d = D % m;
}
return b;
}
vi primes(int n) {
vb b(n + 1);
vi p;
foor(i, 2, n) {
if (!b[i]) {
p << i;
for (int j = 2 * i; j <= n; j += i) {
b[j] = true;
}
}
}
return p;
}
vb isprime(const int n) {
vb v(n + 1, true);
v[0] = v[1] = false;
foor(i, 2, n) {
if (v[i]) {
for (int j = 2 * i; j <= n; j += i) {
v[j] = false;
}
}
}
return v;
}
class LCA {
vvi par;
vi dep;
public:
LCA(vvi &E, int root) : par(MSB(E.size()) + 1, vi(E.size())), dep(E.size()) {
function<void(int, int)> dfs = [&](int i, int p) {
for (int j : E[i])
if (j != p) {
par[0][j] = i;
dep[j] = dep[i] + 1;
dfs(j, i);
}
};
par[0][root] = root;
dfs(root, root);
fr(i, par.size() - 1) {
fr(j, par[0].size()) { par[i + 1][j] = par[i][par[i][j]]; }
}
}
int operator()(int a, int b) {
if (dep[a] > dep[b])
swap(a, b);
for (int t = dep[b] - dep[a], i = 0; t; t >>= 1, ++i) {
if (t & 1) {
b = par[i][b];
}
}
if (a == b)
return a;
rf(i, par.size()) {
if (par[i][a] != par[i][b]) {
a = par[i][a];
b = par[i][b];
}
}
return par[0][a];
}
};
vpii factor(int N) {
vpii r;
for (int i = 2; i * i <= N; ++i) {
if (N % i == 0) {
r << pii{i, 0};
while (N % i == 0) {
N /= i;
++r.back().second;
}
}
}
if (N > 1) {
r << pii{N, 1};
}
return r;
}
vl divisors(ll n) {
vl r;
ll m = sqrt(n);
foor(i, 1, m) if (n % i == 0) r << ll(i);
rf(i, r.size() - (m * m == n)) r << n / r[i];
return r;
}
vi SuffixArray(str S) {
int N = S.size();
vi rank(N + 1), tmp(N + 1), sa(N + 1);
fr(i, N) {
sa[i] = i;
rank[i] = S[i];
}
sa[N] = N;
rank[N] = -1;
int k;
auto cmp = [&](int &a, int &b) -> bool {
if (rank[a] != rank[b])
return rank[a] < rank[b];
return (a + k <= N ? rank[a + k] : -1) < (b + k <= N ? rank[b + k] : -1);
};
for (k = 1; k <= N; k *= 2) {
sort(all(sa), cmp);
tmp[sa[0]] = 0;
foor(i, 1, N) { tmp[sa[i]] = tmp[sa[i - 1]] + cmp(sa[i - 1], sa[i]); }
rank = tmp;
}
return sa;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
str S, T;
cin >> S >> T;
int N = S.size(), M = T.size();
vvl H(3, vl(N + M));
vl B = {123457, 123567, 124567}, m = {998244353, MD, e9 + 9}, P(3), h(3);
fr(i, 3) {
P[i] = pow(B[i], M, m[i]);
int k = 0;
fr(j, N + M - 1) {
H[i][j + 1] = (H[i][j] * B[i] + S[k]) % m[i];
if (++k == N)
k = 0;
}
fr(j, M) { h[i] = (h[i] * B[i] + T[j]) % m[i]; }
}
vvi E(N);
int k = M % N;
fr(j, N) {
if ((H[0][j + M] - H[0][j] * P[0] % m[0] + m[0]) % m[0] == h[0] &&
(H[1][j + M] - H[1][j] * P[1] % m[1] + m[1]) % m[1] == h[1] &&
(H[2][j + M] - H[2][j] * P[2] % m[2] + m[2]) % m[2] == h[2]) {
E[j] << k;
E[k] << j;
}
if (++k == N)
k = 0;
}
vb b(N);
function<int(int, int)> f = [&](int i, int p) {
if (b[i]) {
print(-1);
exit(0);
}
b[i] = true;
int x = 0;
for (int j : E[i])
if (j != p) {
x += 1 + f(j, i);
}
return x;
};
int z = 0;
fr(i, N) {
if (!b[i]) {
chmax(z, f(i, -1));
}
}
print(z);
return 0;
}
| [
"identifier.replace.add",
"literal.replace.remove"
] | 770,863 | 770,864 | u283869437 | cpp |
p02962 | #define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
#define FOR(i, j, k) for (int(i) = (j); (i) < (int)(k); ++(i))
#define rep(i, j) FOR(i, 0, j)
#define each(x, y) for (auto &(x) : (y))
#define mp make_pair
#define MT make_tuple
#define all(x) (x).begin(), (x).end()
#define debug(x) cout << #x << ": " << (x) << endl
#define smax(x, y) (x) = max((x), (y))
#define smin(x, y) (x) = min((x), (y))
#define MEM(x, y) memset((x), (y), sizeof(x))
#define sz(x) (int)(x).size()
#define RT return
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
vector<int> zAlgorithm(const string &s) {
int n = (int)s.size(), l = 0, r = 0;
vector<int> Z(n, n);
for (int i = 1; i < n; ++i) {
if (i > r) {
l = r = i;
} else if (Z[i - l] >= r - i + 1) {
l = i;
} else {
Z[i] = Z[i - l];
continue;
}
while (r < n && s[r] == s[r - l])
r++;
Z[i] = r - l;
r--;
}
return Z;
}
class UnionFind {
int cnt;
vector<int> par, rank, size;
public:
UnionFind() {}
UnionFind(int _n) : cnt(_n), par(_n), rank(_n), size(_n, 1) {
for (int i = 0; i < _n; ++i)
par[i] = i;
}
int find(int k) { return (k == par[k]) ? k : (par[k] = find(par[k])); }
int operator[](int k) { return find(k); }
int getSize(int k) { return size[find(k)]; }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
--cnt;
if (rank[x] < rank[y]) {
par[x] = y;
size[y] += size[x];
} else {
par[y] = x;
size[x] += size[y];
if (rank[y] == rank[x])
++rank[x];
}
}
int count() { return cnt; }
};
void solve() {
string S, T;
cin >> S >> T;
int N = sz(S), M = sz(T);
string s = S;
while (sz(S) < 2 * M) {
S += s;
}
UnionFind uf(N);
int ans = 0;
string TS = T + S;
auto Z = zAlgorithm(TS);
rep(i, N) {
int j = (i + M) % N;
if (Z[i + M] >= M && Z[j + M] >= M) {
uf.unite(i, j);
}
}
vector<bool> vis(N);
rep(i, N) {
if (Z[i + M] >= M) {
smax(ans, uf.getSize(i));
}
int cur = i;
if (vis[cur])
continue;
bool ok = true;
do {
vis[cur] = true;
if (Z[cur + M] < M)
ok = false;
cur = (cur + M) % N;
} while (cur != i);
if (ok) {
cout << -1 << endl;
return;
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
} | #define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
#define FOR(i, j, k) for (int(i) = (j); (i) < (int)(k); ++(i))
#define rep(i, j) FOR(i, 0, j)
#define each(x, y) for (auto &(x) : (y))
#define mp make_pair
#define MT make_tuple
#define all(x) (x).begin(), (x).end()
#define debug(x) cout << #x << ": " << (x) << endl
#define smax(x, y) (x) = max((x), (y))
#define smin(x, y) (x) = min((x), (y))
#define MEM(x, y) memset((x), (y), sizeof(x))
#define sz(x) (int)(x).size()
#define RT return
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
vector<int> zAlgorithm(const string &s) {
int n = (int)s.size(), l = 0, r = 0;
vector<int> Z(n, n);
for (int i = 1; i < n; ++i) {
if (i > r) {
l = r = i;
} else if (Z[i - l] >= r - i + 1) {
l = i;
} else {
Z[i] = Z[i - l];
continue;
}
while (r < n && s[r] == s[r - l])
r++;
Z[i] = r - l;
r--;
}
return Z;
}
class UnionFind {
int cnt;
vector<int> par, rank, size;
public:
UnionFind() {}
UnionFind(int _n) : cnt(_n), par(_n), rank(_n), size(_n, 1) {
for (int i = 0; i < _n; ++i)
par[i] = i;
}
int find(int k) { return (k == par[k]) ? k : (par[k] = find(par[k])); }
int operator[](int k) { return find(k); }
int getSize(int k) { return size[find(k)]; }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
--cnt;
if (rank[x] < rank[y]) {
par[x] = y;
size[y] += size[x];
} else {
par[y] = x;
size[x] += size[y];
if (rank[y] == rank[x])
++rank[x];
}
}
int count() { return cnt; }
};
void solve() {
string S, T;
cin >> S >> T;
int N = sz(S), M = sz(T);
string s = S;
while (sz(S) < 2 * M) {
S += s;
}
S += S;
UnionFind uf(N);
int ans = 0;
string TS = T + S;
auto Z = zAlgorithm(TS);
rep(i, N) {
int j = (i + M) % N;
if (Z[i + M] >= M && Z[j + M] >= M) {
uf.unite(i, j);
}
}
vector<bool> vis(N);
rep(i, N) {
if (Z[i + M] >= M) {
smax(ans, uf.getSize(i));
}
int cur = i;
if (vis[cur])
continue;
bool ok = true;
do {
vis[cur] = true;
if (Z[cur + M] < M)
ok = false;
cur = (cur + M) % N;
} while (cur != i);
if (ok) {
cout << -1 << endl;
return;
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
} | [
"assignment.add"
] | 770,876 | 770,875 | u750436322 | cpp |
p02962 | #pragma GCC optimize("O3")
#include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using QWORD = uint64_t;
using SQWORD = int64_t;
using DWORD = uint32_t;
using SDWORD = int32_t;
using WORD = uint16_t;
using SWORD = int16_t;
using BYTE = uint8_t;
using SBYTE = int8_t;
using DOUBLE = double;
using FLOAT = float;
#define MIN_SDWORD (-2147483648)
#define MAX_SDWORD (2147483647)
#define MIN_SBYTE (-128)
#define MAX_SBYTE (127)
#define MIN_SQWORD (0x8000000000000000)
#define MAX_SQWORD (0x7FFFFFFFFFFFFFFF)
#define MAX_QWORD (0xFFFFFFFFFFFFFFFF)
#define MAX_DWORD (0xFFFFFFFF)
#define MAX_WORD (0xFFFF)
#define MAX_BYTE (0xFF)
#define MAX_DOUBLE (1.0e+308)
#define DOUBLE_EPS (1.0e-12)
#define MIN_DOUBLE_N (-1.0e+308)
#define ArrayLength(a) (sizeof(a) / sizeof(a[0]))
static inline DOUBLE MAX(DOUBLE a, DOUBLE b) { return a > b ? a : b; }
static inline QWORD MAX(QWORD a, QWORD b) { return a > b ? a : b; }
static inline DWORD MAX(DWORD a, DWORD b) { return a > b ? a : b; }
static inline SDWORD MAX(SDWORD a, SDWORD b) { return a > b ? a : b; }
static inline DOUBLE MIN(DOUBLE a, DOUBLE b) { return a < b ? a : b; }
static inline QWORD MIN(QWORD a, QWORD b) { return a < b ? a : b; }
static inline DWORD MIN(DWORD a, DWORD b) { return a < b ? a : b; }
static inline SDWORD MIN(SDWORD a, SDWORD b) { return a < b ? a : b; }
#define BYTE_BITS (8)
#define WORD_BITS (16)
#define DWORD_BITS (32)
#define QWORD_BITS (64)
static inline void inputStringSpSeparated(char *pcStr) {
char *pcCur = pcStr;
for (;;) {
char c = getchar();
if (('\n' == c) || (EOF == c) || (' ' == c)) {
break;
}
*pcCur = c;
pcCur++;
}
*pcCur = '\0';
}
static inline void inputString(char *pcStr) {
char *pcCur = pcStr;
for (;;) {
char c = getchar();
if (('\n' == c) || (EOF == c)) {
break;
}
*pcCur = c;
pcCur++;
}
*pcCur = '\0';
}
static inline SQWORD inputSQWORD(void) {
SQWORD sqNumber = 0;
SQWORD sqMultiplier = 1;
bool bRead = false;
for (;;) {
char c = getchar();
if (!bRead) {
if ('-' == c) {
sqMultiplier = -1;
}
}
if (('0' <= c) && (c <= '9')) {
sqNumber *= 10LL;
sqNumber += (SQWORD)(c - '0');
bRead = true;
} else {
if (bRead) {
return sqNumber * sqMultiplier;
}
}
}
}
static inline SDWORD inputSDWORD(void) {
SDWORD lNumber = 0;
SDWORD lMultiplier = 1;
bool bRead = false;
for (;;) {
char c = getchar();
if (!bRead) {
if ('-' == c) {
lMultiplier = -1;
}
}
if (('0' <= c) && (c <= '9')) {
lNumber *= 10;
lNumber += (c - '0');
bRead = true;
} else {
if (bRead) {
return lNumber * lMultiplier;
}
}
}
}
static inline DOUBLE inputFP(void) {
DOUBLE dInt = 0.0;
DOUBLE dFrac = 0.0;
DOUBLE dMultiplier = 1.0;
DWORD dwFpCnt = 0;
DOUBLE *pdCur = &dInt;
bool bRead = false;
for (;;) {
char c = getchar();
if (!bRead) {
if ('-' == c) {
dMultiplier = -1;
}
}
if ('.' == c) {
pdCur = &dFrac;
} else if (('0' <= c) && (c <= '9')) {
(*pdCur) *= 10;
(*pdCur) += (DOUBLE)(c - '0');
bRead = true;
if (pdCur == &dFrac) {
dwFpCnt++;
}
} else {
if (bRead) {
return dMultiplier *
(dInt + dFrac / (pow((DOUBLE)10.0, (DOUBLE)dwFpCnt)));
}
}
}
}
/**
* mod による操作ライブラリ
*/
#define ANS_MOD (1000000007LL)
static SQWORD addMod(SQWORD x, SQWORD y) { return (x + y) % ANS_MOD; }
static SQWORD subMod(SQWORD x, SQWORD y) { return (x - y + ANS_MOD) % ANS_MOD; }
static SQWORD mulMod(SQWORD x, SQWORD y) { return (x * y) % ANS_MOD; }
static SQWORD powMod(SQWORD x, SQWORD e) {
SQWORD v = 1;
for (; e; x = mulMod(x, x), e >>= 1) {
if (e & 1) {
v = mulMod(v, x);
}
}
return v;
}
static SQWORD divMod(SQWORD x, SQWORD y) {
return mulMod(x, powMod(y, ANS_MOD - 2));
}
static SQWORD combMod(SQWORD n, SQWORD k) {
SQWORD v = 1;
for (SQWORD i = 1; i <= k; i++) {
v = divMod(mulMod(v, n - i + 1), i);
}
return v;
}
/*----------------------------------------------*/
/**
* rolling hash
*/
#define MS (2)
const long long mod[] = {999999937LL, 1000000007LL}, base = 9973;
struct rolling_hash {
int n;
vector<long long> hs[MS], pw[MS];
rolling_hash() {}
rolling_hash(const string &s) {
n = s.size();
for (int i = 0; i < MS; i++) {
hs[i].assign(n + 1, 0);
pw[i].assign(n + 1, 0);
hs[i][0] = 0;
pw[i][0] = 1;
for (int j = 0; j < n; j++) {
pw[i][j + 1] = pw[i][j] * base % mod[i];
hs[i][j + 1] = (hs[i][j] * base + s[j]) % mod[i];
}
}
}
long long hash(int l, int r, int i) {
return ((hs[i][r] - hs[i][l] * pw[i][r - l]) % mod[i] + mod[i]) % mod[i];
}
bool match(int l1, int r1, int l2, int r2) {
bool ret = 1;
for (int i = 0; i < MS; i++)
ret &= hash(l1, r1, i) == hash(l2, r2, i);
return ret;
}
bool match(int l, int r, long long h[]) {
bool ret = 1;
for (int i = 0; i < MS; i++)
ret &= hash(l, r, i) == h[i];
return ret;
}
};
struct rolling_hash64 {
int n;
vector<long long> hs, pw;
rolling_hash64() {}
rolling_hash64(const string &s) {
n = s.size();
hs.assign(n + 1, 0);
pw.assign(n + 1, 0);
pw[0] = 1;
for (int i = 0; i < n; i++) {
hs[i + 1] = hs[i] * base + s[i];
pw[i + 1] = pw[i] * base;
}
}
long long hash(int l, int r) { return hs[r] - hs[l] * pw[r - l]; }
bool match(int l1, int r1, int l2, int r2) {
return hash(l1, r1) == hash(l2, r2);
}
};
/*----------------------------------------------*/
typedef struct {
vector<DWORD> vdwPar;
vector<DWORD> vdwRank;
vector<DWORD> vdwCnt;
DWORD dwSize;
void initUnionFind(DWORD dwSize) {
dwSize = dwSize;
vdwPar.resize(dwSize);
vdwRank.resize(dwSize);
vdwCnt.resize(dwSize);
for (DWORD dwIdx = 0; dwIdx < dwSize; dwIdx++) {
vdwPar[dwIdx] = dwIdx;
vdwRank[dwIdx] = 0;
vdwCnt[dwIdx] = 1;
}
}
DWORD ufGetCnt(DWORD sqIdx) { return vdwCnt[ufGetParent(sqIdx)]; }
DWORD ufGetParent(DWORD dwIdx) const { return vdwPar[dwIdx]; }
DWORD ufGetRank(DWORD dwIdx) const { return vdwRank[dwIdx]; }
void ufSetParent(DWORD dwIdx, DWORD dwParent) {
vdwPar[dwIdx] = dwParent;
if (ufGetRank(dwIdx) == ufGetRank(dwParent)) {
(vdwRank[dwParent])++;
}
}
DWORD ufGetRoot(DWORD dwIdx) const {
if (ufGetParent(dwIdx) == dwIdx) {
return dwIdx;
} else {
DWORD dwParent = ufGetParent(dwIdx);
DWORD dwRoot = ufGetRoot(dwParent);
return dwRoot;
}
}
bool ufUnite(DWORD dwX, DWORD dwY) {
DWORD dwRootX = ufGetRoot(dwX);
DWORD dwRootY = ufGetRoot(dwY);
if (dwRootX == dwRootY) {
return false;
}
if (ufGetRank(dwRootX) < ufGetRank(dwRootY)) {
ufSetParent(dwRootX, dwRootY);
(vdwCnt[dwRootY]) += (vdwCnt[dwRootX]);
} else {
ufSetParent(dwRootY, dwRootX);
(vdwCnt[dwRootX]) += (vdwCnt[dwRootY]);
}
return true;
}
bool ufIsSame(DWORD dwX, DWORD dwY) const {
return (ufGetRoot(dwX) == ufGetRoot(dwY));
}
} ST_UNION_FIND;
/*----------------------------------------------*/
static void getStrMatchPos(string s, string pat, vector<SQWORD> &vsqRet) {
rolling_hash hash_str(s);
rolling_hash hash_pat(pat);
SQWORD size_str = s.size();
SQWORD size_pat = pat.size();
SQWORD asqHashVal[2];
asqHashVal[0] = hash_pat.hash(0, size_pat, 0);
asqHashVal[1] = hash_pat.hash(0, size_pat, 0);
for (SQWORD i = 0; i < size_str - size_pat; i++) {
if ((hash_str.hash(i, i + size_pat, 0) == asqHashVal[0]) &&
(hash_str.hash(i, i + size_pat, 1) == asqHashVal[1])) {
vsqRet.emplace_back(i);
}
}
}
int main(void) {
string str_s, str_t;
cin >> str_s;
cin >> str_t;
SQWORD sqSLen = str_s.size();
SQWORD sqTLen = str_t.size();
string str_s_plus = str_s + str_s + str_s; /* 最低3個は繰り返す */
while (str_s_plus.size() < str_t.size() * 2) {
str_s_plus += str_s;
}
vector<SQWORD> vecMatchPos;
getStrMatchPos(str_s_plus, str_t, vecMatchPos);
ST_UNION_FIND Uf;
Uf.initUnionFind(sqSLen);
bool bIsForever = false;
for (auto pos : vecMatchPos) {
if (pos < str_s.size()) {
bool bFound = std::binary_search(vecMatchPos.begin(), vecMatchPos.end(),
(pos + sqTLen) % sqSLen);
if (bFound) {
if (!Uf.ufUnite(pos, (pos + sqTLen) % sqSLen)) {
bIsForever = true;
break;
}
}
}
}
if (bIsForever) {
printf("-1\n");
} else {
SQWORD sqSizeMax = 0;
for (SDWORD lIdx = 0; lIdx < sqSLen; lIdx++) {
if (std::binary_search(vecMatchPos.begin(), vecMatchPos.end(), lIdx)) {
sqSizeMax = max(sqSizeMax, (SQWORD)Uf.ufGetCnt(lIdx));
}
}
printf("%lld\n", sqSizeMax);
}
return 0;
} | #pragma GCC optimize("O3")
#include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using QWORD = uint64_t;
using SQWORD = int64_t;
using DWORD = uint32_t;
using SDWORD = int32_t;
using WORD = uint16_t;
using SWORD = int16_t;
using BYTE = uint8_t;
using SBYTE = int8_t;
using DOUBLE = double;
using FLOAT = float;
#define MIN_SDWORD (-2147483648)
#define MAX_SDWORD (2147483647)
#define MIN_SBYTE (-128)
#define MAX_SBYTE (127)
#define MIN_SQWORD (0x8000000000000000)
#define MAX_SQWORD (0x7FFFFFFFFFFFFFFF)
#define MAX_QWORD (0xFFFFFFFFFFFFFFFF)
#define MAX_DWORD (0xFFFFFFFF)
#define MAX_WORD (0xFFFF)
#define MAX_BYTE (0xFF)
#define MAX_DOUBLE (1.0e+308)
#define DOUBLE_EPS (1.0e-12)
#define MIN_DOUBLE_N (-1.0e+308)
#define ArrayLength(a) (sizeof(a) / sizeof(a[0]))
static inline DOUBLE MAX(DOUBLE a, DOUBLE b) { return a > b ? a : b; }
static inline QWORD MAX(QWORD a, QWORD b) { return a > b ? a : b; }
static inline DWORD MAX(DWORD a, DWORD b) { return a > b ? a : b; }
static inline SDWORD MAX(SDWORD a, SDWORD b) { return a > b ? a : b; }
static inline DOUBLE MIN(DOUBLE a, DOUBLE b) { return a < b ? a : b; }
static inline QWORD MIN(QWORD a, QWORD b) { return a < b ? a : b; }
static inline DWORD MIN(DWORD a, DWORD b) { return a < b ? a : b; }
static inline SDWORD MIN(SDWORD a, SDWORD b) { return a < b ? a : b; }
#define BYTE_BITS (8)
#define WORD_BITS (16)
#define DWORD_BITS (32)
#define QWORD_BITS (64)
static inline void inputStringSpSeparated(char *pcStr) {
char *pcCur = pcStr;
for (;;) {
char c = getchar();
if (('\n' == c) || (EOF == c) || (' ' == c)) {
break;
}
*pcCur = c;
pcCur++;
}
*pcCur = '\0';
}
static inline void inputString(char *pcStr) {
char *pcCur = pcStr;
for (;;) {
char c = getchar();
if (('\n' == c) || (EOF == c)) {
break;
}
*pcCur = c;
pcCur++;
}
*pcCur = '\0';
}
static inline SQWORD inputSQWORD(void) {
SQWORD sqNumber = 0;
SQWORD sqMultiplier = 1;
bool bRead = false;
for (;;) {
char c = getchar();
if (!bRead) {
if ('-' == c) {
sqMultiplier = -1;
}
}
if (('0' <= c) && (c <= '9')) {
sqNumber *= 10LL;
sqNumber += (SQWORD)(c - '0');
bRead = true;
} else {
if (bRead) {
return sqNumber * sqMultiplier;
}
}
}
}
static inline SDWORD inputSDWORD(void) {
SDWORD lNumber = 0;
SDWORD lMultiplier = 1;
bool bRead = false;
for (;;) {
char c = getchar();
if (!bRead) {
if ('-' == c) {
lMultiplier = -1;
}
}
if (('0' <= c) && (c <= '9')) {
lNumber *= 10;
lNumber += (c - '0');
bRead = true;
} else {
if (bRead) {
return lNumber * lMultiplier;
}
}
}
}
static inline DOUBLE inputFP(void) {
DOUBLE dInt = 0.0;
DOUBLE dFrac = 0.0;
DOUBLE dMultiplier = 1.0;
DWORD dwFpCnt = 0;
DOUBLE *pdCur = &dInt;
bool bRead = false;
for (;;) {
char c = getchar();
if (!bRead) {
if ('-' == c) {
dMultiplier = -1;
}
}
if ('.' == c) {
pdCur = &dFrac;
} else if (('0' <= c) && (c <= '9')) {
(*pdCur) *= 10;
(*pdCur) += (DOUBLE)(c - '0');
bRead = true;
if (pdCur == &dFrac) {
dwFpCnt++;
}
} else {
if (bRead) {
return dMultiplier *
(dInt + dFrac / (pow((DOUBLE)10.0, (DOUBLE)dwFpCnt)));
}
}
}
}
/**
* mod による操作ライブラリ
*/
#define ANS_MOD (1000000007LL)
static SQWORD addMod(SQWORD x, SQWORD y) { return (x + y) % ANS_MOD; }
static SQWORD subMod(SQWORD x, SQWORD y) { return (x - y + ANS_MOD) % ANS_MOD; }
static SQWORD mulMod(SQWORD x, SQWORD y) { return (x * y) % ANS_MOD; }
static SQWORD powMod(SQWORD x, SQWORD e) {
SQWORD v = 1;
for (; e; x = mulMod(x, x), e >>= 1) {
if (e & 1) {
v = mulMod(v, x);
}
}
return v;
}
static SQWORD divMod(SQWORD x, SQWORD y) {
return mulMod(x, powMod(y, ANS_MOD - 2));
}
static SQWORD combMod(SQWORD n, SQWORD k) {
SQWORD v = 1;
for (SQWORD i = 1; i <= k; i++) {
v = divMod(mulMod(v, n - i + 1), i);
}
return v;
}
/*----------------------------------------------*/
/**
* rolling hash
*/
#define MS (2)
const long long mod[] = {999999937LL, 1000000007LL}, base = 9973;
struct rolling_hash {
int n;
vector<long long> hs[MS], pw[MS];
rolling_hash() {}
rolling_hash(const string &s) {
n = s.size();
for (int i = 0; i < MS; i++) {
hs[i].assign(n + 1, 0);
pw[i].assign(n + 1, 0);
hs[i][0] = 0;
pw[i][0] = 1;
for (int j = 0; j < n; j++) {
pw[i][j + 1] = pw[i][j] * base % mod[i];
hs[i][j + 1] = (hs[i][j] * base + s[j]) % mod[i];
}
}
}
long long hash(int l, int r, int i) {
return ((hs[i][r] - hs[i][l] * pw[i][r - l]) % mod[i] + mod[i]) % mod[i];
}
bool match(int l1, int r1, int l2, int r2) {
bool ret = 1;
for (int i = 0; i < MS; i++)
ret &= hash(l1, r1, i) == hash(l2, r2, i);
return ret;
}
bool match(int l, int r, long long h[]) {
bool ret = 1;
for (int i = 0; i < MS; i++)
ret &= hash(l, r, i) == h[i];
return ret;
}
};
struct rolling_hash64 {
int n;
vector<long long> hs, pw;
rolling_hash64() {}
rolling_hash64(const string &s) {
n = s.size();
hs.assign(n + 1, 0);
pw.assign(n + 1, 0);
pw[0] = 1;
for (int i = 0; i < n; i++) {
hs[i + 1] = hs[i] * base + s[i];
pw[i + 1] = pw[i] * base;
}
}
long long hash(int l, int r) { return hs[r] - hs[l] * pw[r - l]; }
bool match(int l1, int r1, int l2, int r2) {
return hash(l1, r1) == hash(l2, r2);
}
};
/*----------------------------------------------*/
typedef struct {
vector<DWORD> vdwPar;
vector<DWORD> vdwRank;
vector<DWORD> vdwCnt;
DWORD dwSize;
void initUnionFind(DWORD dwSize) {
dwSize = dwSize;
vdwPar.resize(dwSize);
vdwRank.resize(dwSize);
vdwCnt.resize(dwSize);
for (DWORD dwIdx = 0; dwIdx < dwSize; dwIdx++) {
vdwPar[dwIdx] = dwIdx;
vdwRank[dwIdx] = 0;
vdwCnt[dwIdx] = 1;
}
}
DWORD ufGetCnt(DWORD sqIdx) { return vdwCnt[ufGetParent(sqIdx)]; }
DWORD ufGetParent(DWORD dwIdx) const { return vdwPar[dwIdx]; }
DWORD ufGetRank(DWORD dwIdx) const { return vdwRank[dwIdx]; }
void ufSetParent(DWORD dwIdx, DWORD dwParent) {
vdwPar[dwIdx] = dwParent;
if (ufGetRank(dwIdx) == ufGetRank(dwParent)) {
(vdwRank[dwParent])++;
}
}
DWORD ufGetRoot(DWORD dwIdx) const {
if (ufGetParent(dwIdx) == dwIdx) {
return dwIdx;
} else {
DWORD dwParent = ufGetParent(dwIdx);
DWORD dwRoot = ufGetRoot(dwParent);
return dwRoot;
}
}
bool ufUnite(DWORD dwX, DWORD dwY) {
DWORD dwRootX = ufGetRoot(dwX);
DWORD dwRootY = ufGetRoot(dwY);
if (dwRootX == dwRootY) {
return false;
}
if (ufGetRank(dwRootX) < ufGetRank(dwRootY)) {
ufSetParent(dwRootX, dwRootY);
(vdwCnt[dwRootY]) += (vdwCnt[dwRootX]);
} else {
ufSetParent(dwRootY, dwRootX);
(vdwCnt[dwRootX]) += (vdwCnt[dwRootY]);
}
return true;
}
bool ufIsSame(DWORD dwX, DWORD dwY) const {
return (ufGetRoot(dwX) == ufGetRoot(dwY));
}
} ST_UNION_FIND;
/*----------------------------------------------*/
static void getStrMatchPos(string s, string pat, vector<SQWORD> &vsqRet) {
rolling_hash hash_str(s);
rolling_hash hash_pat(pat);
SQWORD size_str = s.size();
SQWORD size_pat = pat.size();
SQWORD asqHashVal[2];
asqHashVal[0] = hash_pat.hash(0, size_pat, 0);
asqHashVal[1] = hash_pat.hash(0, size_pat, 1);
for (SQWORD i = 0; i < size_str - size_pat; i++) {
if ((hash_str.hash(i, i + size_pat, 0) == asqHashVal[0]) &&
(hash_str.hash(i, i + size_pat, 1) == asqHashVal[1])) {
vsqRet.emplace_back(i);
}
}
}
int main(void) {
string str_s, str_t;
cin >> str_s;
cin >> str_t;
SQWORD sqSLen = str_s.size();
SQWORD sqTLen = str_t.size();
string str_s_plus = str_s + str_s + str_s; /* 最低3個は繰り返す */
while (str_s_plus.size() < str_t.size() * 2) {
str_s_plus += str_s;
}
vector<SQWORD> vecMatchPos;
getStrMatchPos(str_s_plus, str_t, vecMatchPos);
ST_UNION_FIND Uf;
Uf.initUnionFind(sqSLen);
bool bIsForever = false;
for (auto pos : vecMatchPos) {
if (pos < str_s.size()) {
bool bFound = std::binary_search(vecMatchPos.begin(), vecMatchPos.end(),
(pos + sqTLen) % sqSLen);
if (bFound) {
if (!Uf.ufUnite(pos, (pos + sqTLen) % sqSLen)) {
bIsForever = true;
break;
}
}
}
}
if (bIsForever) {
printf("-1\n");
} else {
SQWORD sqSizeMax = 0;
for (SDWORD lIdx = 0; lIdx < sqSLen; lIdx++) {
if (std::binary_search(vecMatchPos.begin(), vecMatchPos.end(), lIdx)) {
sqSizeMax = max(sqSizeMax, (SQWORD)Uf.ufGetCnt(lIdx));
}
}
printf("%lld\n", sqSizeMax);
}
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"call.arguments.change"
] | 770,886 | 770,887 | u487476769 | cpp |
p02962 | #pragma GCC optimize("-O3", "unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits.h>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#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 SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define m0(x) memset(x, 0, sizeof(x))
#define print(x) cout << x << '\n';
#define pe(x) cout << x << " ";
#define lb(v, n) lower_bound(v.begin(), v.end(), n);
#define ub(v, n) upper_bound(v.begin(), v.end(), n);
#define int long long
//#define int unsigned long long
#define all(x) (x).begin(), (x).end()
#define double long double
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int MOD = 1e9 + 7;
const ll INF = 1e17;
const double pi = acos(-1);
const double EPS = 1e-10;
typedef pair<int, int> P;
const int MAX = 200020;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll add(ll x, ll y) {
x += y;
if (x >= MOD)
return x - MOD;
return x;
}
ll sub(ll x, ll y) {
x -= y;
if (x < 0)
return x + MOD;
return x;
}
ll mult(ll x, ll y) { return (x * y) % MOD; }
ll bin_pow(ll x, ll p) {
if (p == 0)
return 1;
if (p & 1)
return mult(x, bin_pow(x, p - 1));
return bin_pow(mult(x, x), p / 2);
}
int Hash[5000010], hash_t;
int b = 1e7 + 1, h = 1e9 + 7;
string S, T;
bool used[5000010];
int get_hash(string S) {
int N = S.size();
int res = 0;
REP(i, N) {
res = mult(res, b);
res += S[i] - 'a' + 1;
}
// res = mult(res, b);
return res % MOD;
}
int calc(string S, string T) {
int N = S.size();
int M = T.size();
while (S.size() < 2 * 1e5)
S += S;
int fir = 0;
REP(i, M) {
fir = mult(fir, b);
fir += S[i] - 'a' + 1;
}
Hash[0] = fir;
// print(Hash[0]);
REP(i, 22 * 1e5 - M) {
int res = Hash[i];
res = mult(res, b);
res = sub(res, mult(S[i] - 'a' + 1, bin_pow(b, M)));
res = add(res, S[i + M] - 'a' + 1);
Hash[i + 1] = res;
// if(i<20)print(Hash[i + 1]);
}
int mx = 0;
REP(i, 22 * 1e5 - M) {
// if (i > 1000)break;
if (used[i])
continue;
used[i] = true;
int cnt = 0;
if (Hash[i] == hash_t) {
cnt++;
// pe(i); print(cnt);
int nex = i + M;
used[nex] = true;
while (nex < 22 * 1e5 - M && Hash[nex] == hash_t) {
cnt++;
// pe(nex)print(cnt);
nex += M;
used[nex] = true;
if (cnt > (16 * 1e5) / M)
return -1;
}
}
chmax(mx, cnt);
}
return mx;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> S >> T;
hash_t = get_hash(T);
// print(hash_t);
print(calc(S, T));
}
| #pragma GCC optimize("-O3", "unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits.h>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#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 SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define m0(x) memset(x, 0, sizeof(x))
#define print(x) cout << x << '\n';
#define pe(x) cout << x << " ";
#define lb(v, n) lower_bound(v.begin(), v.end(), n);
#define ub(v, n) upper_bound(v.begin(), v.end(), n);
#define int long long
//#define int unsigned long long
#define all(x) (x).begin(), (x).end()
#define double long double
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int MOD = 1e9 + 7;
const ll INF = 1e17;
const double pi = acos(-1);
const double EPS = 1e-10;
typedef pair<int, int> P;
const int MAX = 200020;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll add(ll x, ll y) {
x += y;
if (x >= MOD)
return x - MOD;
return x;
}
ll sub(ll x, ll y) {
x -= y;
if (x < 0)
return x + MOD;
return x;
}
ll mult(ll x, ll y) { return (x * y) % MOD; }
ll bin_pow(ll x, ll p) {
if (p == 0)
return 1;
if (p & 1)
return mult(x, bin_pow(x, p - 1));
return bin_pow(mult(x, x), p / 2);
}
int Hash[3000010], hash_t;
int b = 1e7 + 1, h = 1e9 + 7;
string S, T;
bool used[3000010];
int get_hash(string S) {
int N = S.size();
int res = 0;
REP(i, N) {
res = mult(res, b);
res += S[i] - 'a' + 1;
}
// res = mult(res, b);
return res % MOD;
}
int calc(string S, string T) {
int N = S.size();
int M = T.size();
while (S.size() < 22 * 1e5)
S += S;
int fir = 0;
REP(i, M) {
fir = mult(fir, b);
fir += S[i] - 'a' + 1;
}
Hash[0] = fir;
// print(Hash[0]);
REP(i, 22 * 1e5 - M) {
int res = Hash[i];
res = mult(res, b);
res = sub(res, mult(S[i] - 'a' + 1, bin_pow(b, M)));
res = add(res, S[i + M] - 'a' + 1);
Hash[i + 1] = res;
// if(i<20)print(Hash[i + 1]);
}
int mx = 0;
REP(i, 22 * 1e5 - M) {
// if (i > 1000)break;
if (used[i])
continue;
used[i] = true;
int cnt = 0;
if (Hash[i] == hash_t) {
cnt++;
// pe(i); print(cnt);
int nex = i + M;
used[nex] = true;
while (nex < 22 * 1e5 - M && Hash[nex] == hash_t) {
cnt++;
// pe(nex)print(cnt);
nex += M;
used[nex] = true;
if (cnt > (16 * 1e5) / M)
return -1;
}
}
chmax(mx, cnt);
}
return mx;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> S >> T;
hash_t = get_hash(T);
// print(hash_t);
print(calc(S, T));
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"control_flow.loop.condition.change"
] | 770,900 | 770,901 | u859396346 | cpp |
p02962 | //#define NDEBUG
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <vector>
namespace n91 {
using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
constexpr usize operator"" _z(unsigned long long x) noexcept {
return static_cast<usize>(x);
}
class rep {
const usize f, l;
public:
class itr {
friend rep;
usize i;
constexpr itr(const usize x) noexcept : i(x) {}
public:
void operator++() noexcept { ++i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr rep(const usize first, const usize last) noexcept
: f(first), l(last) {}
constexpr itr begin() const noexcept { return itr(f); }
constexpr itr end() const noexcept { return itr(l); }
};
class revrep {
const usize f, l;
public:
class itr {
friend revrep;
usize i;
constexpr itr(usize x) noexcept : i(x) {}
public:
void operator++() noexcept { --i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr revrep(usize first, usize last) noexcept : f(--first), l(--last) {}
constexpr itr begin() const noexcept { return itr(l); }
constexpr itr end() const noexcept { return itr(f); }
};
template <class T> using vec_alias = std::vector<T>;
template <class T> auto md_vec(const usize n, const T &value) {
return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) {
return a < b ? b - a : a - b;
}
template <class T> T scan() {
T ret;
std::cin >> ret;
return ret;
}
} // namespace n91
#include <cstdint>
#include <vector>
namespace n91 {
template <class Base> struct mersenne61_rolling_hash {
using u64 = std::uint_fast64_t;
using value_type = u64;
using container_type = std::vector<value_type>;
using size_type = typename container_type::size_type;
template <int Width> static constexpr u64 div(const u64 v) noexcept {
return v >> Width;
}
template <int Width> static constexpr u64 mod(const u64 v) noexcept {
return v & (static_cast<u64>(1) << Width) - static_cast<u64>(1);
}
static constexpr u64 Modulus =
(static_cast<u64>(1) << 61) - static_cast<u64>(1);
static constexpr u64 shl31(const u64 v) noexcept {
return (div<30>(v) << 31) + mod<30>(v);
}
static constexpr u64 calc(u64 v) noexcept {
if (v > Modulus) {
v = div<61>(v) + mod<61>(v);
}
if (v > Modulus) {
return v -= Modulus;
}
return v;
}
static constexpr u64 multiplies(const u64 l, const u64 r) noexcept {
const u64 lu = div<31>(l), ld = mod<31>(l), ru = div<31>(r),
rd = mod<31>(r);
return calc((lu * ru << 1) + ld * rd + shl31(lu * rd + ru * ld));
}
static constexpr u64 multiplies_plus(const u64 l, const u64 r,
const u64 c) noexcept {
const u64 lu = div<31>(l), ld = mod<31>(l), ru = div<31>(r),
rd = mod<31>(r);
return calc((lu * ru << 1) + ld * rd + shl31(lu * rd + ru * ld) + c);
}
container_type prefix, power;
public:
template <class InputIterator>
explicit mersenne61_rolling_hash(InputIterator first,
const InputIterator last) noexcept
: prefix(), power() {
const size_type n = static_cast<size_type>(std::distance(first, last));
prefix.reserve(n + static_cast<size_type>(1));
prefix.push_back(static_cast<value_type>(0));
for (; first != last; ++first) {
prefix.push_back(multiplies_plus(prefix.back(), Base::value, *first));
}
power.reserve(n + static_cast<size_type>(1));
power.push_back(static_cast<value_type>(1));
for (size_type i = static_cast<size_type>(0); i != n; ++i) {
power.push_back(multiplies(power.back(), Base::value));
}
}
value_type operator()(const size_type first,
const size_type last) const noexcept {
return multiplies_plus(prefix[first], power[last - first],
Modulus - prefix[last]);
}
};
} // namespace n91
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <utility>
namespace n91 {
void main_() {
using hash = mersenne61_rolling_hash<std::integral_constant<u64, 62479294>>;
auto s = scan<std::string>();
const auto t = scan<std::string>();
const usize m = t.size();
while (s.size() < m) {
s = s + s;
}
const usize n = s.size();
s = s + s;
const hash sh(s.cbegin(), s.cend());
const u64 th = hash(t.cbegin(), t.cend())(0_z, m);
std::vector<usize> next(n, n), prev(n, n);
for (const auto i : rep(0_z, n)) {
if (sh(i, i + m) == th) {
next[i] = (i + m) % n;
prev[next[i]] = i;
}
}
usize r_cnt = 0_z;
usize ans = 0_z;
for (const auto i : rep(0_z, n)) {
if (prev[i] == n) {
++r_cnt;
usize count = 0_z;
usize v = next[i];
while (v != n) {
++r_cnt;
v = next[v];
++count;
}
ans = std::max(ans, count);
}
}
if (r_cnt == n) {
std::cout << ans << std::endl;
} else {
std::cout << "-1" << std::endl;
}
}
} // namespace n91
int main() {
n91::main_();
return 0;
}
| //#define NDEBUG
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <vector>
namespace n91 {
using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
constexpr usize operator"" _z(unsigned long long x) noexcept {
return static_cast<usize>(x);
}
class rep {
const usize f, l;
public:
class itr {
friend rep;
usize i;
constexpr itr(const usize x) noexcept : i(x) {}
public:
void operator++() noexcept { ++i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr rep(const usize first, const usize last) noexcept
: f(first), l(last) {}
constexpr itr begin() const noexcept { return itr(f); }
constexpr itr end() const noexcept { return itr(l); }
};
class revrep {
const usize f, l;
public:
class itr {
friend revrep;
usize i;
constexpr itr(usize x) noexcept : i(x) {}
public:
void operator++() noexcept { --i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr revrep(usize first, usize last) noexcept : f(--first), l(--last) {}
constexpr itr begin() const noexcept { return itr(l); }
constexpr itr end() const noexcept { return itr(f); }
};
template <class T> using vec_alias = std::vector<T>;
template <class T> auto md_vec(const usize n, const T &value) {
return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) {
return a < b ? b - a : a - b;
}
template <class T> T scan() {
T ret;
std::cin >> ret;
return ret;
}
} // namespace n91
#include <cstdint>
#include <vector>
namespace n91 {
template <class Base> struct mersenne61_rolling_hash {
using u64 = std::uint_fast64_t;
using value_type = u64;
using container_type = std::vector<value_type>;
using size_type = typename container_type::size_type;
template <int Width> static constexpr u64 div(const u64 v) noexcept {
return v >> Width;
}
template <int Width> static constexpr u64 mod(const u64 v) noexcept {
return v & (static_cast<u64>(1) << Width) - static_cast<u64>(1);
}
static constexpr u64 Modulus =
(static_cast<u64>(1) << 61) - static_cast<u64>(1);
static constexpr u64 shl31(const u64 v) noexcept {
return (mod<30>(v) << 31) + div<30>(v);
}
static constexpr u64 calc(u64 v) noexcept {
if (v > Modulus) {
v = div<61>(v) + mod<61>(v);
}
if (v > Modulus) {
return v -= Modulus;
}
return v;
}
static constexpr u64 multiplies(const u64 l, const u64 r) noexcept {
const u64 lu = div<31>(l), ld = mod<31>(l), ru = div<31>(r),
rd = mod<31>(r);
return calc((lu * ru << 1) + ld * rd + shl31(lu * rd + ru * ld));
}
static constexpr u64 multiplies_plus(const u64 l, const u64 r,
const u64 c) noexcept {
const u64 lu = div<31>(l), ld = mod<31>(l), ru = div<31>(r),
rd = mod<31>(r);
return calc((lu * ru << 1) + ld * rd + shl31(lu * rd + ru * ld) + c);
}
container_type prefix, power;
public:
template <class InputIterator>
explicit mersenne61_rolling_hash(InputIterator first,
const InputIterator last) noexcept
: prefix(), power() {
const size_type n = static_cast<size_type>(std::distance(first, last));
prefix.reserve(n + static_cast<size_type>(1));
prefix.push_back(static_cast<value_type>(0));
for (; first != last; ++first) {
prefix.push_back(multiplies_plus(prefix.back(), Base::value, *first));
}
power.reserve(n + static_cast<size_type>(1));
power.push_back(static_cast<value_type>(1));
for (size_type i = static_cast<size_type>(0); i != n; ++i) {
power.push_back(multiplies(power.back(), Base::value));
}
}
value_type operator()(const size_type first,
const size_type last) const noexcept {
return multiplies_plus(prefix[first], power[last - first],
Modulus - prefix[last]);
}
};
} // namespace n91
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <utility>
namespace n91 {
void main_() {
using hash = mersenne61_rolling_hash<std::integral_constant<u64, 62479294>>;
auto s = scan<std::string>();
const auto t = scan<std::string>();
const usize m = t.size();
while (s.size() < m) {
s = s + s;
}
const usize n = s.size();
s = s + s;
const hash sh(s.cbegin(), s.cend());
const u64 th = hash(t.cbegin(), t.cend())(0_z, m);
std::vector<usize> next(n, n), prev(n, n);
for (const auto i : rep(0_z, n)) {
if (sh(i, i + m) == th) {
next[i] = (i + m) % n;
prev[next[i]] = i;
}
}
usize r_cnt = 0_z;
usize ans = 0_z;
for (const auto i : rep(0_z, n)) {
if (prev[i] == n) {
++r_cnt;
usize count = 0_z;
usize v = next[i];
while (v != n) {
++r_cnt;
v = next[v];
++count;
}
ans = std::max(ans, count);
}
}
if (r_cnt == n) {
std::cout << ans << std::endl;
} else {
std::cout << "-1" << std::endl;
}
}
} // namespace n91
int main() {
n91::main_();
return 0;
}
| [
"identifier.change",
"function.return_value.change",
"expression.operation.binary.change"
] | 770,904 | 770,905 | u708618797 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.