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 |
|---|---|---|---|---|---|---|---|
p03061 | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 2; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[n - 2], R[1]);
for (int i = 0; i < n; ++i) {
int l = L[i];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 2; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[n - 2], R[1]); //下のfor文だと,これらを計算しないから.
for (int i = 1; i < n - 1; ++i) {
int l = L[i - 1];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 874,137 | 874,134 | u509680664 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 2; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[1], R[n - 2]);
// int ans{};
for (int i = 1; i < n - 1; ++i) {
int l = L[i - 1];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 2; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[n - 2], R[1]); // L[for文のrの初期値], R[lの初期値]
// int ans{};
for (int i = 1; i < n - 1; ++i) {
int l = L[i - 1];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | [
"call.arguments.change",
"call.arguments.add"
] | 874,133 | 874,138 | u509680664 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 1; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[n - 2], R[1]);
for (int i = 1; i < n - 1; ++i) {
int l = L[i];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 2; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[n - 2], R[1]); // L[for文のrの初期値], R[lの初期値]
// int ans{};
for (int i = 1; i < n - 1; ++i) {
int l = L[i - 1];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 874,135 | 874,138 | u509680664 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 2; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[n - 2], R[1]);
for (int i = 1; i < n - 1; ++i) {
int l = L[i];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 2; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[n - 2], R[1]); // L[for文のrの初期値], R[lの初期値]
// int ans{};
for (int i = 1; i < n - 1; ++i) {
int l = L[i - 1];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | [
"assignment.change"
] | 874,136 | 874,138 | u509680664 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 2; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[n - 2], R[1]);
for (int i = 1; i < n - 1; ++i) {
int l = L[i];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 2; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[n - 2], R[1]);
for (int i = 1; i < n - 1; ++i) {
int l = L[i - 1];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | [
"assignment.change"
] | 874,136 | 874,139 | u509680664 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 2; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[n - 2], R[1]);
for (int i = 0; i < n; ++i) {
int l = L[i];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int32_t GCD(int32_t a, int32_t b) { return b ? GCD(b, a % b) : a; }
int64_t GCD(int64_t a, int64_t b) { return b ? GCD(b, a % b) : a; }
int32_t LCM(int32_t a, int32_t b) { return a * b / GCD(a, b); }
int64_t LCM(int64_t a, int64_t b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
constexpr int32_t INF = 1001001001;
constexpr int64_t LINF = 1001001001001001001ll;
constexpr int32_t MOD = 1e9 + 7; // 10^9
constexpr int64_t EPS = 1e-9;
constexpr int32_t dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// constexpr int32_t dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
//#define int int64_t
signed main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0, i_len = (int)n; i < i_len; ++i)
cin >> a[i];
vector<int> L(n, -1);
L[0] = a[0];
vector<int> R(n, -1);
R[n - 1] = a[n - 1];
// cumGCD
for (int l = 1; l < n; ++l) {
L[l] = GCD(L[l - 1], a[l]);
}
for (int r = n - 2; r >= 0; --r) {
R[r] = GCD(R[r + 1], a[r]);
}
int ans = max(L[n - 2], R[1]);
for (int i = 1; i < n - 1; ++i) {
int l = L[i - 1];
int r = R[i + 1];
amax(ans, GCD(l, r));
}
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 874,137 | 874,139 | u509680664 | cpp |
p03061 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define irep(i, n) for (int i = n - 1; i >= 0; i--)
typedef long long ll;
#define intv vector<int>
#define llv vector<long long>
#define intvv vector<vector<int>>
#define llvv vector<vector<long long>>
using namespace std;
int main() {
int n;
cin >> n;
llv a(100000);
rep(i, n) cin >> a[i];
llv l(100000), r(100000);
l[0] = 0;
r[n] = 0;
rep(i, n) { l[i + 1] = __gcd(l[i], a[i]); }
irep(i, n) { r[i] = __gcd(r[i + 1], a[i]); }
ll ans = 0;
int j = 0;
while (j <= n - 1) {
ans = max(ans, max(l[j], r[j + 1]));
j++;
}
cout << ans << endl;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define irep(i, n) for (int i = n - 1; i >= 0; i--)
typedef long long ll;
#define intv vector<int>
#define llv vector<long long>
#define intvv vector<vector<int>>
#define llvv vector<vector<long long>>
using namespace std;
int main() {
int n;
cin >> n;
llv a(100000);
rep(i, n) cin >> a[i];
llv l(100000), r(100000);
l[0] = 0;
r[n] = 0;
rep(i, n) { l[i + 1] = __gcd(l[i], a[i]); }
irep(i, n) { r[i] = __gcd(r[i + 1], a[i]); }
ll ans = 0;
int j = 0;
while (j <= n - 1) {
ans = max(ans, __gcd(l[j], r[j + 1]));
j++;
}
cout << ans << endl;
}
| [
"assignment.value.change",
"identifier.change",
"call.function.change",
"call.arguments.change"
] | 874,144 | 874,145 | u379440427 | cpp |
p03061 | #include <iomanip>
#include <iostream>
#include <math.h>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int gcd(int a, int b) {
if (a < b) {
int temp = a;
a = b;
b = temp;
}
while (a % b != 0) {
int temp = a;
a = b;
b = temp % b;
}
return b;
}
int main(void) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int b[n], c[n];
b[0] = a[1], c[n - 1] = a[n - 1];
for (int i = 1; i < n; i++) {
b[i] = gcd(b[i - 1], a[i]);
}
for (int i = n - 2; i >= 0; i--) {
c[i] = gcd(c[i + 1], a[i]);
}
int ans = 1;
if (b[n - 2] > ans) {
ans = b[n - 2];
}
if (c[1] > ans) {
ans = c[1];
}
for (int i = 1; i < n - 1; i++) {
int num = gcd(b[i - 1], c[i + 1]);
if (num > ans) {
ans = num;
}
}
cout << ans << endl;
}
| #include <iomanip>
#include <iostream>
#include <math.h>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
int gcd(int a, int b) {
if (a < b) {
int temp = a;
a = b;
b = temp;
}
while (a % b != 0) {
int temp = a;
a = b;
b = temp % b;
}
return b;
}
int main(void) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int b[n], c[n];
b[0] = a[0];
c[n - 1] = a[n - 1];
for (int i = 1; i < n; i++) {
b[i] = gcd(b[i - 1], a[i]);
}
for (int i = n - 2; i >= 0; i--) {
c[i] = gcd(c[i + 1], a[i]);
}
int ans = 1;
if (b[n - 2] > ans) {
ans = b[n - 2];
}
if (c[1] > ans) {
ans = c[1];
}
for (int i = 1; i < n - 1; i++) {
int num = gcd(b[i - 1], c[i + 1]);
if (num > ans) {
ans = num;
}
}
cout << ans << endl;
}
| [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change"
] | 874,152 | 874,153 | u161609067 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int n;
int a[100010];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int l[100010] = {};
int r[100010] = {};
for (int i = 0; i < n; i++) {
if (l[i] == 0) {
l[i + 1] = a[i];
} else {
l[i + 1] = __gcd(l[i], a[i]);
}
}
for (int i = n - 1; i >= 0; i--) {
if (r[i + 1] == 0) {
r[i] = a[i];
} else {
r[i] = __gcd(r[i + 1], a[i]);
}
}
int ans = max(l[n], r[1]);
for (int i = 1; i < n - 1; i++) {
ans = max(ans, __gcd(l[i], r[i + 1]));
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int n;
int a[100010];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int l[100010] = {};
int r[100010] = {};
for (int i = 0; i < n; i++) {
if (l[i] == 0) {
l[i + 1] = a[i];
} else {
l[i + 1] = __gcd(l[i], a[i]);
}
}
for (int i = n - 1; i >= 0; i--) {
if (r[i + 1] == 0) {
r[i] = a[i];
} else {
r[i] = __gcd(r[i + 1], a[i]);
}
}
int ans = max(l[n - 1], r[1]);
for (int i = 1; i < n - 1; i++) {
ans = max(ans, __gcd(l[i], r[i + 1]));
}
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 874,163 | 874,164 | u221119670 | cpp |
p03061 |
// C
#include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) {
if (a < b)
swap(a, b);
// cout << a << " " << b << endl;
if (b == 0)
return a;
else
return GCD(a % b, b);
}
int main() {
int N;
cin >> N;
int A[N];
int L[N];
int R[N];
for (int i = 0; i < N; i++)
cin >> A[i];
L[0] = 0;
R[0] = 0;
for (int i = 0; i < N - 1; i++) {
L[i + 1] = GCD(L[i], A[i]);
R[i + 1] = GCD(R[i], A[N - i - 1]);
// cout << L[i+1] << " " << R[i+1] << endl;
}
int ans = 0;
for (int i = 0; i < N - 1; i++) {
ans = max(ans, GCD(L[i], R[N - 1 - i]));
// cout << ans << endl;
}
cout << ans << endl;
} |
// C
#include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) {
if (a < b)
swap(a, b);
// cout << a << " " << b << endl;
if (b == 0)
return a;
else
return GCD(a % b, b);
}
int main() {
int N;
cin >> N;
int A[N];
int L[N];
int R[N];
for (int i = 0; i < N; i++)
cin >> A[i];
L[0] = 0;
R[0] = 0;
for (int i = 0; i < N - 1; i++) {
L[i + 1] = GCD(L[i], A[i]);
R[i + 1] = GCD(R[i], A[N - i - 1]);
// cout << L[i+1] << " " << R[i+1] << endl;
}
int ans = 0;
for (int i = 0; i < N; i++) {
ans = max(ans, GCD(L[i], R[N - 1 - i]));
// cout << ans << endl;
}
cout << ans << endl;
}
| [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 874,167 | 874,168 | u583701239 | cpp |
p03061 |
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<int> r(n), l(n);
rep(i, n) l[i + 1] = gcd(l[i], a[i]);
/*
for(int i=0; i<n; ++i)
{
l[i+1] = gcd(l[i],a[i]);
}
*/
for (int i = n - 1; i >= 1; --i) {
r[i - 1] = gcd(r[i], a[i]);
}
int ans = 1;
rep(i, n) ans = max(ans, gcd(l[i], r[i]));
/*
for(int i=0; i<n; ++i)
{
ans = max(ans, gcd(l[i],r[i]));
}
*/
cout << ans << endl;
return 0;
} | //#include <bits/stdc++.h>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<int> r(n), l(n);
rep(i, n - 1) l[i + 1] = gcd(l[i], a[i]);
/*
for(int i=0; i<n; ++i)
{
l[i+1] = gcd(l[i],a[i]);
}
*/
for (int i = n - 1; i >= 1; --i) {
r[i - 1] = gcd(r[i], a[i]);
}
int ans = 1;
rep(i, n) ans = max(ans, gcd(l[i], r[i]));
/*
for(int i=0; i<n; ++i)
{
ans = max(ans, gcd(l[i],r[i]));
}
*/
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 874,169 | 874,170 | u365159808 | cpp |
p03061 | #include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(), a.end())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define MP(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define INF LLONG_MAX / 2
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
cerr << #v << ":"; \
rep(i, v.size()) cerr << " " << v[i]; \
cerr << endl
using namespace std;
int MOD = 998244353;
int gcd(int a, int b) {
if (a < b) {
int c = a;
a = b;
b = c;
}
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
signed main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
vector<int> c(n);
rep(i, n) cin >> a[i];
b[0] = a[0];
c[n - 1] = a[n - 1];
for (int i = 1; i < n; i++) {
b[i] = gcd(a[i], b[i - 1]);
c[n - 1 - i] = gcd(a[n - 1 - i], c[n - i]);
}
int ans = max(b[1], c[n - 2]);
for (int i = 1; i < n - 1; i++) {
ans = max(ans, gcd(b[i - 1], c[i + 1]));
}
cout << ans << endl;
rep(i, n) cerr << b[i] << " ";
cerr << endl;
rep(i, n) cerr << c[i] << " ";
cerr << endl;
return 0;
}
// g++ -std=c++14 code1.cpp
// rm -r -f test;oj dl
// https://cf17-final-open.contest.atcoder.jp/tasks/cf17_final_a rm -r -f
// test;oj dl http://abc125.contest.atcoder.jp/tasks/abc125_c
| #include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(), a.end())
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define MP(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define INF LLONG_MAX / 2
#define all(x) (x).begin(), (x).end()
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
cerr << #v << ":"; \
rep(i, v.size()) cerr << " " << v[i]; \
cerr << endl
using namespace std;
int MOD = 998244353;
int gcd(int a, int b) {
if (a < b) {
int c = a;
a = b;
b = c;
}
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
signed main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
vector<int> c(n);
rep(i, n) cin >> a[i];
b[0] = a[0];
c[n - 1] = a[n - 1];
for (int i = 1; i < n; i++) {
b[i] = gcd(a[i], b[i - 1]);
c[n - 1 - i] = gcd(a[n - 1 - i], c[n - i]);
}
int ans = max(c[1], b[n - 2]);
for (int i = 1; i < n - 1; i++) {
ans = max(ans, gcd(b[i - 1], c[i + 1]));
}
cout << ans << endl;
rep(i, n) cerr << b[i] << " ";
cerr << endl;
rep(i, n) cerr << c[i] << " ";
cerr << endl;
return 0;
}
// g++ -std=c++14 code1.cpp
// rm -r -f test;oj dl
// https://cf17-final-open.contest.atcoder.jp/tasks/cf17_final_a rm -r -f
// test;oj dl http://abc125.contest.atcoder.jp/tasks/abc125_c
| [
"identifier.change",
"call.arguments.change"
] | 874,173 | 874,174 | u548768105 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
long long int gcd(long long int m, long long int n) {
if (n == 0) {
return m;
}
return gcd(n, m % n);
}
long long int lcm(long long int number1, long long int number2) {
return number1 * number2 / gcd(number1, number2);
}
ll max2(ll a, ll b) {
if (a > b) {
return a;
} else {
return b;
}
}
int main() {
int N;
cin >> N;
vector<ll> A(N);
vector<ll> rig(N);
vector<ll> lef(N);
cin >> A[0];
ll ans = A[0];
rig[0] = ans;
for (ll i = 1; i < N; i++) {
cin >> A[i];
ans = gcd(ans, A[i]);
rig[i] = ans;
}
lef[0] = A[N - 1];
ans = A[N - 1];
for (ll i = 1; i < N; i++) {
ans = gcd(ans, A[N - 1 - i]);
lef[i] = ans;
}
int max = max2(rig[N - 2], lef[N - 2]);
for (ll i = 1; i < N - 1; i++) {
int t = gcd(rig[i - 1], lef[i - 1]);
if (t > max) {
max = t;
}
}
cout << max << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
long long int gcd(long long int m, long long int n) {
if (n == 0) {
return m;
}
return gcd(n, m % n);
}
long long int lcm(long long int number1, long long int number2) {
return number1 * number2 / gcd(number1, number2);
}
ll max2(ll a, ll b) {
if (a > b) {
return a;
} else {
return b;
}
}
int main() {
int N;
cin >> N;
vector<ll> A(N);
vector<ll> rig(N);
vector<ll> lef(N);
cin >> A[0];
ll ans = A[0];
rig[0] = ans;
for (ll i = 1; i < N; i++) {
cin >> A[i];
ans = gcd(ans, A[i]);
rig[i] = ans;
}
lef[0] = A[N - 1];
ans = A[N - 1];
for (ll i = 1; i < N; i++) {
ans = gcd(ans, A[N - 1 - i]);
lef[i] = ans;
}
int max = max2(rig[N - 2], lef[N - 2]);
for (ll i = 1; i < N - 1; i++) {
int t = gcd(rig[i - 1], lef[N - 2 - i]);
if (t > max) {
max = t;
}
}
cout << max << endl;
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"literal.number.change"
] | 874,181 | 874,182 | u096717230 | cpp |
p03061 | #include "bits/stdc++.h"
#define ed cout << "\n";
#define speed \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long
#define ffor(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define rep(i, n) ffor(i, 0, n)
#define All(obj) (obj).begin(), (obj).end()
#define INF ((ll)1e9 + 7)
#define c(a) cout << a << "\n";
using namespace std;
const int N = 100005;
int gcd(int a, int b) {
if (a < b)
swap(a, b);
while (ll r = (a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
speed;
int n;
cin >> n;
vector<int> a(n);
rep(i, n) { cin >> a[i]; }
vector<int> l(n);
vector<int> r(n);
l[0] = a[0];
r[n - 1] = a[n - 1];
ffor(i, 1, n) {
l[i] = gcd(a[i], l[i - 1]);
r[n - 1 - i] = gcd(r[n - 1], a[n - 1 - i]);
}
int ans = 0;
rep(i, n) {
if (i == 0)
ans = max(ans, r[1]);
else if (i == n - 1)
ans = max(ans, l[n - 2]);
else
ans = max(ans, gcd(l[i - 1], r[i + 1]));
}
c(ans);
return 0;
}
| #include "bits/stdc++.h"
#define ed cout << "\n";
#define speed \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long
#define ffor(i, a, b) for (ll i = (ll)(a); i < (ll)(b); ++i)
#define rep(i, n) ffor(i, 0, n)
#define All(obj) (obj).begin(), (obj).end()
#define INF ((ll)1e9 + 7)
#define c(a) cout << a << "\n";
using namespace std;
const int N = 100005;
int gcd(ll a, ll b) {
if (a < b)
swap(a, b);
while (ll r = (a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
speed;
int n;
cin >> n;
vector<int> a(n);
rep(i, n) { cin >> a[i]; }
vector<int> l(n);
vector<int> r(n);
l[0] = a[0];
r[n - 1] = a[n - 1];
ffor(i, 1, n) {
l[i] = gcd(a[i], l[i - 1]);
r[n - 1 - i] = gcd(r[n - i], a[n - 1 - i]);
}
int ans = 0;
rep(i, n) {
if (i == 0)
ans = max(ans, r[1]);
else if (i == n - 1)
ans = max(ans, l[n - 2]);
else
ans = max(ans, gcd(l[i - 1], r[i + 1]));
}
c(ans);
return 0;
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 874,183 | 874,184 | u662918817 | cpp |
p03061 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
ll euq_gcd(ll a, ll b) { return b ? euq_gcd(b, a % b) : a; }
int main() {
ll N;
cin >> N;
vector<ll> A(N + 1);
for (ll i = 1; i <= N; i++)
cin >> A[i];
vector<ll> L(N), R(N);
L[0] = R[N + 1] = 0;
for (ll i = 1; i <= N; i++) {
L[i] = euq_gcd(L[i - 1], A[i]);
R[N + 1 - i] = euq_gcd(R[N + 2 - i], A[N + 1 - i]);
}
ll max = -1;
for (ll i = 1; i <= N; i++) {
ll temp = euq_gcd(L[i - 1], R[i + 1]);
if (temp > max)
max = temp;
}
cout << max << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
ll euq_gcd(ll a, ll b) { return b ? euq_gcd(b, a % b) : a; }
int main() {
ll N;
cin >> N;
vector<ll> A(N + 1);
for (ll i = 1; i <= N; i++)
cin >> A[i];
vector<ll> L(N), R(N + 2);
L[0] = R[N + 1] = 0;
for (ll i = 1; i < N; i++) {
L[i] = euq_gcd(L[i - 1], A[i]);
R[N + 1 - i] = euq_gcd(R[N + 2 - i], A[N + 1 - i]);
}
ll max = -1;
for (ll i = 1; i <= N; i++) {
ll temp = euq_gcd(L[i - 1], R[i + 1]);
if (temp > max)
max = temp;
}
cout << max << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 874,187 | 874,186 | u703503553 | cpp |
p03061 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
ll euq_gcd(ll a, ll b) { return b ? euq_gcd(b, a % b) : a; }
int main() {
ll N;
cin >> N;
vector<ll> A(N + 1);
for (ll i = 1; i <= N; i++)
cin >> A[i];
vector<ll> L(N), R(N);
L[0] = R[N + 1] = 0;
for (ll i = 1; i < N; i++) {
L[i] = euq_gcd(L[i - 1], A[i]);
R[N + 1 - i] = euq_gcd(R[N + 2 - i], A[N + 1 - i]);
}
ll max = -1;
for (ll i = 1; i <= N; i++) {
ll temp = euq_gcd(L[i - 1], R[i + 1]);
if (temp > max)
max = temp;
}
cout << max << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
ll euq_gcd(ll a, ll b) { return b ? euq_gcd(b, a % b) : a; }
int main() {
ll N;
cin >> N;
vector<ll> A(N + 1);
for (ll i = 1; i <= N; i++)
cin >> A[i];
vector<ll> L(N), R(N + 2);
L[0] = R[N + 1] = 0;
for (ll i = 1; i < N; i++) {
L[i] = euq_gcd(L[i - 1], A[i]);
R[N + 1 - i] = euq_gcd(R[N + 2 - i], A[N + 1 - i]);
}
ll max = -1;
for (ll i = 1; i <= N; i++) {
ll temp = euq_gcd(L[i - 1], R[i + 1]);
if (temp > max)
max = temp;
}
cout << max << endl;
return 0;
} | [
"assignment.change"
] | 874,188 | 874,186 | u703503553 | cpp |
p03061 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
ll euq_gcd(ll a, ll b) { return b ? euq_gcd(b, a % b) : a; }
int main() {
int N;
cin >> N;
vector<ll> A(N + 1);
for (int i = 1; i <= N; i++)
cin >> A[i];
vector<ll> L(N), R(N);
L[0] = R[N + 1] = 0;
for (ll i = 1; i < N; i++) {
L[i] = euq_gcd(L[i - 1], A[i]);
R[N + 1 - i] = euq_gcd(R[N + 2 - i], A[N + 1 - i]);
}
ll max = -1;
for (ll i = 1; i <= N; i++) {
ll temp = euq_gcd(L[i - 1], R[i + 1]);
if (temp > max)
max = temp;
}
cout << max << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
ll euq_gcd(ll a, ll b) { return b ? euq_gcd(b, a % b) : a; }
int main() {
ll N;
cin >> N;
vector<ll> A(N + 1);
for (ll i = 1; i <= N; i++)
cin >> A[i];
vector<ll> L(N), R(N + 2);
L[0] = R[N + 1] = 0;
for (ll i = 1; i < N; i++) {
L[i] = euq_gcd(L[i - 1], A[i]);
R[N + 1 - i] = euq_gcd(R[N + 2 - i], A[N + 1 - i]);
}
ll max = -1;
for (ll i = 1; i <= N; i++) {
ll temp = euq_gcd(L[i - 1], R[i + 1]);
if (temp > max)
max = temp;
}
cout << max << endl;
return 0;
} | [
"variable_declaration.type.change",
"control_flow.loop.for.initializer.change"
] | 874,189 | 874,186 | u703503553 | cpp |
p03061 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <time.h>
#include <tuple>
#include <vector>
using namespace std;
//#define int long long
#define rep(i, s, n) for (int i = s; i < n; i++)
#define repe(i, s, n) for (int i = s; i <= n; i++)
#define rrep(i, s, n) for (int i = (n)-1; i >= (s); i--)
#define all(v) (v).begin(), (v).end()
#define pb push_back
#define fi first
#define se second
#define chmin(a, b) a = min((a), (b))
#define chmax(a, b) a = max((a), (b))
#define l1 list[index]
#define l2 list[index - 1]
#define l3 list[index + 1]
#define iif(i, j) ((i < 0 && j < 0) || (i > 0 && j > 0)) ? true : false
typedef long long ll;
typedef pair<int, int> pint;
typedef vector<int> vint;
typedef vector<pint> vpint;
typedef pair<pint, int> P1;
typedef pair<int, pint> P2;
typedef pair<pint, pint> PP;
static const ll maxLL = (ll)1 << 62;
const ll MOD = 1000000007;
const ll INF = 1e18;
const double PI = 3.14159265359;
int ca[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
ll euclidean_gcd(ll a, ll b) {
if (a < b)
return euclidean_gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
signed main() {
ll n;
vector<ll> list;
ll maxn = 0;
cin >> n;
for (ll i = 0; i < n; i++) {
ll num;
cin >> num;
list.push_back(num);
}
if (n == 2) {
cout << max(list[0], list[1]);
return 0;
}
vector<ll> L, R;
for (int i = 0; i < n; i++) {
if (i == 0) {
L.push_back(list[0]);
} else {
// L.push_back(euclidean_gcd(list[i - 1], list[i]));
L.push_back(euclidean_gcd(L[i - 1], list[i]));
}
}
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1) {
R.push_back(list[n - 1]);
} else {
// R.push_back(euclidean_gcd(list[i + 1], list[i]));
R.push_back(euclidean_gcd(list[R.size() - 1], list[i]));
}
}
reverse(R.begin(), R.end());
int l, r;
vector<ll> ans;
for (int i = 0; i < n; i++) {
l = i - 1;
r = i + 1;
if (l < 0) {
ans.push_back(R[r]);
} else if (i == n - 1) {
ans.push_back(L[l]);
} else {
ans.push_back(euclidean_gcd(L[l], R[r]));
}
}
sort(ans.begin(), ans.end(), greater<ll>());
cout << ans[0] << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <time.h>
#include <tuple>
#include <vector>
using namespace std;
//#define int long long
#define rep(i, s, n) for (int i = s; i < n; i++)
#define repe(i, s, n) for (int i = s; i <= n; i++)
#define rrep(i, s, n) for (int i = (n)-1; i >= (s); i--)
#define all(v) (v).begin(), (v).end()
#define pb push_back
#define fi first
#define se second
#define chmin(a, b) a = min((a), (b))
#define chmax(a, b) a = max((a), (b))
#define l1 list[index]
#define l2 list[index - 1]
#define l3 list[index + 1]
#define iif(i, j) ((i < 0 && j < 0) || (i > 0 && j > 0)) ? true : false
typedef long long ll;
typedef pair<int, int> pint;
typedef vector<int> vint;
typedef vector<pint> vpint;
typedef pair<pint, int> P1;
typedef pair<int, pint> P2;
typedef pair<pint, pint> PP;
static const ll maxLL = (ll)1 << 62;
const ll MOD = 1000000007;
const ll INF = 1e18;
const double PI = 3.14159265359;
int ca[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
ll euclidean_gcd(ll a, ll b) {
if (a < b)
return euclidean_gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
signed main() {
ll n;
vector<ll> list;
ll maxn = 0;
cin >> n;
for (ll i = 0; i < n; i++) {
ll num;
cin >> num;
list.push_back(num);
}
if (n == 2) {
cout << max(list[0], list[1]);
return 0;
}
vector<ll> L, R;
for (int i = 0; i < n; i++) {
if (i == 0) {
L.push_back(list[0]);
} else {
// L.push_back(euclidean_gcd(list[i - 1], list[i]));
L.push_back(euclidean_gcd(L[i - 1], list[i]));
}
}
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1) {
R.push_back(list[n - 1]);
} else {
// R.push_back(euclidean_gcd(list[i + 1], list[i]));
R.push_back(euclidean_gcd(R[R.size() - 1], list[i]));
}
}
reverse(R.begin(), R.end());
int l, r;
vector<ll> ans;
for (int i = 0; i < n; i++) {
l = i - 1;
r = i + 1;
if (l < 0) {
ans.push_back(R[r]);
} else if (i == n - 1) {
ans.push_back(L[l]);
} else {
ans.push_back(euclidean_gcd(L[l], R[r]));
}
}
sort(ans.begin(), ans.end(), greater<ll>());
cout << ans[0] << endl;
return 0;
} | [
"identifier.change",
"call.arguments.change"
] | 874,190 | 874,191 | u271719815 | cpp |
p03061 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
#define int long long
int32_t main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
vector<int> r(n + 1, 0);
vector<int> l(n + 1, 0);
for (int i = 1; i < n; i++) {
l[i] = __gcd(l[i - 1], v[i - 1]);
r[n - 1 - i] = __gcd(r[n - i], v[n - i]);
}
int ma = 0;
for (int i = 1; i < n; i++) {
if (ma <= __gcd(l[i], r[i])) {
ma = __gcd(l[i], r[i]);
}
}
cout << ma;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
#define int long long
int32_t main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
vector<int> r(n + 1, 0);
vector<int> l(n + 1, 0);
for (int i = 1; i < n; i++) {
l[i] = __gcd(l[i - 1], v[i - 1]);
r[n - 1 - i] = __gcd(r[n - i], v[n - i]);
}
int ma = 0;
for (int i = 0; i < n; i++) {
if (ma <= __gcd(l[i], r[i])) {
ma = __gcd(l[i], r[i]);
}
}
cout << ma;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 874,199 | 874,200 | u062324064 | cpp |
p03061 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
#define int long long
int32_t main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
vector<int> r(n + 1, 0);
vector<int> l(n + 1, 0);
for (int i = 1; i < n; i++) {
l[i] = __gcd(l[i - 1], v[i]);
r[n - 1 - i] = __gcd(r[n - i], v[n - i]);
}
int ma = 0;
for (int i = 1; i < n; i++) {
if (ma <= __gcd(l[i], r[i])) {
ma = __gcd(l[i], r[i]);
}
}
cout << ma;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
using namespace std;
#define int long long
int32_t main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
vector<int> r(n + 1, 0);
vector<int> l(n + 1, 0);
for (int i = 1; i < n; i++) {
l[i] = __gcd(l[i - 1], v[i - 1]);
r[n - 1 - i] = __gcd(r[n - i], v[n - i]);
}
int ma = 0;
for (int i = 0; i < n; i++) {
if (ma <= __gcd(l[i], r[i])) {
ma = __gcd(l[i], r[i]);
}
}
cout << ma;
}
| [
"assignment.change",
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 874,201 | 874,200 | u062324064 | cpp |
p03061 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using ll = unsigned long long;
using namespace std;
// http://drken1215.hatenablog.com/entry/2019/04/27/224100_1
int n;
ll *A;
int gcd(int a, int b) {
if (b == 0) {
return a;
} else {
gcd(b, a % b);
}
}
int main(void) {
cin >> n;
A = new ll[n];
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
// あるA[i]が無い状態での最大公約数を求める
// gcd(left[i], right[i])のうちで，もっとも大きい値が解
ll *left, *right;
// nが抜けてたときのために，+1
left = new ll[n + 1];
right = new ll[n + 1];
// forward 前向きに入れていく
left[0] = 0;
for (int i = 0; i < n; ++i) {
left[i + 1] = gcd(left[i], A[i]);
}
// backward 後ろ向きにいれていく
right[n] = 0;
for (int i = n - 1; i >= 0; ++i) {
right[i] = gcd(right[i + 1], A[i]);
}
// 集計する
int maxv = 0;
for (int i = 0; i < n; ++i) {
// index問題に弱すぎ...ちゃんと確認すること
int l = left[i];
int r = right[i + 1];
int cand = gcd(l, r);
if (maxv < cand) {
maxv = cand;
}
}
cout << maxv << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using ll = unsigned long long;
using namespace std;
// http://drken1215.hatenablog.com/entry/2019/04/27/224100_1
int n;
ll *A;
int gcd(int a, int b) {
if (b == 0) {
return a;
} else {
gcd(b, a % b);
}
}
int main(void) {
cin >> n;
A = new ll[n];
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
// あるA[i]が無い状態での最大公約数を求める
// gcd(left[i], right[i])のうちで，もっとも大きい値が解
ll *left, *right;
// nが抜けてたときのために，+1
left = new ll[n + 1];
right = new ll[n + 1];
// forward 前向きに入れていく
left[0] = 0;
for (int i = 0; i < n; ++i) {
left[i + 1] = gcd(left[i], A[i]);
}
// backward 後ろ向きにいれていく
right[n] = 0;
for (int i = n - 1; i >= 0; --i) {
right[i] = gcd(right[i + 1], A[i]);
}
// 集計する
int maxv = 0;
for (int i = 0; i < n; ++i) {
// index問題に弱すぎ...ちゃんと確認すること
int l = left[i];
int r = right[i + 1];
int cand = gcd(l, r);
if (maxv < cand) {
maxv = cand;
}
}
cout << maxv << endl;
return 0;
} | [] | 874,214 | 874,215 | u871841829 | cpp |
p03061 | #include <iostream>
#include <vector>
using namespace std;
using ll = long long int;
//拡張ユークリッドの互除法
// ax + by = cとなるようなc=gcd(a,b)をxをペアにして返す
// firstがx,secondがc
template <typename number>
pair<number, number> extended_euclid(number a, number b) {
number r0, r1, a0, a1, b0, b1;
r0 = a;
r1 = b;
a0 = 1;
a1 = 0;
b0 = 0;
b1 = 1;
while (r1 > 0) {
number q1 = r0 / r1;
number r2 = r0 % r1;
number a2 = a0 - q1 * a1;
number b2 = b0 - q1 * b1;
r0 = r1;
r1 = r2;
a0 = a1;
a1 = a2;
b0 = b1;
b1 = b2;
}
number c = r0;
a = a0; // x
b = b0; // y
return {a, c};
}
int main() {
int n;
cin >> n;
vector<ll> a(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<ll> memo1(n, 0);
vector<ll> memo2(n, 0);
memo1[0] = a[0];
memo2[n - 1] = a[n - 1];
for (int i = 1; i < n; i++) {
memo1[i] = extended_euclid(memo1[i - 1], a[i]).second;
memo2[n - 1 - i] = extended_euclid(memo2[n - i], a[n - 1 - i]).second;
}
ll result = max(memo1[n - 2], memo2[1]);
for (int i = 1; i < n - 1; i++) {
ll temp = extended_euclid(memo1[i - 1], memo2[n - 1]).second;
result = max(result, temp);
}
cout << result << endl;
} | #include <iostream>
#include <vector>
using namespace std;
using ll = long long int;
//拡張ユークリッドの互除法
// ax + by = cとなるようなc=gcd(a,b)をxをペアにして返す
// firstがx,secondがc
template <typename number>
pair<number, number> extended_euclid(number a, number b) {
number r0, r1, a0, a1, b0, b1;
r0 = a;
r1 = b;
a0 = 1;
a1 = 0;
b0 = 0;
b1 = 1;
while (r1 > 0) {
number q1 = r0 / r1;
number r2 = r0 % r1;
number a2 = a0 - q1 * a1;
number b2 = b0 - q1 * b1;
r0 = r1;
r1 = r2;
a0 = a1;
a1 = a2;
b0 = b1;
b1 = b2;
}
number c = r0;
a = a0; // x
b = b0; // y
return {a, c};
}
int main() {
int n;
cin >> n;
vector<ll> a(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<ll> memo1(n, 0);
vector<ll> memo2(n, 0);
memo1[0] = a[0];
memo2[n - 1] = a[n - 1];
for (int i = 1; i < n; i++) {
memo1[i] = extended_euclid(memo1[i - 1], a[i]).second;
memo2[n - 1 - i] = extended_euclid(memo2[n - i], a[n - 1 - i]).second;
}
ll result = max(memo1[n - 2], memo2[1]);
for (int i = 1; i < n - 1; i++) {
ll temp = extended_euclid(memo1[i - 1], memo2[i + 1]).second;
result = max(result, temp);
}
cout << result << endl;
} | [] | 874,216 | 874,217 | u432897824 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "../lib/dump.hpp"
#else
#define dump(...)
#define dumpv(...)
#endif
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 1e9 + 7;
const int INF = 1001001001;
const ll LINF = 1001002003004005006ll;
ll gcd(ll a, ll b) { return (a == 0) ? b : gcd(b % a, a); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("temp.1", "r", stdin);
int N;
cin >> N;
vector<ll> a(N);
for (int i = 0; i < N; i++) {
cin >> a[i];
}
vector<ll> al(N);
vector<ll> ar(N);
al[0] = a[0];
for (int i = 1; i < N; i++) {
al[i] = gcd(a[i], a[i - 1]);
}
ar[N - 1] = a[N - 1];
for (int i = N - 2; 0 <= i; i--) {
ar[i] = gcd(a[i], a[i + 1]);
}
dump(al, ar);
ll ans = 0;
for (int i = 0; i < N; i++) {
ll g;
if (i == 0)
g = ar[i + 1];
else if (i == N - 1)
g = al[i - 1];
else
g = gcd(al[i - 1], ar[i + 1]);
ans = max(ans, g);
dump(g, ans);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "../lib/dump.hpp"
#else
#define dump(...)
#define dumpv(...)
#endif
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 1e9 + 7;
const int INF = 1001001001;
const ll LINF = 1001002003004005006ll;
ll gcd(ll a, ll b) { return (a == 0) ? b : gcd(b % a, a); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("temp.1", "r", stdin);
int N;
cin >> N;
vector<ll> a(N);
for (int i = 0; i < N; i++) {
cin >> a[i];
}
vector<ll> al(N);
vector<ll> ar(N);
al[0] = a[0];
for (int i = 1; i < N; i++) {
al[i] = gcd(a[i], al[i - 1]);
}
ar[N - 1] = a[N - 1];
for (int i = N - 2; 0 <= i; i--) {
ar[i] = gcd(a[i], ar[i + 1]);
}
dump(al, ar);
ll ans = 0;
for (int i = 0; i < N; i++) {
ll g;
if (i == 0)
g = ar[i + 1];
else if (i == N - 1)
g = al[i - 1];
else
g = gcd(al[i - 1], ar[i + 1]);
ans = max(ans, g);
dump(g, ans);
}
cout << ans << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 874,225 | 874,226 | u147305315 | cpp |
p03061 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
#define ll long long
unsigned euclidean_gcd(unsigned a, unsigned b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
int main(void) {
ll int n;
cin >> n;
vector<ll> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
vector<ll> l(n + 1);
l[0] = 0, l[1] = A[0];
vector<ll> r(n + 1);
r[n] = 0, r[n - 1] = A[n - 1];
for (int i = 2; i <= n; i++) {
l[i] = euclidean_gcd(l[i - 1], A[i]);
}
for (int i = n - 2; i >= 0; i--) {
r[i] = euclidean_gcd(r[i + 1], A[i]);
}
ll ans = 0;
for (int i = 0; i < n; i++) {
ll tmp;
if (i == 0) {
tmp = r[i + 1];
} else if (i == n - 1) {
tmp = l[i];
} else {
tmp = euclidean_gcd(l[i], r[0 + 1]);
}
if (ans < tmp) {
ans = tmp;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
using namespace std;
#define ll long long
unsigned euclidean_gcd(unsigned a, unsigned b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
int main(void) {
ll int n;
cin >> n;
vector<ll> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
vector<ll> l(n + 1);
l[0] = 0, l[1] = A[0];
vector<ll> r(n + 1);
r[n] = 0, r[n - 1] = A[n - 1];
for (int i = 2; i <= n; i++) {
l[i] = euclidean_gcd(l[i - 1], A[i - 1]);
}
for (int i = n - 2; i >= 0; i--) {
r[i] = euclidean_gcd(r[i + 1], A[i]);
}
ll ans = 0;
for (int i = 0; i < n; i++) {
ll tmp;
if (i == 0) {
tmp = r[i + 1];
} else if (i == n - 1) {
tmp = l[i];
} else {
tmp = euclidean_gcd(l[i], r[i + 1]);
}
if (ans < tmp) {
ans = tmp;
}
}
cout << ans << endl;
return 0;
}
| [
"assignment.change",
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 874,227 | 874,228 | u030848580 | cpp |
p03061 | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
ll gcd(ll a, ll b) {
ll tmp;
ll r;
if (a == 0)
return b;
if (b == 0)
return a;
if (a < b) {
tmp = a;
a = b;
b = tmp;
}
/* ユークリッドの互除法 */
r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return b;
}
int main() {
ll n;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll m[n] = {};
ll r[n + 2];
ll l[n + 2];
l[0] = 0;
r[n + 1] = 0;
for (ll i = 0; i < n; i++)
l[i + 1] = gcd(l[i], a[i]);
for (ll i = n + 1; i > 0; i--)
r[i - 1] = gcd(r[i], a[i - 1]);
for (ll i = 0; i < n; i++)
m[i] = gcd(l[i], r[i + 1]);
cout << *std::max_element(m, m + n) << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
ll gcd(ll a, ll b) {
ll tmp;
ll r;
if (a == 0)
return b;
if (b == 0)
return a;
if (a < b) {
tmp = a;
a = b;
b = tmp;
}
/* ユークリッドの互除法 */
r = a % b;
while (r != 0) {
a = b;
b = r;
r = a % b;
}
return b;
}
int main() {
ll n;
cin >> n;
ll a[n];
for (ll i = 0; i < n; i++)
cin >> a[i];
ll m[n] = {};
ll r[n + 1];
ll l[n + 1];
l[0] = 0;
r[n] = 0;
for (ll i = 0; i < n; i++)
l[i + 1] = gcd(l[i], a[i]);
for (ll i = n; i > 0; i--)
r[i - 1] = gcd(r[i], a[i - 1]);
for (ll i = 0; i < n; i++)
m[i] = gcd(l[i], r[i + 1]);
cout << *std::max_element(m, m + n) << endl;
return 0;
} | [
"literal.number.change",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"control_flow.loop.for.initializer.change"
] | 874,235 | 874,236 | u988076584 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
const int inf = (1 << 30) - 1;
const ll infll = (1LL << 61) - 1;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
// 0 - indexed
template <typename Monoid> struct Segmenttree {
using F = function<Monoid(Monoid, Monoid)>;
const Monoid e;
const F f;
int sz;
vector<Monoid> seg;
// size, operator, unit
Segmenttree(int N, const F f, const Monoid e) : f(f), e(e) {
sz = 1;
while (sz < N)
sz *= 2;
seg.assign(2 * sz - 1, e);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k >= 0; k--) {
seg[k] = f(seg[2 * k + 1], seg[2 * k + 2]);
}
}
void update(int k, const Monoid &x) {
k += sz - 1;
seg[k] = x;
while (k > 0) {
k = (k - 1) / 2;
seg[k] = f(seg[k * 2 + 1], seg[k * 2 + 2]);
}
}
Monoid sub_query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return seg[k];
else {
Monoid vl = sub_query(a, b, k * 2 + 1, l, (l + r) / 2);
Monoid vr = sub_query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
}
// [l, r)
Monoid query(int l, int r) { return sub_query(l, r, 0, 0, sz); }
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
int main() {
int N;
cin >> N;
Segmenttree<int> seg(
N, [](int a, int b) { return gcd(a, b); }, 0);
for (int i = 0; i < N; i++) {
int a;
cin >> a;
seg.set(i, a);
}
seg.build();
int ans = 0;
for (int i = 0; i < N; i++) {
ans = max(gcd(seg.query(0, i), seg.query(i + 1, N)), ans);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
const int inf = (1 << 30) - 1;
const ll infll = (1LL << 61) - 1;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
// 0 - indexed
template <typename Monoid> struct Segmenttree {
using F = function<Monoid(Monoid, Monoid)>;
const Monoid e;
const F f;
int sz;
vector<Monoid> seg;
// size, operator, unit
Segmenttree(int N, const F f, const Monoid e) : f(f), e(e) {
sz = 1;
while (sz < N)
sz *= 2;
seg.assign(2 * sz - 1, e);
}
void set(int k, const Monoid &x) { seg[k + sz - 1] = x; }
void build() {
for (int k = sz - 2; k >= 0; k--) {
seg[k] = f(seg[2 * k + 1], seg[2 * k + 2]);
}
}
void update(int k, const Monoid &x) {
k += sz - 1;
seg[k] = x;
while (k > 0) {
k = (k - 1) / 2;
seg[k] = f(seg[k * 2 + 1], seg[k * 2 + 2]);
}
}
Monoid sub_query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return seg[k];
else {
Monoid vl = sub_query(a, b, k * 2 + 1, l, (l + r) / 2);
Monoid vr = sub_query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
}
// [l, r)
Monoid query(int l, int r) { return sub_query(l, r, 0, 0, sz); }
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
int main() {
int N;
cin >> N;
Segmenttree<int> seg(
N, [](int a, int b) { return gcd(a, b); }, 0);
for (int i = 0; i < N; i++) {
int a;
cin >> a;
seg.set(i, a);
}
seg.build();
int ans = 0;
for (int i = 0; i < N; i++) {
ans = max(gcd(seg.query(0, i), seg.query(i + 1, N)), ans);
}
cout << ans << endl;
} | [
"assignment.change",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 874,241 | 874,242 | u394482932 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
const int inf = (1 << 30) - 1;
const ll infll = (1LL << 61) - 1;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
// 0 - indexed
template <typename Monoid> struct Segmenttree {
using F = function<Monoid(Monoid, Monoid)>;
const Monoid e;
const F f;
int sz;
vector<Monoid> seg;
// size, operator, unit
Segmenttree(int N, const F f, const Monoid e) : f(f), e(e) {
sz = 1;
while (sz < N)
sz *= 2;
seg.assign(2 * sz - 1, e);
}
void set(int k, const Monoid &x) { seg[k + sz] = x; }
void build() {
for (int k = sz - 1; k >= 0; k--) {
seg[k] = f(seg[2 * k + 1], seg[2 * k + 2]);
}
}
void update(int k, const Monoid &x) {
k += sz - 1;
seg[k] = x;
while (k > 0) {
k = (k - 1) / 2;
seg[k] = f(seg[k * 2 + 1], seg[k * 2 + 2]);
}
}
Monoid sub_query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return seg[k];
else {
Monoid vl = sub_query(a, b, k * 2 + 1, l, (l + r) / 2);
Monoid vr = sub_query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
}
// [l, r)
Monoid query(int l, int r) { return sub_query(l, r, 0, 0, sz); }
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
int main() {
int N;
cin >> N;
Segmenttree<int> seg(
N, [](int a, int b) { return gcd(a, b); }, 0);
for (int i = 0; i < N; i++) {
int a;
cin >> a;
seg.set(i, a);
}
seg.build();
int ans = 0;
for (int i = 0; i < N; i++) {
ans = max(gcd(seg.query(0, i), seg.query(i + 1, N)), ans);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
const int inf = (1 << 30) - 1;
const ll infll = (1LL << 61) - 1;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
// 0 - indexed
template <typename Monoid> struct Segmenttree {
using F = function<Monoid(Monoid, Monoid)>;
const Monoid e;
const F f;
int sz;
vector<Monoid> seg;
// size, operator, unit
Segmenttree(int N, const F f, const Monoid e) : f(f), e(e) {
sz = 1;
while (sz < N)
sz *= 2;
seg.assign(2 * sz - 1, e);
}
void set(int k, const Monoid &x) { seg[k + sz - 1] = x; }
void build() {
for (int k = sz - 2; k >= 0; k--) {
seg[k] = f(seg[2 * k + 1], seg[2 * k + 2]);
}
}
void update(int k, const Monoid &x) {
k += sz - 1;
seg[k] = x;
while (k > 0) {
k = (k - 1) / 2;
seg[k] = f(seg[k * 2 + 1], seg[k * 2 + 2]);
}
}
Monoid sub_query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return seg[k];
else {
Monoid vl = sub_query(a, b, k * 2 + 1, l, (l + r) / 2);
Monoid vr = sub_query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
}
// [l, r)
Monoid query(int l, int r) { return sub_query(l, r, 0, 0, sz); }
Monoid operator[](const int &k) const { return seg[k + sz]; }
};
int main() {
int N;
cin >> N;
Segmenttree<int> seg(
N, [](int a, int b) { return gcd(a, b); }, 0);
for (int i = 0; i < N; i++) {
int a;
cin >> a;
seg.update(i, a);
}
seg.build();
int ans = 0;
for (int i = 0; i < N; i++) {
ans = max(gcd(seg.query(0, i), seg.query(i + 1, N)), ans);
}
cout << ans << endl;
} | [
"assignment.change",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"call.function.change"
] | 874,241 | 874,243 | u394482932 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
const ll inf = (1 << 30) - 1;
const ll infll = (1LL << 61) - 1;
ll gcd(ll a, ll b) { return (b ? gcd(b, a % b) : a); }
ll lcm(ll a, ll b) { return a / (gcd(a, b)) * b; }
template <typename T> void print(vector<T> vec) {
int n = vec.size();
for (int i = 0; i < n; i++) {
cout << vec[i] << (i == n - 1 ? "\n" : " ");
}
}
int N;
int main() {
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
vector<ll> left(N + 1), right(N + 1);
left[0] = A[0], right[N] = A[N - 1];
for (int i = 0; i < N; i++) {
left[i + 1] = gcd(A[i], left[i]);
right[N - i - 1] = gcd(A[N - 1 - i], right[N - i]);
}
ll ans = 0;
right[N] = A[0], left[0] = A[N - 1];
// print(left);
// print(right);
for (int i = 1; i < N; i++) {
ans = max(ans, gcd(left[i - 1], right[i]));
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
const ll inf = (1 << 30) - 1;
const ll infll = (1LL << 61) - 1;
ll gcd(ll a, ll b) { return (b ? gcd(b, a % b) : a); }
ll lcm(ll a, ll b) { return a / (gcd(a, b)) * b; }
template <typename T> void print(vector<T> vec) {
int n = vec.size();
for (int i = 0; i < n; i++) {
cout << vec[i] << (i == n - 1 ? "\n" : " ");
}
}
int N;
int main() {
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
vector<ll> left(N + 1), right(N + 1);
left[0] = A[0], right[N] = A[N - 1];
for (int i = 0; i < N; i++) {
left[i + 1] = gcd(A[i], left[i]);
right[N - i - 1] = gcd(A[N - 1 - i], right[N - i]);
}
ll ans = left[N - 1];
right[N] = A[0], left[0] = A[N - 1];
// print(left); //A[0]~A[i-1]
// print(right); //A[i]~A[N-1]
for (int i = 1; i < N; i++) {
ans = max(ans, gcd(left[i - 1], right[i]));
}
cout << ans << endl;
} | [
"identifier.replace.add",
"literal.replace.remove"
] | 874,244 | 874,245 | u394482932 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef vector<int> VI;
const ll MOD = 1000000007;
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
int main() {
int n;
cin >> n;
VI a(n);
REP(i, n)
cin >> a[i];
VI sb(n);
sb[0] = a[0];
REP(i, n - 1)
sb[i + 1] = __gcd(sb[i], a[i + 1]);
VI se(n);
se[n - 1] = a[n - 1];
for (int i = n - 1; i > 0; i--)
se[i - 1] = __gcd(se[i], a[i - 1]);
int ans;
for (int i = 0; i < n; i++) {
if (i == 0)
ans = se[i];
else if (i == n - 1)
ans = max(ans, sb[i]);
else
ans = max(ans, __gcd(sb[i - 1], se[i + 1]));
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef vector<int> VI;
const ll MOD = 1000000007;
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
int main() {
int n;
cin >> n;
VI a(n);
REP(i, n)
cin >> a[i];
VI sb(n);
sb[0] = a[0];
REP(i, n - 1)
sb[i + 1] = __gcd(sb[i], a[i + 1]);
VI se(n);
se[n - 1] = a[n - 1];
for (int i = n - 1; i > 0; i--)
se[i - 1] = __gcd(se[i], a[i - 1]);
int ans;
for (int i = 0; i < n; i++) {
if (i == 0)
ans = se[i + 1];
else if (i == n - 1)
ans = max(ans, sb[i - 1]);
else
ans = max(ans, __gcd(sb[i - 1], se[i + 1]));
}
cout << ans;
} | [
"assignment.change"
] | 874,251 | 874,252 | u408650734 | cpp |
p03061 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int main() {
int n;
cin >> n;
vector<int> a(n + 2);
for (int i = 1; i <= n; ++i)
cin >> a[i];
vector<int> l(n + 2, 0), r(n + 2, 0);
for (int i = 1; i <= n; ++i)
l[i] = gcd(l[i - 1], a[i]);
for (int i = n; i > 0; --i)
r[i] = gcd(r[i + 1], a[i]);
int ans = 0;
for (int i = 1; i < n; ++i)
ans = max(ans, gcd(l[i - 1], r[i + 1]));
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int main() {
int n;
cin >> n;
vector<int> a(n + 2);
for (int i = 1; i <= n; ++i)
cin >> a[i];
vector<int> l(n + 2, 0), r(n + 2, 0);
for (int i = 1; i <= n; ++i)
l[i] = gcd(l[i - 1], a[i]);
for (int i = n; i > 0; --i)
r[i] = gcd(r[i + 1], a[i]);
int ans = 0;
for (int i = 1; i <= n; ++i)
ans = max(ans, gcd(l[i - 1], r[i + 1]));
cout << ans << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 874,258 | 874,259 | u848359007 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int gf[MAXN], ge[MAXN], n, a[MAXN];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i], gf[i] = __gcd(a[i], gf[i - 1]);
for (int i = n; i >= 0; i--)
ge[i] = __gcd(ge[i], ge[i + 1]);
int ans = 0;
for (int i = 1; i <= n; i++)
ans = max(__gcd(gf[i - 1], ge[i + 1]), ans);
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int gf[MAXN], ge[MAXN], n, a[MAXN];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i], gf[i] = __gcd(a[i], gf[i - 1]);
for (int i = n; i >= 0; i--)
ge[i] = __gcd(a[i], ge[i + 1]);
int ans = 0;
for (int i = 1; i <= n; i++)
ans = max(__gcd(gf[i - 1], ge[i + 1]), ans);
cout << ans;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change"
] | 874,260 | 874,261 | u494617175 | cpp |
p03061 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
static const int Max = 100000;
long long gcd(long long a, long long b) {
long long tmp;
while (b != 0) {
tmp = b;
b = a % b;
a = tmp;
}
return a;
}
int main() {
int n;
cin >> n;
vector<long long> v;
long long l[Max] = {0}, r[Max] = {0};
long long t, ans = 0;
for (int i = 0; i < n; i++) {
cin >> t;
v.push_back(t);
}
sort(v.begin(), v.end());
for (int i = 1; i < n; i++) {
if (i == 1) {
l[i] = v[i - 1];
r[n - 1 - i] = v[n - i];
} else {
l[i] = gcd(l[i - 1], v[i - 1]);
r[n - 1 - i] = gcd(r[n - i], v[i - 1]);
}
}
for (int i = 0; i < n; i++) {
if (i == 0)
ans = r[i];
else if (i == n - 1) {
if (r[i] > ans)
ans = r[i];
} else {
if (ans < gcd(l[i], r[i])) {
ans = gcd(l[i], r[i]);
}
}
}
printf("%lld\n", ans);
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
static const int Max = 100000;
long long gcd(long long a, long long b) {
long long tmp;
while (b != 0) {
tmp = b;
b = a % b;
a = tmp;
}
return a;
}
int main() {
int n;
cin >> n;
vector<long long> v;
long long l[Max] = {0}, r[Max] = {0};
long long t, ans = 0;
for (int i = 0; i < n; i++) {
cin >> t;
v.push_back(t);
}
sort(v.begin(), v.end());
for (int i = 1; i < n; i++) {
if (i == 1) {
l[i] = v[i - 1];
r[n - 1 - i] = v[n - i];
} else {
l[i] = gcd(l[i - 1], v[i - 1]);
r[n - 1 - i] = gcd(r[n - i], v[n - i]);
}
}
for (int i = 0; i < n; i++) {
if (i == 0)
ans = r[i];
else if (i == n - 1) {
if (l[i] > ans)
ans = l[i];
} else {
if (ans < gcd(l[i], r[i])) {
ans = gcd(l[i], r[i]);
}
}
}
printf("%lld\n", ans);
return 0;
} | [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 874,264 | 874,263 | u839397805 | cpp |
p03061 | #include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n, x) for (int i = n; i < x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define REV(x) reverse(x.begin(), x.end())
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define setp(x) setprecision(x)
using LL = long long;
using ULL = unsigned long long;
LL gcd(LL a, LL b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
LL n;
cin >> n;
vector<LL> a(n + 1);
rep(i, 1, n + 1) cin >> a[i];
vector<LL> l(n + 2), r(n + 2);
l[0] = 0;
rep(i, 0, n) l[i + 1] = gcd(l[i], a[i]);
r[n + 1] = 0;
for (int i = n; i > 0; i--)
r[i] = gcd(r[i + 1], a[i]);
LL ans = 0;
rep(i, 0, n) {
LL m = gcd(l[i], r[i + 1]);
ans = max(ans, m);
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <set>
#include <stdlib.h>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n, x) for (int i = n; i < x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define REV(x) reverse(x.begin(), x.end())
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define setp(x) setprecision(x)
using LL = long long;
using ULL = unsigned long long;
LL gcd(LL a, LL b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
LL n;
cin >> n;
vector<LL> a(n + 1);
rep(i, 1, n + 1) cin >> a[i];
vector<LL> l(n + 2), r(n + 2);
l[0] = 0;
rep(i, 0, n) l[i + 1] = gcd(l[i], a[i]);
r[n + 1] = 0;
for (int i = n; i > 0; i--)
r[i] = gcd(r[i + 1], a[i]);
LL ans = 0;
rep(i, 0, n + 1) {
LL m = gcd(l[i], r[i + 1]);
ans = max(ans, m);
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 874,271 | 874,272 | u526854325 | cpp |
p03061 | #define _CRT_SECURE_NO_WARNINGS
#define MATH_PI 3.14159265358979323846264338327950288419716939
#define DIVIDER9 1000000007
#define lli long long int
#include <fstream>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <string.h>
using namespace std;
#ifdef _WIN32
#pragma warning(disable : 4101)
signed wait() {
char wait_dummy[256];
scanf("%c", &wait_dummy);
return 0;
}
template <typename... Args> void dout(const char *format, Args const &...args) {
printf(format, args...);
}
#define MAX_CHARBUF 65536
#define DATAFILE "data.dat"
class csLocalInput {
int FileOpen();
public:
FILE *fp;
csLocalInput();
};
csLocalInput::csLocalInput() { FileOpen(); }
int csLocalInput::FileOpen() {
fp = fopen(DATAFILE, "rt");
return 1;
}
csLocalInput local_in;
#define DEBUG 1
#else
inline signed wait() { return 0; }
inline void dout(const char *arg, ...) {}
#endif
template <typename T> inline void SWAP(T &a, T &b) {
T t = a;
a = b;
b = t;
}
inline void CSWAP(char *&a, char *&b) {
char *t = a;
a = b;
b = t;
}
int _ret;
#define CLIP(ptr, min, max) \
{ \
if ((min) <= (max)) { \
if (ptr < (min)) { \
ptr = (min); \
} \
if (ptr > (max)) { \
ptr = (max); \
} \
} \
}
#define Sin(deg) sin((deg)*MATH_PI / 180.0)
#define Cos(deg) cos((deg)*MATH_PI / 180.0)
#define Tan(deg) tan((deg)*MATH_PI / 180.0)
#define Rad(deg) ((deg)*MATH_PI / 180.0)
#define rep(param, num) for (int param = 0; param < num; ++param)
#define fi(num) for (int i = 0; i < num; ++i)
#define fj(num) for (int j = 0; j < num; ++j)
#define fk(num) for (int k = 0; k < num; ++k)
#define fl(num) for (int l = 0; l < num; ++l)
#define fn(num) for (int n = 0; n < num; ++n)
#define ffr(param, num) for (int param = num - 1; param >= 0; --param)
#define fir(num) for (int i = num - 1; i >= 0; --i)
#define fjr(num) for (int j = num - 1; j >= 0; --j)
#define fkr(num) for (int k = num - 1; k >= 0; --k)
#define flr(num) for (int l = num - 1; l >= 0; --l)
#define fnr(num) for (int n = num - 1; n >= 0; --n)
#define gi(p) \
int p; \
Gi(p)
#define gi2(p1, p2) \
int p1, p2; \
Gi2(p1, p2)
#define gi3(p1, p2, p3) \
int p1, p2, p3; \
Gi3(p1, p2, p3)
#define gi4(p1, p2, p3, p4) \
int p1, p2, p3, p4; \
Gi4(p1, p2, p3, p4)
#define glli(p) \
lli p; \
Glli(p)
#define glli2(p1, p2) \
lli p1, p2; \
Glli2(p1, p2)
#define glli3(p1, p2, p3) \
lli p1, p2, p3; \
Glli3(p1, p2, p3)
#define glli4(p1, p2, p3, p4) \
lli p1, p2, p3, p4; \
Glli4(p1, p2, p3, p4)
#define gf(p) \
double p; \
Gf(p);
#define gf2(p1, p2) \
double p1, p2; \
Gf2(p1, p2);
#define gf3(p1, p2, p3) \
double p1, p2, p3; \
Gf3(p1, p2, p3);
#define gf4(p1, p2, p3, p4) \
double p1, p2, p3, p4; \
Gf4(p1, p2, p3, p4)
#define Gi(p) _ret = Scanf("%d", p)
#define Gi2(p1, p2) _ret = Scanf2("%d %d", p1, p2)
#define Gi3(p1, p2, p3) _ret = Scanf3("%d %d %d", p1, p2, p3)
#define Gi4(p1, p2, p3, p4) _ret = Scanf4("%d %d %d %d", p1, p2, p3, p4)
#define Glli(p) _ret = Scanf("%lld", p)
#define Glli2(p1, p2) _ret = Scanf2("%lld %lld", p1, p2)
#define Glli3(p1, p2, p3) _ret = Scanf3("%lld %lld %lld", p1, p2, p3)
#define Glli4(p1, p2, p3, p4) \
_ret = Scanf4("%lld %lld %lld %lld", p1, p2, p3, p4)
#define Gf(p) _ret = Scanf("%f", p)
#define Gf2(p1, p2) _ret = Scanf2("%f %f", p1, p2)
#define Gf3(p1, p2, p3) _ret = Scanf3("%f %f %f", p1, p2, p3)
#define Gf4(p1, p2, p3, p4) _ret = Scanf4("%f %f %f %f", p1, p2, p3, p4)
#ifdef DEBUG
#define Gc(buf) fscanf(local_in.fp, "%s", buf)
#define Scanf(expr, p) fscanf(local_in.fp, expr, &p)
#define Scanf2(expr, p1, p2) fscanf(local_in.fp, expr, &p1, &p2)
#define Scanf3(expr, p1, p2, p3) fscanf(local_in.fp, expr, &p1, &p2, &p3)
#define Scanf4(expr, p1, p2, p3, p4) \
fscanf(local_in.fp, expr, &p1, &p2, &p3, &p4)
#else
#define Gc(buf) Scanf("%s", buf)
#define Scanf(expr, p) scanf(expr, &p)
#define Scanf2(expr, p1, p2) scanf(expr, &p1, &p2)
#define Scanf3(expr, p1, p2, p3) scanf(expr, &p1, &p2, &p3)
#define Scanf4(expr, p1, p2, p3, p4) scanf(expr, &p1, &p2, &p3, &p4)
#endif
#define ans(p) cout << p << endl;
#define ans_end(p) \
{ \
cout << p << endl; \
return wait(); \
}
void CombSort(int N, int *ar, int order_ascending) {
if (N <= 1)
return;
int h = int(N / 1.3);
int flag;
int i;
while (true) {
flag = 0;
for (i = 0; i + h < N; ++i) {
if ((order_ascending && ar[i] > ar[i + h]) ||
(!order_ascending && ar[i] < ar[i + h])) {
swap<int>(ar[i], ar[i + h]);
flag = 1;
}
}
if (h == 1 && !flag)
break;
if (h == 9 || h == 10)
h = 11;
if (h > 1)
h = int(h / 1.3);
}
}
void CombSort_ll(int N, lli *ar, int order_ascending) {
if (N <= 1)
return;
int h = int(N / 1.3);
int flag;
int i;
while (true) {
flag = 0;
for (i = 0; i + h < N; ++i) {
if ((order_ascending && ar[i] > ar[i + h]) ||
(!order_ascending && ar[i] < ar[i + h])) {
swap<lli>(ar[i], ar[i + h]);
flag = 1;
}
}
if (h == 1 && !flag)
break;
if (h == 9 || h == 10)
h = 11;
if (h > 1)
h = int(h / 1.3);
}
}
int EuclideanAlgorithm(int N, int *ar) {
fn(N - 1) {
while (true) {
if (ar[n] == 0 || ar[n + 1] == 0) {
if (ar[n] < ar[n + 1])
ar[n] = ar[n + 1];
ar[n + 1] = ar[n];
break;
}
if (ar[n] % ar[n + 1] == 0 || ar[n + 1] % ar[n] == 0) {
ar[n + 1] = ar[n] < ar[n + 1] ? ar[n] : ar[n + 1];
break;
}
if (ar[n] > ar[n + 1]) {
ar[n] %= ar[n + 1];
} else {
ar[n + 1] %= ar[n];
}
}
}
return ar[N - 1];
}
int EuclideanAlgorithmPreserved(int N, int *ar) {
int a, b;
a = ar[0];
fn(N - 1) {
b = ar[n + 1];
while (true) {
if (a == 0 || b == 0) {
if (a < b)
a = b;
b = a;
break;
}
if (a % b == 0 || b % a == 0) {
b = a < b ? a : b;
break;
}
if (a > b) {
a %= b;
} else {
b %= a;
}
}
a = b;
}
return a;
}
template <typename T> void CombSort(int N, T *ar, int order_ascending) {
if (N <= 1)
return;
int i, flag;
int h = int(N / 1.3);
while (true) {
flag = 0;
for (i = 0; i + h < N; ++i) {
if (order_ascending && ar[i].SortValue > ar[i + h].SortValue ||
!order_ascending && ar[i].SortValue < ar[i + h].SortValue) {
SWAP<T>(ar[i], ar[i + h]);
flag = 1;
}
}
if (h > 1) {
h = int(h / 1.3);
if (h == 9 || h == 10)
h = 11;
} else {
if (!flag)
break;
}
}
}
#include <algorithm>
#include <vector>
struct UnionFind {
vector<int> par;
UnionFind(int N) : par(N) {
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry)
return;
par[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
void Replace(char *c, int len, char before, char after) {
fi(len) {
if (c[i] == before)
c[i] = after;
}
}
void Replace(char *c, char before, char after) {
int len = strlen(c);
Replace(c, len, before, after);
}
class csNode {
public:
csNode() {}
};
class csStack {
public:
csStack() { num = 0; }
void alloc(int size) { param = new int[size]; }
void sort(int order = 1) {
if (num > 1)
CombSort(num, param, order);
}
int num;
int *param;
void push(int p) { param[num++] = p; }
};
class csPosition {
public:
csPosition() { x = y = 0; }
int x, y;
};
typedef class csPosition POS;
template <typename T> class csPos {
public:
csPos() { x = y = 0; }
T x, y;
};
char s[200010];
int p[100010];
signed main() {
gi(n);
fi(n) { Gi(p[i]); }
int gcd, mx_gcd = 1;
int ar[2];
int L[100010] = {0}, R[100010] = {0};
fi(n - 1) {
ar[0] = L[i];
ar[1] = p[i];
L[i + 1] = EuclideanAlgorithm(2, ar);
}
fi(n - 1) {
ar[0] = R[n - 1];
ar[1] = p[n - i - 1];
R[n - i - 1] = EuclideanAlgorithm(2, ar);
}
fi(n) {
ar[0] = L[i];
ar[1] = R[i + 1];
gcd = EuclideanAlgorithm(2, ar);
mx_gcd = max(gcd, mx_gcd);
}
ans(mx_gcd);
return wait();
}
| #define _CRT_SECURE_NO_WARNINGS
#define MATH_PI 3.14159265358979323846264338327950288419716939
#define DIVIDER9 1000000007
#define lli long long int
#include <fstream>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <string.h>
using namespace std;
#ifdef _WIN32
#pragma warning(disable : 4101)
signed wait() {
char wait_dummy[256];
scanf("%c", &wait_dummy);
return 0;
}
template <typename... Args> void dout(const char *format, Args const &...args) {
printf(format, args...);
}
#define MAX_CHARBUF 65536
#define DATAFILE "data.dat"
class csLocalInput {
int FileOpen();
public:
FILE *fp;
csLocalInput();
};
csLocalInput::csLocalInput() { FileOpen(); }
int csLocalInput::FileOpen() {
fp = fopen(DATAFILE, "rt");
return 1;
}
csLocalInput local_in;
#define DEBUG 1
#else
inline signed wait() { return 0; }
inline void dout(const char *arg, ...) {}
#endif
template <typename T> inline void SWAP(T &a, T &b) {
T t = a;
a = b;
b = t;
}
inline void CSWAP(char *&a, char *&b) {
char *t = a;
a = b;
b = t;
}
int _ret;
#define CLIP(ptr, min, max) \
{ \
if ((min) <= (max)) { \
if (ptr < (min)) { \
ptr = (min); \
} \
if (ptr > (max)) { \
ptr = (max); \
} \
} \
}
#define Sin(deg) sin((deg)*MATH_PI / 180.0)
#define Cos(deg) cos((deg)*MATH_PI / 180.0)
#define Tan(deg) tan((deg)*MATH_PI / 180.0)
#define Rad(deg) ((deg)*MATH_PI / 180.0)
#define rep(param, num) for (int param = 0; param < num; ++param)
#define fi(num) for (int i = 0; i < num; ++i)
#define fj(num) for (int j = 0; j < num; ++j)
#define fk(num) for (int k = 0; k < num; ++k)
#define fl(num) for (int l = 0; l < num; ++l)
#define fn(num) for (int n = 0; n < num; ++n)
#define ffr(param, num) for (int param = num - 1; param >= 0; --param)
#define fir(num) for (int i = num - 1; i >= 0; --i)
#define fjr(num) for (int j = num - 1; j >= 0; --j)
#define fkr(num) for (int k = num - 1; k >= 0; --k)
#define flr(num) for (int l = num - 1; l >= 0; --l)
#define fnr(num) for (int n = num - 1; n >= 0; --n)
#define gi(p) \
int p; \
Gi(p)
#define gi2(p1, p2) \
int p1, p2; \
Gi2(p1, p2)
#define gi3(p1, p2, p3) \
int p1, p2, p3; \
Gi3(p1, p2, p3)
#define gi4(p1, p2, p3, p4) \
int p1, p2, p3, p4; \
Gi4(p1, p2, p3, p4)
#define glli(p) \
lli p; \
Glli(p)
#define glli2(p1, p2) \
lli p1, p2; \
Glli2(p1, p2)
#define glli3(p1, p2, p3) \
lli p1, p2, p3; \
Glli3(p1, p2, p3)
#define glli4(p1, p2, p3, p4) \
lli p1, p2, p3, p4; \
Glli4(p1, p2, p3, p4)
#define gf(p) \
double p; \
Gf(p);
#define gf2(p1, p2) \
double p1, p2; \
Gf2(p1, p2);
#define gf3(p1, p2, p3) \
double p1, p2, p3; \
Gf3(p1, p2, p3);
#define gf4(p1, p2, p3, p4) \
double p1, p2, p3, p4; \
Gf4(p1, p2, p3, p4)
#define Gi(p) _ret = Scanf("%d", p)
#define Gi2(p1, p2) _ret = Scanf2("%d %d", p1, p2)
#define Gi3(p1, p2, p3) _ret = Scanf3("%d %d %d", p1, p2, p3)
#define Gi4(p1, p2, p3, p4) _ret = Scanf4("%d %d %d %d", p1, p2, p3, p4)
#define Glli(p) _ret = Scanf("%lld", p)
#define Glli2(p1, p2) _ret = Scanf2("%lld %lld", p1, p2)
#define Glli3(p1, p2, p3) _ret = Scanf3("%lld %lld %lld", p1, p2, p3)
#define Glli4(p1, p2, p3, p4) \
_ret = Scanf4("%lld %lld %lld %lld", p1, p2, p3, p4)
#define Gf(p) _ret = Scanf("%f", p)
#define Gf2(p1, p2) _ret = Scanf2("%f %f", p1, p2)
#define Gf3(p1, p2, p3) _ret = Scanf3("%f %f %f", p1, p2, p3)
#define Gf4(p1, p2, p3, p4) _ret = Scanf4("%f %f %f %f", p1, p2, p3, p4)
#ifdef DEBUG
#define Gc(buf) fscanf(local_in.fp, "%s", buf)
#define Scanf(expr, p) fscanf(local_in.fp, expr, &p)
#define Scanf2(expr, p1, p2) fscanf(local_in.fp, expr, &p1, &p2)
#define Scanf3(expr, p1, p2, p3) fscanf(local_in.fp, expr, &p1, &p2, &p3)
#define Scanf4(expr, p1, p2, p3, p4) \
fscanf(local_in.fp, expr, &p1, &p2, &p3, &p4)
#else
#define Gc(buf) Scanf("%s", buf)
#define Scanf(expr, p) scanf(expr, &p)
#define Scanf2(expr, p1, p2) scanf(expr, &p1, &p2)
#define Scanf3(expr, p1, p2, p3) scanf(expr, &p1, &p2, &p3)
#define Scanf4(expr, p1, p2, p3, p4) scanf(expr, &p1, &p2, &p3, &p4)
#endif
#define ans(p) cout << p << endl;
#define ans_end(p) \
{ \
cout << p << endl; \
return wait(); \
}
void CombSort(int N, int *ar, int order_ascending) {
if (N <= 1)
return;
int h = int(N / 1.3);
int flag;
int i;
while (true) {
flag = 0;
for (i = 0; i + h < N; ++i) {
if ((order_ascending && ar[i] > ar[i + h]) ||
(!order_ascending && ar[i] < ar[i + h])) {
swap<int>(ar[i], ar[i + h]);
flag = 1;
}
}
if (h == 1 && !flag)
break;
if (h == 9 || h == 10)
h = 11;
if (h > 1)
h = int(h / 1.3);
}
}
void CombSort_ll(int N, lli *ar, int order_ascending) {
if (N <= 1)
return;
int h = int(N / 1.3);
int flag;
int i;
while (true) {
flag = 0;
for (i = 0; i + h < N; ++i) {
if ((order_ascending && ar[i] > ar[i + h]) ||
(!order_ascending && ar[i] < ar[i + h])) {
swap<lli>(ar[i], ar[i + h]);
flag = 1;
}
}
if (h == 1 && !flag)
break;
if (h == 9 || h == 10)
h = 11;
if (h > 1)
h = int(h / 1.3);
}
}
int EuclideanAlgorithm(int N, int *ar) {
fn(N - 1) {
while (true) {
if (ar[n] == 0 || ar[n + 1] == 0) {
if (ar[n] < ar[n + 1])
ar[n] = ar[n + 1];
ar[n + 1] = ar[n];
break;
}
if (ar[n] % ar[n + 1] == 0 || ar[n + 1] % ar[n] == 0) {
ar[n + 1] = ar[n] < ar[n + 1] ? ar[n] : ar[n + 1];
break;
}
if (ar[n] > ar[n + 1]) {
ar[n] %= ar[n + 1];
} else {
ar[n + 1] %= ar[n];
}
}
}
return ar[N - 1];
}
int EuclideanAlgorithmPreserved(int N, int *ar) {
int a, b;
a = ar[0];
fn(N - 1) {
b = ar[n + 1];
while (true) {
if (a == 0 || b == 0) {
if (a < b)
a = b;
b = a;
break;
}
if (a % b == 0 || b % a == 0) {
b = a < b ? a : b;
break;
}
if (a > b) {
a %= b;
} else {
b %= a;
}
}
a = b;
}
return a;
}
template <typename T> void CombSort(int N, T *ar, int order_ascending) {
if (N <= 1)
return;
int i, flag;
int h = int(N / 1.3);
while (true) {
flag = 0;
for (i = 0; i + h < N; ++i) {
if (order_ascending && ar[i].SortValue > ar[i + h].SortValue ||
!order_ascending && ar[i].SortValue < ar[i + h].SortValue) {
SWAP<T>(ar[i], ar[i + h]);
flag = 1;
}
}
if (h > 1) {
h = int(h / 1.3);
if (h == 9 || h == 10)
h = 11;
} else {
if (!flag)
break;
}
}
}
#include <algorithm>
#include <vector>
struct UnionFind {
vector<int> par;
UnionFind(int N) : par(N) {
for (int i = 0; i < N; i++)
par[i] = i;
}
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry)
return;
par[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
void Replace(char *c, int len, char before, char after) {
fi(len) {
if (c[i] == before)
c[i] = after;
}
}
void Replace(char *c, char before, char after) {
int len = strlen(c);
Replace(c, len, before, after);
}
class csNode {
public:
csNode() {}
};
class csStack {
public:
csStack() { num = 0; }
void alloc(int size) { param = new int[size]; }
void sort(int order = 1) {
if (num > 1)
CombSort(num, param, order);
}
int num;
int *param;
void push(int p) { param[num++] = p; }
};
class csPosition {
public:
csPosition() { x = y = 0; }
int x, y;
};
typedef class csPosition POS;
template <typename T> class csPos {
public:
csPos() { x = y = 0; }
T x, y;
};
char s[200010];
int p[100010];
signed main() {
gi(n);
fi(n) { Gi(p[i]); }
int gcd, mx_gcd = 1;
int ar[2];
int L[100010] = {0}, R[100010] = {0};
fi(n - 1) {
ar[0] = L[i];
ar[1] = p[i];
L[i + 1] = EuclideanAlgorithm(2, ar);
}
fi(n - 1) {
ar[0] = R[n - i];
ar[1] = p[n - i - 1];
R[n - i - 1] = EuclideanAlgorithm(2, ar);
}
fi(n) {
ar[0] = L[i];
ar[1] = R[i + 1];
gcd = EuclideanAlgorithm(2, ar);
mx_gcd = max(gcd, mx_gcd);
}
ans(mx_gcd);
return wait();
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 874,296 | 874,297 | u575781793 | cpp |
p03061 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int main() {
int n;
cin >> n;
vector<int> a(n, 0);
REP(i, n) { cin >> a[i]; }
vector<int> l(n, 0), r(n, 0);
for (int i = 0; i < n - 1; i++) {
/* code */
l[n + 1] = gcd(l[i], a[i]);
}
for (int i = n - 1; i > 0; --i) {
r[i - 1] = gcd(r[i], a[i]);
}
int ans = 1;
REP(i, n) { ans = max(gcd(r[i], l[i]), ans); }
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int main() {
int n;
cin >> n;
vector<int> a(n, 0);
REP(i, n) { cin >> a[i]; }
vector<int> l(n, 0), r(n, 0);
for (int i = 0; i < n - 1; i++) {
/* code */
l[i + 1] = gcd(l[i], a[i]);
}
for (int i = n - 1; i >= 1; --i) {
r[i - 1] = gcd(r[i], a[i]);
}
int ans = 1;
REP(i, n) { ans = max(gcd(r[i], l[i]), ans); }
cout << ans << endl;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change"
] | 874,300 | 874,301 | u376859266 | cpp |
p03061 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int main() {
int N;
vector<int> A(N, 0);
vector<int> l(N, 0), r(N, 0);
for (auto &&a : A) {
cin >> a;
}
for (int i = 0; i < N - 1; ++i) {
l[i + 1] = gcd(l[i], A[i]);
}
for (int i = N - 1; i >= 1; --i) {
r[i - 1] = gcd(r[i], A[i]);
}
int ans = 1;
for (int i = 0; i < N; ++i) {
ans = max(ans, gcd(l[i], r[i]));
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int main() {
int N;
cin >> N;
vector<int> A(N, 0);
vector<int> l(N, 0), r(N, 0);
for (auto &&a : A) {
cin >> a;
}
for (int i = 0; i < N - 1; ++i) {
l[i + 1] = gcd(l[i], A[i]);
}
for (int i = N - 1; i >= 1; --i) {
r[i - 1] = gcd(r[i], A[i]);
}
int ans = 1;
for (int i = 0; i < N; ++i) {
ans = max(ans, gcd(l[i], r[i]));
}
cout << ans << endl;
return 0;
} | [] | 874,302 | 874,303 | u894555185 | cpp |
p03061 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int main() {
int N;
vector<int> A(N, 0);
vector<int> l(N, 0), r(N, 0);
for (auto &&a : A) {
cin >> a;
}
for (int i = 0; i < N - 1; ++i) {
l[i + 1] = gcd(l[i], A[i]);
}
for (int i = N - 1; i >= 0; --i) {
r[i - 1] = gcd(r[i], A[i]);
}
int ans = 1;
for (int i = 0; i < N; ++i) {
ans = max(ans, gcd(l[i], r[i]));
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
int main() {
int N;
cin >> N;
vector<int> A(N, 0);
vector<int> l(N, 0), r(N, 0);
for (auto &&a : A) {
cin >> a;
}
for (int i = 0; i < N - 1; ++i) {
l[i + 1] = gcd(l[i], A[i]);
}
for (int i = N - 1; i >= 1; --i) {
r[i - 1] = gcd(r[i], A[i]);
}
int ans = 1;
for (int i = 0; i < N; ++i) {
ans = max(ans, gcd(l[i], r[i]));
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 874,304 | 874,303 | u894555185 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int main() {
int N;
cin >> N;
vector<int> a(N);
for (int i = 0; i < N; ++i)
cin >> a[i];
// 累積 GCD (左と右両方)
vector<int> left(N + 1, 0), right(N + 1, 0);
for (int i = 0; i < N; ++i)
left[i + 1] = GCD(left[i], a[i]);
for (int i = N - 1; i >= 0; --i)
right[i] = GCD(right[i + 1], a[i]);
// 集計
int res = 0;
for (int i = 0; i < N; ++i) {
// 左側
int l = left[i];
// 右側
int r = right[i + 1];
// 更新
max(res, GCD(l, r));
}
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int main() {
int N;
cin >> N;
vector<int> a(N);
for (int i = 0; i < N; ++i)
cin >> a[i];
// 累積 GCD (左と右両方)
vector<int> left(N + 1, 0), right(N + 1, 0);
for (int i = 0; i < N; ++i)
left[i + 1] = GCD(left[i], a[i]);
for (int i = N - 1; i >= 0; --i)
right[i] = GCD(right[i + 1], a[i]);
// 集計
int res = 0;
for (int i = 0; i < N; ++i) {
// 左側
int l = left[i];
// 右側
int r = right[i + 1];
// 更新
res = max(res, GCD(l, r));
}
cout << res << endl;
} | [
"assignment.change"
] | 874,310 | 874,311 | u800100718 | cpp |
p03061 | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = int64_t;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define REP(i, b) FOR(i, 0, b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(), x.end()
using pi = pair<int, int>;
using vi = vector<int>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
REP(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("\n"); }
void print(ll x, int suc = 1) {
printf("%" PRId64, x);
if (suc == 1)
printEoln();
if (suc == 2)
printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char *readCharArray() {
static char buf[3341000];
static int bufUsed = 0;
char *ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
template <class T> T Sq(const T &t) { return t * t; }
const int mod = 1e9 + 7;
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
signed main() {
int n;
cin >> n;
vi a;
REP(i, n) { a.PB(read()); }
vi l(n), r(n);
REP(i, n - 1) { l[i + 1] = gcd(l[i], a[i]); }
for (int i = n - 1; i <= 1; i--)
r[i - 1] = gcd(r[i], a[i]);
int ans = 1;
REP(i, n) { chmax(ans, gcd(l[i], r[i])); }
print(ans);
}
| #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = int64_t;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define REP(i, b) FOR(i, 0, b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(), x.end()
using pi = pair<int, int>;
using vi = vector<int>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
REP(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("\n"); }
void print(ll x, int suc = 1) {
printf("%" PRId64, x);
if (suc == 1)
printEoln();
if (suc == 2)
printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char *readCharArray() {
static char buf[3341000];
static int bufUsed = 0;
char *ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
template <class T> T Sq(const T &t) { return t * t; }
const int mod = 1e9 + 7;
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
signed main() {
int n;
cin >> n;
vi a;
REP(i, n) { a.PB(read()); }
vi l(n), r(n);
REP(i, n - 1) { l[i + 1] = gcd(l[i], a[i]); }
for (int i = n - 1; i >= 1; i--)
r[i - 1] = gcd(r[i], a[i]);
int ans = 1;
REP(i, n) { chmax(ans, gcd(l[i], r[i])); }
print(ans);
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 874,314 | 874,315 | u700484101 | cpp |
p03061 | #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = int64_t;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define REP(i, b) FOR(i, 0, b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(), x.end()
using pi = pair<int, int>;
using vi = vector<int>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
REP(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("\n"); }
void print(ll x, int suc = 1) {
printf("%" PRId64, x);
if (suc == 1)
printEoln();
if (suc == 2)
printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char *readCharArray() {
static char buf[3341000];
static int bufUsed = 0;
char *ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
template <class T> T Sq(const T &t) { return t * t; }
const int mod = 1e9 + 7;
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
signed main() {
int n;
cin >> n;
vi a(n + 1);
for (int i = 1; i <= n; i++)
a[i] = read();
vi foward(n + 1);
foward[1] = a[1];
for (int i = 2; i < n; i++)
foward[i] = gcd(i, foward[i - 1]);
vi backward(n + 1);
backward[n] = a[n];
for (int i = n - 1; i > 1; i--)
backward[i] = gcd(i, backward[i + 1]);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (i == 1)
chmax(ans, backward[2]);
else if (i == n)
chmax(ans, foward[n - 1]);
else
chmax(ans, gcd(foward[i - 1], backward[i + 1]));
}
print(ans);
}
| #include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = int64_t;
#define int ll
#define FOR(i, a, b) for (int i = int(a); i < int(b); i++)
#define REP(i, b) FOR(i, 0, b)
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) x.begin(), x.end()
using pi = pair<int, int>;
using vi = vector<int>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
REP(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
ll read() {
ll i;
scanf("%" SCNd64, &i);
return i;
}
void printSpace() { printf(" "); }
void printEoln() { printf("\n"); }
void print(ll x, int suc = 1) {
printf("%" PRId64, x);
if (suc == 1)
printEoln();
if (suc == 2)
printSpace();
}
string readString() {
static char buf[3341000];
scanf("%s", buf);
return string(buf);
}
char *readCharArray() {
static char buf[3341000];
static int bufUsed = 0;
char *ret = buf + bufUsed;
scanf("%s", ret);
bufUsed += strlen(ret) + 1;
return ret;
}
template <class T, class U> void chmax(T &a, U b) {
if (a < b)
a = b;
}
template <class T, class U> void chmin(T &a, U b) {
if (b < a)
a = b;
}
template <class T> T Sq(const T &t) { return t * t; }
const int mod = 1e9 + 7;
int gcd(int x, int y) {
if (y == 0)
return x;
return gcd(y, x % y);
}
signed main() {
int n;
cin >> n;
vi a(n + 1);
for (int i = 1; i <= n; i++)
a[i] = read();
vi foward(n + 1);
foward[1] = a[1];
for (int i = 2; i < n; i++)
foward[i] = gcd(a[i], foward[i - 1]);
vi backward(n + 1);
backward[n] = a[n];
for (int i = n - 1; i > 1; i--)
backward[i] = gcd(a[i], backward[i + 1]);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (i == 1)
chmax(ans, backward[2]);
else if (i == n)
chmax(ans, foward[n - 1]);
else
chmax(ans, gcd(foward[i - 1], backward[i + 1]));
}
print(ans);
}
| [
"call.arguments.change"
] | 874,316 | 874,317 | u700484101 | cpp |
p03061 | #include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long int
#define MAX 1000000007
using namespace std;
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main(void) {
int n;
cin >> n;
ll a[n], l[n - 1], r[n - 1];
rep(i, n) cin >> a[i];
l[0] = a[0];
r[n - 2] = a[n - 1];
rep(i, n - 2) {
l[i + 1] = gcd(l[i], a[i + 1]);
// cout<<"l["<<i<<"]="<<l[i+1]<<endl;
r[n - 3 - i] = gcd(r[n - 2 - i], a[n - 2 - i]);
// cout<<"r["<<n-3-i<<"]="<<r[n-3-i]<<endl;
}
ll ans = 0;
if (r[0] > ans)
ans = r[0];
if (l[n - 2] > ans)
ans = l[n - 2];
rep(i, n - 3) {
ll tmp = gcd(l[i], r[i + 1]);
// printf("gcd(%lld,%lld)=%lld\n", l[i],r[n-2-i],tmp);
if (ans < tmp)
ans = tmp;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long int
#define MAX 1000000007
using namespace std;
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main(void) {
int n;
cin >> n;
ll a[n], l[n - 1], r[n - 1];
rep(i, n) cin >> a[i];
l[0] = a[0];
r[n - 2] = a[n - 1];
rep(i, n - 2) {
l[i + 1] = gcd(l[i], a[i + 1]);
// cout<<"l["<<i+1<<"]="<<l[i+1]<<endl;
r[n - 3 - i] = gcd(r[n - 2 - i], a[n - 2 - i]);
// cout<<"r["<<n-3-i<<"]="<<r[n-3-i]<<endl;
}
ll ans = 0;
if (r[0] > ans)
ans = r[0];
if (l[n - 2] > ans)
ans = l[n - 2];
rep(i, n - 2) {
ll tmp = gcd(l[i], r[i + 1]);
// printf("gcd(%lld,%lld)=%lld\n", l[i],r[n-2-i],tmp);
if (ans < tmp)
ans = tmp;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 874,318 | 874,319 | u582848517 | cpp |
p03061 | #include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long int
#define MAX 1000000007
using namespace std;
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main(void) {
int n;
cin >> n;
ll a[n], l[n - 1], r[n - 1];
rep(i, n) cin >> a[i];
l[0] = a[0];
r[n - 2] = a[n - 1];
rep(i, n - 2) {
l[i + 1] = gcd(l[i], a[i + 1]);
// cout<<"l["<<i<<"]="<<l[i+1]<<endl;
r[n - 3 - i] = gcd(r[n - 2 - i], a[n - 2 - i]);
// cout<<"r["<<n-3-i<<"]="<<r[n-3-i]<<endl;
}
ll ans = 0;
if (r[0] > ans)
ans = r[0];
if (l[n - 2] > ans)
ans = l[n - 2];
rep(i, n - 2) {
ll tmp = gcd(l[i], r[n - 2 - i]);
// printf("gcd(%lld,%lld)=%lld\n", l[i],r[n-2-i],tmp);
if (ans < tmp)
ans = tmp;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long int
#define MAX 1000000007
using namespace std;
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main(void) {
int n;
cin >> n;
ll a[n], l[n - 1], r[n - 1];
rep(i, n) cin >> a[i];
l[0] = a[0];
r[n - 2] = a[n - 1];
rep(i, n - 2) {
l[i + 1] = gcd(l[i], a[i + 1]);
// cout<<"l["<<i+1<<"]="<<l[i+1]<<endl;
r[n - 3 - i] = gcd(r[n - 2 - i], a[n - 2 - i]);
// cout<<"r["<<n-3-i<<"]="<<r[n-3-i]<<endl;
}
ll ans = 0;
if (r[0] > ans)
ans = r[0];
if (l[n - 2] > ans)
ans = l[n - 2];
rep(i, n - 2) {
ll tmp = gcd(l[i], r[i + 1]);
// printf("gcd(%lld,%lld)=%lld\n", l[i],r[n-2-i],tmp);
if (ans < tmp)
ans = tmp;
}
cout << ans << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 874,320 | 874,319 | u582848517 | cpp |
p03061 | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
int N;
ll A[100000], g[100000], gr[100000];
cin >> N;
for (int i(0); i < N; i++)
cin >> A[i];
g[0] = A[0];
gr[N - 1] = A[N - 1];
for (int i(1); i < N; i++) {
g[i] = gcd(A[i], g[i - 1]);
}
for (int i(N - 1); i >= 0; i--) {
gr[i] = gcd(A[i], g[i + 1]);
}
ll maxi(0), gcdi;
for (int i(1); i < N - 1; i++) {
gcdi = gcd(g[i - 1], gr[i + 1]);
maxi = max(maxi, gcdi);
}
maxi = max(g[N], max(gr[0], maxi));
cout << maxi;
} | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
int N;
ll A[100000], g[100000], gr[100000];
cin >> N;
for (int i(0); i < N; i++)
cin >> A[i];
g[0] = A[0];
gr[N - 1] = A[N - 1];
for (int i(1); i < N; i++) {
g[i] = gcd(A[i], g[i - 1]);
}
for (int i(N - 1); i >= 0; i--) {
gr[i] = gcd(A[i], gr[i + 1]);
}
ll maxi(0), gcdi;
for (int i(1); i < N - 1; i++) {
gcdi = gcd(g[i - 1], gr[i + 1]);
maxi = max(maxi, gcdi);
}
maxi = max(g[N - 2], max(gr[1], maxi));
cout << maxi;
}
| [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"assignment.change",
"literal.number.change",
"variable_access.subscript.index.change"
] | 874,321 | 874,322 | u991846372 | cpp |
p03061 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int gcd(int x, int y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(x % y, y);
}
int main() {
int N;
cin >> N;
int A[N];
for (int i = 0; i < N; i++)
cin >> A[i];
vector<int> L(N, 0), R(N, 0);
L[0] = A[0];
R[0] = A[N - 1];
for (int i = 1; i < N - 1; i++) {
L[i + 1] = gcd(L[i], A[i + 1]);
}
for (int i = 0; i < N - 1; i++) {
R[i + 1] = gcd(R[i], A[(N - 2) - i]);
}
int ans = 0;
for (int erase_e = 0; erase_e < N; erase_e++) {
int t;
if (erase_e == 0)
t = R[(N - 1) - erase_e - 1];
else if (erase_e == N - 1)
t = L[erase_e - 1];
else
t = gcd(L[erase_e - 1], R[(N - 1) - erase_e - 1]);
if (ans < t)
ans = t;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int gcd(int x, int y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(x % y, y);
}
int main() {
int N;
cin >> N;
int A[N];
for (int i = 0; i < N; i++)
cin >> A[i];
vector<int> L(N, 0), R(N, 0);
L[0] = A[0];
R[0] = A[N - 1];
for (int i = 0; i < N - 1; i++) {
L[i + 1] = gcd(L[i], A[i + 1]);
}
for (int i = 0; i < N - 1; i++) {
R[i + 1] = gcd(R[i], A[(N - 2) - i]);
}
int ans = 0;
for (int erase_e = 0; erase_e < N; erase_e++) {
int t;
if (erase_e == 0)
t = R[(N - 1) - erase_e - 1];
else if (erase_e == N - 1)
t = L[erase_e - 1];
else
t = gcd(L[erase_e - 1], R[(N - 1) - erase_e - 1]);
if (ans < t)
ans = t;
}
cout << ans << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 874,328 | 874,329 | u547844563 | cpp |
p03056 | /*
ЗАПУСКАЕМ
░ГУСЯ░▄▀▀▀▄░РАБОТЯГУ░░
▄███▀░◐░░░▌░░░░░░░
░░░░▌░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▌░░░░░▐▄▄░░░░░
░░░░▌░░░░▄▀▒▒▀▀▀▀▄
░░░▐░░░░▐▒▒▒▒▒▒▒▒▀▀▄
░░░▐░░░░▐▄▒▒▒▒▒▒▒▒▒▒▀▄
░░░░▀▄░░░░▀▄▒▒▒▒▒▒▒▒▒▒▀▄
░░░░░░▀▄▄▄▄▄█▄▄▄▄▄▄▄▄▄▄▄▀▄
░░░░░░░░░░░▌▌░▌▌░░░░░
░░░░░░░░░░░▌▌░▌▌░░░░░
░░░░░░░░░▄▄▌▌▄▌▌░░░░░
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
template <typename T1, typename T2> inline void chkmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chkmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
#define files(FILENAME) \
read(FILENAME); \
write(FILENAME)
#define read(FILENAME) freopen((FILENAME + ".in").c_str(), "r", stdin)
#define write(FILENAME) freopen((FILENAME + ".out").c_str(), "w", stdout)
#define all(c) (c).begin(), (c).end()
#define sz(c) (int)(c).size()
#define left left228
#define right right228
#define y1 y1228
#define mp make_pair
#define pb push_back
#define y2 y2228
#define rank rank228
const string FILENAME = "input";
const int MAXN = 190;
int h, w;
string s[MAXN];
int d[MAXN][MAXN];
int kek[MAXN][MAXN], kek1[MAXN][MAXN];
int getsum(const int &i, const int &j, const int &i1, const int &j1) {
return d[i1][j1] - d[i1][j - 1] - d[i - 1][j1] + d[i - 1][j - 1];
}
bool check(const int &i, const int &j, const int &i1, const int &j1) {
int s = getsum(i, j, i1, j1);
return s == 0 || s == (j1 - j + 1) * (i1 - i + 1);
}
short dp[2][22][MAXN][MAXN][MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// read(FILENAME);
cin >> h >> w;
for (int i = 0; i < h; i++) {
cin >> s[i];
for (int j = 0; j < w; j++) {
d[i + 1][j + 1] = s[i][j] == '#';
}
}
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
d[i][j] += d[i - 1][j] + d[i][j - 1] - d[i - 1][j - 1];
}
}
for (int ans = 0; ans < 20; ans++) {
for (int k = 1; k <= h; k++) {
for (int i = 1; i <= w; i++) {
int uk = i;
for (int j = i; j <= w; j++) {
if (ans == 0) {
for (int g = k; g <= h; g++) {
if (check(k, i, g, j)) {
chkmax(dp[1][ans][i][j][k], g);
}
}
}
}
}
}
for (int k = 1; k <= w; k++) {
for (int i = 1; i <= h; i++) {
int uk = i;
for (int j = i; j <= h; j++) {
if (ans == 0) {
for (int g = k; g <= w; g++) {
if (check(i, k, j, g)) {
chkmax(dp[0][ans][i][j][k], g);
}
}
}
}
}
}
for (int i = 1; i <= h; i++) {
for (int j = h - 1; j >= i; j--) {
for (int k = 1; k <= w; k++) {
chkmax(dp[0][ans][i][j][k], dp[0][ans][i][j + 1][k]);
}
}
}
for (int i = 1; i <= w; i++) {
for (int j = w - 1; j >= i; j--) {
for (int k = 1; k <= h; k++) {
chkmax(dp[1][ans][i][j][k], dp[1][ans][i][j + 1][k]);
}
}
}
for (int i = 1; i <= h; i++) {
for (int j = i; j <= h; j++) {
for (int k = 1; k <= w; k++) {
if (dp[0][ans][i][j][k] == 0) {
continue;
}
chkmax(dp[0][ans + 1][i][j][k], dp[0][ans][i][j][k]);
chkmax(dp[0][ans + 1][i][j][k],
dp[0][ans][i][j][dp[0][ans][i][j][k] + 1]);
int x = dp[0][ans][i][j][dp[0][ans][i][j][k] + 1];
// k, x, i, j
chkmax(dp[1][ans + 1][k][x][i], j);
}
}
}
for (int i = 1; i <= w; i++) {
for (int j = i; j <= w; j++) {
for (int k = 1; k <= h; k++) {
if (dp[1][ans][i][j][k] == 0) {
continue;
}
chkmax(dp[1][ans + 1][i][j][k], dp[1][ans][i][j][k]);
chkmax(dp[1][ans + 1][i][j][k],
dp[1][ans][i][j][dp[1][ans][i][j][k] + 1]);
int x = dp[1][ans][i][j][dp[1][ans][i][j][k] + 1];
// k, x, i, j
chkmax(dp[0][ans + 1][k][x][i], j);
}
}
}
}
for (int ans = 0; ans < 20; ans++) {
if (dp[0][ans][1][h][1] >= w || dp[1][ans][1][w][1] >= h) {
cout << ans << '\n';
break;
}
}
return 0;
} | /*
ЗАПУСКАЕМ
░ГУСЯ░▄▀▀▀▄░РАБОТЯГУ░░
▄███▀░◐░░░▌░░░░░░░
░░░░▌░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▌░░░░░▐▄▄░░░░░
░░░░▌░░░░▄▀▒▒▀▀▀▀▄
░░░▐░░░░▐▒▒▒▒▒▒▒▒▀▀▄
░░░▐░░░░▐▄▒▒▒▒▒▒▒▒▒▒▀▄
░░░░▀▄░░░░▀▄▒▒▒▒▒▒▒▒▒▒▀▄
░░░░░░▀▄▄▄▄▄█▄▄▄▄▄▄▄▄▄▄▄▀▄
░░░░░░░░░░░▌▌░▌▌░░░░░
░░░░░░░░░░░▌▌░▌▌░░░░░
░░░░░░░░░▄▄▌▌▄▌▌░░░░░
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
template <typename T1, typename T2> inline void chkmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chkmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
#define files(FILENAME) \
read(FILENAME); \
write(FILENAME)
#define read(FILENAME) freopen((FILENAME + ".in").c_str(), "r", stdin)
#define write(FILENAME) freopen((FILENAME + ".out").c_str(), "w", stdout)
#define all(c) (c).begin(), (c).end()
#define sz(c) (int)(c).size()
#define left left228
#define right right228
#define y1 y1228
#define mp make_pair
#define pb push_back
#define y2 y2228
#define rank rank228
const string FILENAME = "input";
const int MAXN = 190;
int h, w;
string s[MAXN];
int d[MAXN][MAXN];
int kek[MAXN][MAXN], kek1[MAXN][MAXN];
int getsum(const int &i, const int &j, const int &i1, const int &j1) {
return d[i1][j1] - d[i1][j - 1] - d[i - 1][j1] + d[i - 1][j - 1];
}
bool check(const int &i, const int &j, const int &i1, const int &j1) {
int s = getsum(i, j, i1, j1);
return s == 0 || s == (j1 - j + 1) * (i1 - i + 1);
}
unsigned char dp[2][22][MAXN][MAXN][MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// read(FILENAME);
cin >> h >> w;
for (int i = 0; i < h; i++) {
cin >> s[i];
for (int j = 0; j < w; j++) {
d[i + 1][j + 1] = s[i][j] == '#';
}
}
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
d[i][j] += d[i - 1][j] + d[i][j - 1] - d[i - 1][j - 1];
}
}
for (int ans = 0; ans < 20; ans++) {
for (int k = 1; k <= h; k++) {
for (int i = 1; i <= w; i++) {
int uk = i;
for (int j = i; j <= w; j++) {
if (ans == 0) {
for (int g = k; g <= h; g++) {
if (check(k, i, g, j)) {
chkmax(dp[1][ans][i][j][k], g);
}
}
}
}
}
}
for (int k = 1; k <= w; k++) {
for (int i = 1; i <= h; i++) {
int uk = i;
for (int j = i; j <= h; j++) {
if (ans == 0) {
for (int g = k; g <= w; g++) {
if (check(i, k, j, g)) {
chkmax(dp[0][ans][i][j][k], g);
}
}
}
}
}
}
for (int i = 1; i <= h; i++) {
for (int j = h - 1; j >= i; j--) {
for (int k = 1; k <= w; k++) {
chkmax(dp[0][ans][i][j][k], dp[0][ans][i][j + 1][k]);
}
}
}
for (int i = 1; i <= w; i++) {
for (int j = w - 1; j >= i; j--) {
for (int k = 1; k <= h; k++) {
chkmax(dp[1][ans][i][j][k], dp[1][ans][i][j + 1][k]);
}
}
}
for (int i = 1; i <= h; i++) {
for (int j = i; j <= h; j++) {
for (int k = 1; k <= w; k++) {
if (dp[0][ans][i][j][k] == 0) {
continue;
}
chkmax(dp[0][ans + 1][i][j][k], dp[0][ans][i][j][k]);
chkmax(dp[0][ans + 1][i][j][k],
dp[0][ans][i][j][dp[0][ans][i][j][k] + 1]);
int x = dp[0][ans][i][j][dp[0][ans][i][j][k] + 1];
// k, x, i, j
chkmax(dp[1][ans + 1][k][x][i], j);
}
}
}
for (int i = 1; i <= w; i++) {
for (int j = i; j <= w; j++) {
for (int k = 1; k <= h; k++) {
if (dp[1][ans][i][j][k] == 0) {
continue;
}
chkmax(dp[1][ans + 1][i][j][k], dp[1][ans][i][j][k]);
chkmax(dp[1][ans + 1][i][j][k],
dp[1][ans][i][j][dp[1][ans][i][j][k] + 1]);
int x = dp[1][ans][i][j][dp[1][ans][i][j][k] + 1];
// k, x, i, j
chkmax(dp[0][ans + 1][k][x][i], j);
}
}
}
}
for (int ans = 0; ans < 20; ans++) {
if (dp[0][ans][1][h][1] >= w || dp[1][ans][1][w][1] >= h) {
cout << ans << '\n';
break;
}
}
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 874,334 | 874,335 | u139147798 | cpp |
p03056 | #include <bits/stdc++.h>
// iostream is too mainstream
#include <cstdio>
// bitch please
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <time.h>
#include <vector>
#define dibs reserve
#define OVER9000 1234567890
#define ALL_THE(CAKE, LIE) \
for (auto LIE = CAKE.begin(); LIE != CAKE.end(); LIE++)
#define tisic 47
#define soclose 1e-8
#define chocolate win
// so much chocolate
#define patkan 9
#define ff first
#define ss second
#define abs(x) (((x) < 0) ? -(x) : (x))
#define uint unsigned int
#define dbl long double
#define pi 3.14159265358979323846
using namespace std;
// mylittledoge
using cat = long long;
#ifdef DONLINE_JUDGE
// palindromic tree is better than splay tree!
#define lld I64d
#endif
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int H, W;
cin >> H >> W;
vector<string> A(H);
for (int i = 0; i < H; i++)
cin >> A[i];
constexpr int MX = 16;
vector<vector<vector<uint8_t>>> max_h[MX + 1];
vector<vector<vector<uint8_t>>> max_w[MX + 1];
for (int v = 0; v <= MX; v++) {
max_h[v].resize(W + 1, vector<vector<uint8_t>>(W + 1));
max_w[v].resize(H + 1, vector<vector<uint8_t>>(H + 1));
for (int i = 0; i < H; i++)
for (int j = i + 1; j <= H; j++) {
max_w[v][i][j].resize(W + 1, 0);
for (int k = 0; k <= W; k++)
max_w[v][i][j][k] = k;
}
for (int i = 0; i < W; i++)
for (int j = i + 1; j <= W; j++) {
max_h[v][i][j].resize(H + 1, 0);
for (int k = 0; k <= H; k++)
max_h[v][i][j][k] = k;
}
}
for (int i = 0; i < H; i++)
for (int j = W - 1; j >= 0; j--) {
if (j < W - 1 && A[i][j] != A[i][j + 1])
max_w[0][i][i + 1][j] = j + 1;
else
max_w[0][i][i + 1][j] = max_w[0][i][i + 1][j + 1];
}
for (int i = 0; i < W; i++)
for (int j = H - 1; j >= 0; j--) {
if (j < H - 1 && A[j][i] != A[j][i + 1])
max_h[0][i][i + 1][j] = j + 1;
else
max_h[0][i][i + 1][j] = max_h[0][i][i + 1][j + 1];
}
for (int d = 2; d <= H; d++)
for (int i = 0; i <= H - d; i++)
for (int j = 0; j < W; j++)
if (A[i][j] == A[i + 1][j])
max_w[0][i][i + d][j] =
min(max_w[0][i + 1][i + d][j], max_w[0][i][i + 1][j]);
for (int d = 2; d <= W; d++)
for (int i = 0; i <= W - d; i++)
for (int j = 0; j < H; j++)
if (A[j][i] == A[j][i + 1])
max_h[0][i][i + d][j] =
min(max_h[0][i + 1][i + d][j], max_h[0][i][i + 1][j]);
for (int v = 1; v <= MX; v++) {
for (int i = 0; i < H; i++)
for (int j = 0; j < W; j++)
for (int k = j + 1; k <= W; k++) {
int h1 = max_h[v - 1][j][k][i];
if (h1 == i)
break;
int h2 = max_h[v - 1][j][k][h1];
max_w[v][i][h2][j] = max(max_w[v][i][h2][j], (uint8_t)k);
}
for (int i = 0; i < H; i++) {
for (int k = H - 1; k > i; k--)
for (int j = 0; j < W; j++)
max_w[v][i][k][j] = max(max_w[v][i][k][j], max_w[v][i][k + 1][j]);
for (int j = i + 1; j <= H; j++)
for (int l = 0; l < W; l++) {
int w2 = max_w[v - 1][i][j][l];
max_w[v][i][j][l] = max(max_w[v][i][j][l], max_w[v - 1][i][j][w2]);
}
}
for (int i = 0; i < W; i++)
for (int j = 0; j < H; j++)
for (int k = j + 1; k <= H; k++) {
int w1 = max_w[v - 1][j][k][i];
if (w1 == i)
break;
int w2 = max_w[v - 1][j][k][w1];
max_h[v][i][w2][j] = max(max_h[v][i][w2][j], (uint8_t)k);
}
for (int i = 0; i < W; i++) {
for (int k = W - 1; k > i; k--)
for (int j = 0; j < H; j++)
max_h[v][i][k][j] = max(max_h[v][i][k][j], max_h[v][i][k + 1][j]);
for (int j = i + 1; j <= W; j++)
for (int l = 0; l < H; l++) {
int h2 = max_h[v - 1][i][j][l];
max_h[v][i][j][l] = max(max_h[v][i][j][l], max_h[v - 1][i][j][h2]);
}
}
}
for (int i = 0; i <= MX; i++)
if (max_w[i][0][H][0] == W) {
cout << i << "\n";
return 0;
}
return 0;
}
// look at my code
// my code is amazing
| #include <bits/stdc++.h>
// iostream is too mainstream
#include <cstdio>
// bitch please
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <time.h>
#include <vector>
#define dibs reserve
#define OVER9000 1234567890
#define ALL_THE(CAKE, LIE) \
for (auto LIE = CAKE.begin(); LIE != CAKE.end(); LIE++)
#define tisic 47
#define soclose 1e-8
#define chocolate win
// so much chocolate
#define patkan 9
#define ff first
#define ss second
#define abs(x) (((x) < 0) ? -(x) : (x))
#define uint unsigned int
#define dbl long double
#define pi 3.14159265358979323846
using namespace std;
// mylittledoge
using cat = long long;
#ifdef DONLINE_JUDGE
// palindromic tree is better than splay tree!
#define lld I64d
#endif
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int H, W;
cin >> H >> W;
vector<string> A(H);
for (int i = 0; i < H; i++)
cin >> A[i];
constexpr int MX = 16;
vector<vector<vector<uint8_t>>> max_h[MX + 1];
vector<vector<vector<uint8_t>>> max_w[MX + 1];
for (int v = 0; v <= MX; v++) {
max_h[v].resize(W + 1, vector<vector<uint8_t>>(W + 1));
max_w[v].resize(H + 1, vector<vector<uint8_t>>(H + 1));
for (int i = 0; i < H; i++)
for (int j = i + 1; j <= H; j++) {
max_w[v][i][j].resize(W + 1, 0);
for (int k = 0; k <= W; k++)
max_w[v][i][j][k] = k;
}
for (int i = 0; i < W; i++)
for (int j = i + 1; j <= W; j++) {
max_h[v][i][j].resize(H + 1, 0);
for (int k = 0; k <= H; k++)
max_h[v][i][j][k] = k;
}
}
for (int i = 0; i < H; i++)
for (int j = W - 1; j >= 0; j--) {
if (j < W - 1 && A[i][j] != A[i][j + 1])
max_w[0][i][i + 1][j] = j + 1;
else
max_w[0][i][i + 1][j] = max_w[0][i][i + 1][j + 1];
}
for (int i = 0; i < W; i++)
for (int j = H - 1; j >= 0; j--) {
if (j < H - 1 && A[j][i] != A[j + 1][i])
max_h[0][i][i + 1][j] = j + 1;
else
max_h[0][i][i + 1][j] = max_h[0][i][i + 1][j + 1];
}
for (int d = 2; d <= H; d++)
for (int i = 0; i <= H - d; i++)
for (int j = 0; j < W; j++)
if (A[i][j] == A[i + 1][j])
max_w[0][i][i + d][j] =
min(max_w[0][i + 1][i + d][j], max_w[0][i][i + 1][j]);
for (int d = 2; d <= W; d++)
for (int i = 0; i <= W - d; i++)
for (int j = 0; j < H; j++)
if (A[j][i] == A[j][i + 1])
max_h[0][i][i + d][j] =
min(max_h[0][i + 1][i + d][j], max_h[0][i][i + 1][j]);
for (int v = 1; v <= MX; v++) {
for (int i = 0; i < H; i++)
for (int j = 0; j < W; j++)
for (int k = j + 1; k <= W; k++) {
int h1 = max_h[v - 1][j][k][i];
if (h1 == i)
break;
int h2 = max_h[v - 1][j][k][h1];
max_w[v][i][h2][j] = max(max_w[v][i][h2][j], (uint8_t)k);
}
for (int i = 0; i < H; i++) {
for (int k = H - 1; k > i; k--)
for (int j = 0; j < W; j++)
max_w[v][i][k][j] = max(max_w[v][i][k][j], max_w[v][i][k + 1][j]);
for (int j = i + 1; j <= H; j++)
for (int l = 0; l < W; l++) {
int w2 = max_w[v - 1][i][j][l];
max_w[v][i][j][l] = max(max_w[v][i][j][l], max_w[v - 1][i][j][w2]);
}
}
for (int i = 0; i < W; i++)
for (int j = 0; j < H; j++)
for (int k = j + 1; k <= H; k++) {
int w1 = max_w[v - 1][j][k][i];
if (w1 == i)
break;
int w2 = max_w[v - 1][j][k][w1];
max_h[v][i][w2][j] = max(max_h[v][i][w2][j], (uint8_t)k);
}
for (int i = 0; i < W; i++) {
for (int k = W - 1; k > i; k--)
for (int j = 0; j < H; j++)
max_h[v][i][k][j] = max(max_h[v][i][k][j], max_h[v][i][k + 1][j]);
for (int j = i + 1; j <= W; j++)
for (int l = 0; l < H; l++) {
int h2 = max_h[v - 1][i][j][l];
max_h[v][i][j][l] = max(max_h[v][i][j][l], max_h[v - 1][i][j][h2]);
}
}
}
for (int i = 0; i <= MX; i++)
if (max_w[i][0][H][0] == W) {
cout << i << "\n";
return 0;
}
return 0;
}
// look at my code
// my code is amazing
| [
"control_flow.loop.for.condition.change",
"control_flow.branch.if.condition.change"
] | 874,340 | 874,341 | u642082255 | cpp |
p03056 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define MP make_pair
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int MOD = 998244353;
int n, m;
char dat[190][190];
int dpr[190][190][190], dpd[190][190][190];
int cur[190];
int main() {
scanf("%d%d", &n, &m);
rep(i, n) scanf("%s", dat[i]);
for (int i = n - 1; i >= 0; i--) {
int cur = m;
for (int j = m - 1; j >= 0; j--) {
if (j == m - 1 || dat[i][j] != dat[i][j + 1])
cur = j;
dpd[i][j][i] = cur;
for (int k = i + 1; k < n; k++)
if (dat[k][j] == dat[k - 1][j])
dpd[i][j][k] = min(dpd[i][j][k - 1], dpd[k][j][k]);
else
dpd[i][j][k] = j - 1;
}
}
for (int j = m - 1; j >= 0; j--) {
int cur = n;
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1 || dat[i][j] != dat[i + 1][j])
cur = i;
dpr[i][j][j] = cur;
for (int k = j + 1; k < m; k++)
if (dat[i][k] == dat[i][k - 1])
dpr[i][j][k] = min(dpr[i][j][k - 1], dpr[i][k][k]);
else
dpr[i][j][k] = i - 1;
}
}
rep(i, 20) {
if (dpd[0][0][n - 1] == m - 1) {
printf("%d\n", i);
return 0;
}
rep(i, n) rep(j, m) for (int k = i; k < n; k++) dpd[i][j][k] =
dpd[i][min(dpd[i][j][k] + 1, m - 1)][k];
rep(i, n) rep(j, m) for (int k = j; k < m; k++) dpr[i][j][k] =
dpr[min(dpr[i][j][k] + 1, n - 1)][j][k];
rep(i, n) rep(j, m) {
for (int k = j; k < m; k++)
dpd[i][j][dpr[i][j][k]] = max(dpd[i][j][dpr[i][j][k]], k);
for (int k = n - 2; k >= i; k--)
dpd[i][j][k] = max(dpd[i][j][k], dpd[i][j][k + 1]);
for (int k = i; k < n; k++)
dpr[i][j][dpd[i][j][k]] = max(dpr[i][j][dpd[i][j][k]], k);
for (int k = m - 2; k >= i; k--)
dpr[i][j][k] = max(dpr[i][j][k], dpr[i][j][k + 1]);
}
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define MP make_pair
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int MOD = 998244353;
int n, m;
char dat[190][190];
int dpr[190][190][190], dpd[190][190][190];
int cur[190];
int main() {
scanf("%d%d", &n, &m);
rep(i, n) scanf("%s", dat[i]);
for (int i = n - 1; i >= 0; i--) {
int cur = m;
for (int j = m - 1; j >= 0; j--) {
if (j == m - 1 || dat[i][j] != dat[i][j + 1])
cur = j;
dpd[i][j][i] = cur;
for (int k = i + 1; k < n; k++)
if (dat[k][j] == dat[k - 1][j])
dpd[i][j][k] = min(dpd[i][j][k - 1], dpd[k][j][k]);
else
dpd[i][j][k] = j - 1;
}
}
for (int j = m - 1; j >= 0; j--) {
int cur = n;
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1 || dat[i][j] != dat[i + 1][j])
cur = i;
dpr[i][j][j] = cur;
for (int k = j + 1; k < m; k++)
if (dat[i][k] == dat[i][k - 1])
dpr[i][j][k] = min(dpr[i][j][k - 1], dpr[i][k][k]);
else
dpr[i][j][k] = i - 1;
}
}
rep(i, 20) {
if (dpd[0][0][n - 1] == m - 1) {
printf("%d\n", i);
return 0;
}
rep(i, n) rep(j, m) for (int k = i; k < n; k++) dpd[i][j][k] =
dpd[i][min(dpd[i][j][k] + 1, m - 1)][k];
rep(i, n) rep(j, m) for (int k = j; k < m; k++) dpr[i][j][k] =
dpr[min(dpr[i][j][k] + 1, n - 1)][j][k];
rep(i, n) rep(j, m) {
for (int k = j; k < m; k++)
dpd[i][j][dpr[i][j][k]] = max(dpd[i][j][dpr[i][j][k]], k);
for (int k = n - 2; k >= i; k--)
dpd[i][j][k] = max(dpd[i][j][k], dpd[i][j][k + 1]);
for (int k = i; k < n; k++)
dpr[i][j][dpd[i][j][k]] = max(dpr[i][j][dpd[i][j][k]], k);
for (int k = m - 2; k >= j; k--)
dpr[i][j][k] = max(dpr[i][j][k], dpr[i][j][k + 1]);
}
}
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 874,348 | 874,349 | u103391254 | cpp |
p03056 | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
// gp_hash_table<int, int> mapka;
using namespace std;
#define PB push_back
#define MP make_pair
#define LL long long
#define int LL
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define RE(i, n) FOR(i, 1, n)
#define REP(i, n) FOR(i, 0, (int)(n)-1)
#define R(i, n) REP(i, n)
#define VI vector<int>
#define PII pair<int, int>
#define LD long double
#define FI first
#define SE second
#define st FI
#define nd SE
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
template <class C> void mini(C &a4, C b4) { a4 = min(a4, b4); }
template <class C> void maxi(C &a4, C b4) { a4 = max(a4, b4); }
template <class TH> void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA> void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',')
cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V)
os << vv << ",";
return os << "]";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.st << "," << P.nd << ")";
}
#ifdef LOCAL
#define debug(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define debug(...) (__VA_ARGS__)
#define cerr \
if (0) \
cout
#endif
const int MAX = 186;
int n, m;
int sp[MAX][MAX];
int32_t poz[2][MAX][MAX][MAX];
int32_t poz_podz[2][MAX][MAX][MAX];
int32_t pion[2][MAX][MAX][MAX];
int32_t pion_podz[2][MAX][MAX][MAX];
int32_t res[2][MAX][MAX][MAX];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
cerr << fixed << setprecision(6);
cin >> n >> m;
R(i, n) {
string s;
cin >> s;
R(j, m) {
sp[i + 1][j + 1] = sp[i + 1][j] + sp[i][j + 1] - sp[i][j] + (s[j] == '.');
}
}
R(_, n + 1) {
int i = _ & 1;
R(ii, m + 1)
for (int j = _ - 1; j >= 0; j--) for (int jj = ii - 1; jj >= 0; jj--) {
int pom = sp[_][ii] - sp[_][jj] - sp[j][ii] + sp[j][jj];
if (pom == 0 || pom == (_ - j) * (ii - jj)) {
// debug("pusty", _, ii, j, jj);
poz[i][ii][j][jj] = 0;
poz_podz[i][ii][j][jj] = j;
pion[i][ii][j][jj] = 0;
pion_podz[i][ii][j][jj] = jj;
res[i][ii][j][jj] = 0;
continue;
}
int32_t &pozz = poz[i][ii][j][jj];
if (j + 1 != _) {
pozz = 1 + max(res[!i][ii][j][jj], res[i][_ - 1][ii][jj]);
poz_podz[i][ii][j][jj] = _ - 1;
} else {
pozz = 1e9;
poz_podz[i][ii][j][jj] = _;
}
int32_t war = poz[!i][ii][j][jj];
int32_t gd = poz_podz[!i][ii][j][jj];
if (res[i][ii][gd][jj] < war) {
if (pozz > war) {
pozz = war;
poz_podz[i][ii][j][jj] = gd;
}
}
int32_t &pionn = pion[i][ii][j][jj];
if (jj + 1 != ii) {
pionn = 1 + max(res[i][ii - 1][j][jj], res[i][ii][j][ii - 1]);
pion_podz[i][ii][j][jj] = ii - 1;
} else {
pionn = 1e9;
pion_podz[i][ii][j][jj] = ii;
}
war = pion[i][ii - 1][j][jj];
gd = pion_podz[i][ii - 1][j][jj];
if (res[i][ii][j][gd] < war) {
if (pionn > war) {
pionn = war;
pion_podz[i][ii][j][jj] = gd;
}
}
res[i][ii][j][jj] = min(pionn, pozz);
}
}
cout << res[n & 1][m][0][0] << "\n";
}
| #pragma GCC optimize("O3")
#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
// gp_hash_table<int, int> mapka;
using namespace std;
#define PB push_back
#define MP make_pair
#define LL long long
#define int LL
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define RE(i, n) FOR(i, 1, n)
#define REP(i, n) FOR(i, 0, (int)(n)-1)
#define R(i, n) REP(i, n)
#define VI vector<int>
#define PII pair<int, int>
#define LD long double
#define FI first
#define SE second
#define st FI
#define nd SE
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
template <class C> void mini(C &a4, C b4) { a4 = min(a4, b4); }
template <class C> void maxi(C &a4, C b4) { a4 = max(a4, b4); }
template <class TH> void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA> void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',')
cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V)
os << vv << ",";
return os << "]";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.st << "," << P.nd << ")";
}
#ifdef LOCAL
#define debug(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define debug(...) (__VA_ARGS__)
#define cerr \
if (0) \
cout
#endif
const int MAX = 186;
int n, m;
int sp[MAX][MAX];
int32_t poz[2][MAX][MAX][MAX];
int32_t poz_podz[2][MAX][MAX][MAX];
int32_t pion[2][MAX][MAX][MAX];
int32_t pion_podz[2][MAX][MAX][MAX];
int32_t res[2][MAX][MAX][MAX];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
cerr << fixed << setprecision(6);
cin >> n >> m;
R(i, n) {
string s;
cin >> s;
R(j, m) {
sp[i + 1][j + 1] = sp[i + 1][j] + sp[i][j + 1] - sp[i][j] + (s[j] == '.');
}
}
R(_, n + 1) {
int i = _ & 1;
R(ii, m + 1)
for (int j = _ - 1; j >= 0; j--) for (int jj = ii - 1; jj >= 0; jj--) {
int pom = sp[_][ii] - sp[_][jj] - sp[j][ii] + sp[j][jj];
if (pom == 0 || pom == (_ - j) * (ii - jj)) {
// debug("pusty", _, ii, j, jj);
poz[i][ii][j][jj] = 0;
poz_podz[i][ii][j][jj] = j;
pion[i][ii][j][jj] = 0;
pion_podz[i][ii][j][jj] = jj;
res[i][ii][j][jj] = 0;
continue;
}
int32_t &pozz = poz[i][ii][j][jj];
if (j + 1 != _) {
pozz = 1 + max(res[!i][ii][j][jj], res[i][ii][_ - 1][jj]);
poz_podz[i][ii][j][jj] = _ - 1;
} else {
pozz = 1e9;
poz_podz[i][ii][j][jj] = _;
}
int32_t war = poz[!i][ii][j][jj];
int32_t gd = poz_podz[!i][ii][j][jj];
if (res[i][ii][gd][jj] < war) {
if (pozz > war) {
pozz = war;
poz_podz[i][ii][j][jj] = gd;
}
}
int32_t &pionn = pion[i][ii][j][jj];
if (jj + 1 != ii) {
pionn = 1 + max(res[i][ii - 1][j][jj], res[i][ii][j][ii - 1]);
pion_podz[i][ii][j][jj] = ii - 1;
} else {
pionn = 1e9;
pion_podz[i][ii][j][jj] = ii;
}
war = pion[i][ii - 1][j][jj];
gd = pion_podz[i][ii - 1][j][jj];
if (res[i][ii][j][gd] < war) {
if (pionn > war) {
pionn = war;
pion_podz[i][ii][j][jj] = gd;
}
}
res[i][ii][j][jj] = min(pionn, pozz);
}
}
cout << res[n & 1][m][0][0] << "\n";
}
| [] | 874,350 | 874,351 | u200679581 | cpp |
p03056 | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author izban
*/
#include <fstream>
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double dbl;
#ifdef HOME
#define db(x) \
{ cerr << #x << " = " << x << endl; }
#define db2(x, y) \
{ \
cerr << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")" \
<< endl; \
}
#define db3(x, y, z) \
{ \
cerr << "(" << #x << ", " << #y << ", " << #z << ") = (" << x << ", " << y \
<< ", " << z << ")" << endl; \
}
#define dbv(a) \
{ \
cerr << #a << " = "; \
for (auto xxx : a) \
cerr << xxx << " "; \
cerr << endl; \
}
#else
#define db(x) ;
#define db3(x, y, z) ;
#define db2(x, y) ;
#define dbv(a) ;
#endif
#define sz(a) (int)(a).size()
#define all(a) (a).begin(), a.end()
#define pw(x) (1LL << (x))
const int N = 187;
const int LG = 20;
// typedef int mint;
const int INF = 1000;
int dpR[LG][N][N][N];
int dpD[LG][N][N][N];
class D {
public:
int fast(vector<vector<int>> a) {
int n = a.size();
int m = a[0].size();
vector<vector<int>> s(n + 1, vector<int>(m + 1));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i - 1][j - 1];
}
}
auto ok = [&](int u, int d, int l, int r) {
int cnt = s[d + 1][r + 1] - s[u][r + 1] - s[d + 1][l] + s[u][l];
return cnt == 0 || cnt == (d - u + 1) * (r - l + 1);
};
// memset(dpR, 255, sizeof(dpR));
// memset(dpD, 255, sizeof(dpD));
for (int val = 0; val < LG; val++) {
for (int u = 0; u < n; u++) {
for (int l = 0; l < m; l++) {
for (int d = u; d < n; d++) {
int L = l - 1, R = m;
while (R - L > 1) {
int M = (L + R) >> 1;
bool good = 0;
if (val == 0) {
good = ok(u, d, l, M);
} else {
{
int cov1 = dpR[val - 1][u][l][d];
if (cov1 < m - 1)
cov1 = dpR[val - 1][u][cov1 + 1][d];
good |= cov1 >= M;
}
{
int cov1 = dpD[val - 1][u][l][M];
if (cov1 < n - 1)
cov1 = dpD[val - 1][cov1 + 1][l][M];
good |= cov1 >= d;
}
}
if (good)
L = M;
else
R = M;
}
dpR[val][u][l][d] = L;
}
for (int r = l; r < m; r++) {
int L = u - 1, R = n;
while (R - L > 1) {
int M = (L + R) >> 1;
bool good = 0;
if (val == 0) {
good = ok(u, M, l, r);
} else {
{
int cov1 = dpD[val - 1][u][l][r];
if (cov1 < n - 1)
cov1 = dpD[val - 1][cov1 + 1][l][r];
good |= cov1 >= M;
}
{
int cov1 = dpR[val - 1][u][l][M];
if (cov1 < m - 1)
cov1 = dpR[val - 1][u][cov1 + 1][M];
good |= cov1 >= r;
}
}
if (good)
L = M;
else
R = M;
}
dpD[val][u][l][r] = L;
}
}
}
}
int ans = 0;
while (dpR[ans][0][0][n - 1] < m - 1) {
ans++;
}
return ans;
}
void test() {
int n = 185, m = 185;
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
a[i][j] = rand() % 2;
cout << fast(a) << endl;
cerr << clock() / (double)CLOCKS_PER_SEC << endl;
exit(0);
}
void solve(std::istream &in, std::ostream &out) {
// test();
ios_base::sync_with_stdio(0);
in.tie(0);
int n, m;
in >> n >> m;
vector<string> s(n);
for (int i = 0; i < n; i++)
in >> s[i];
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
a[i][j] = s[i][j] == '#';
out << fast(a) << endl;
}
};
int main() {
D solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author izban
*/
#include <fstream>
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double dbl;
#ifdef HOME
#define db(x) \
{ cerr << #x << " = " << x << endl; }
#define db2(x, y) \
{ \
cerr << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")" \
<< endl; \
}
#define db3(x, y, z) \
{ \
cerr << "(" << #x << ", " << #y << ", " << #z << ") = (" << x << ", " << y \
<< ", " << z << ")" << endl; \
}
#define dbv(a) \
{ \
cerr << #a << " = "; \
for (auto xxx : a) \
cerr << xxx << " "; \
cerr << endl; \
}
#else
#define db(x) ;
#define db3(x, y, z) ;
#define db2(x, y) ;
#define dbv(a) ;
#endif
#define sz(a) (int)(a).size()
#define all(a) (a).begin(), a.end()
#define pw(x) (1LL << (x))
const int N = 187;
const int LG = 18;
// typedef int mint;
const int INF = 1000;
short dpR[LG][N][N][N];
short dpD[LG][N][N][N];
class D {
public:
int fast(vector<vector<int>> a) {
// cerr << sizeof(dpR) + sizeof(dpD) << endl;
int n = a.size();
int m = a[0].size();
vector<vector<int>> s(n + 1, vector<int>(m + 1));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i - 1][j - 1];
}
}
auto ok = [&](int u, int d, int l, int r) {
int cnt = s[d + 1][r + 1] - s[u][r + 1] - s[d + 1][l] + s[u][l];
return cnt == 0 || cnt == (d - u + 1) * (r - l + 1);
};
// memset(dpR, 255, sizeof(dpR));
// memset(dpD, 255, sizeof(dpD));
for (int val = 0; val < LG; val++) {
for (int u = 0; u < n; u++) {
for (int l = 0; l < m; l++) {
for (int d = u; d < n; d++) {
int L = l - 1, R = m;
while (R - L > 1) {
int M = (L + R) >> 1;
bool good = 0;
if (val == 0) {
good = ok(u, d, l, M);
} else {
{
int cov1 = dpR[val - 1][u][l][d];
if (cov1 < m - 1)
cov1 = dpR[val - 1][u][cov1 + 1][d];
good |= cov1 >= M;
}
{
int cov1 = dpD[val - 1][u][l][M];
if (cov1 < n - 1)
cov1 = dpD[val - 1][cov1 + 1][l][M];
good |= cov1 >= d;
}
}
if (good)
L = M;
else
R = M;
}
dpR[val][u][l][d] = L;
}
for (int r = l; r < m; r++) {
int L = u - 1, R = n;
while (R - L > 1) {
int M = (L + R) >> 1;
bool good = 0;
if (val == 0) {
good = ok(u, M, l, r);
} else {
{
int cov1 = dpD[val - 1][u][l][r];
if (cov1 < n - 1)
cov1 = dpD[val - 1][cov1 + 1][l][r];
good |= cov1 >= M;
}
{
int cov1 = dpR[val - 1][u][l][M];
if (cov1 < m - 1)
cov1 = dpR[val - 1][u][cov1 + 1][M];
good |= cov1 >= r;
}
}
if (good)
L = M;
else
R = M;
}
dpD[val][u][l][r] = L;
}
}
}
}
int ans = 0;
while (dpR[ans][0][0][n - 1] < m - 1) {
ans++;
}
return ans;
}
void test() {
int n = 185, m = 185;
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
a[i][j] = rand() % 2;
cout << fast(a) << endl;
cerr << clock() / (double)CLOCKS_PER_SEC << endl;
exit(0);
}
void solve(std::istream &in, std::ostream &out) {
// test();
ios_base::sync_with_stdio(0);
in.tie(0);
int n, m;
in >> n >> m;
vector<string> s(n);
for (int i = 0; i < n; i++)
in >> s[i];
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
a[i][j] = s[i][j] == '#';
out << fast(a) << endl;
}
};
int main() {
D solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"variable_declaration.type.primitive.change"
] | 874,356 | 874,357 | u039462798 | cpp |
p03056 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define REP(i, n) for (int i = (0); i < (n); i++)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef long long ll;
const int N = 188, M = 19;
short f[N][N][N][M];
short g[N][N][N][M];
int s[N][N], n, m;
char a[N][N];
int empty(int u, int d, int l, int r) {
int sum = s[d][r] - s[d][l - 1] - s[u - 1][r] + s[u - 1][l - 1];
return sum == 0 || sum == (r - l + 1) * (d - u + 1);
}
short F(int L, int U, int D, int k);
short G(int U, int L, int R, int k);
short F(int L, int U, int D, int k) {
if (L > m)
return m;
short &res = f[L][U][D][k];
if (res != -1)
return res;
if (k == 0) {
int l = L - 1, r = m, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (empty(U, D, l, mid))
l = mid;
else
r = mid - 1;
}
return res = l;
}
int A = F(F(L, U, D, k - 1) + 1, U, D, k - 1);
int l = L - 1, r = m, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (G(G(U, L, mid, k - 1) + 1, L, mid, k - 1) >= D)
l = mid;
else
r = mid - 1;
}
// printf("%d %d %d %d %d\n",L,U,D,k,max(A,l));
return res = max(A, l);
}
short G(int U, int L, int R, int k) {
if (U > n)
return n;
short &res = g[U][L][R][k];
if (res != -1)
return res;
if (k == 0) {
int l = U - 1, r = n, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (empty(U, mid, L, R))
l = mid;
else
r = mid - 1;
}
return res = l;
}
int A = G(G(U, L, R, k - 1) + 1, L, R, k - 1);
int l = U - 1, r = n, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (F(F(L, U, mid, k - 1) + 1, U, mid, k - 1) >= R)
l = mid;
else
r = mid - 1;
}
return res = max(A, l);
}
int main() {
scanf("%d%d", &n, &m);
rep(i, 1, n) {
scanf("%s", a[i] + 1);
rep(j, 1, m) s[i][j] =
s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + (a[i][j] == '#');
}
int ans = 0;
memset(f, -1, sizeof f);
memset(g, -1, sizeof g);
while (F(1, 1, n, ans) < m)
ans++;
printf("%d\n", ans);
return 0;
} | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define REP(i, n) for (int i = (0); i < (n); i++)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef long long ll;
const int N = 188, M = 19;
short f[N][N][N][M];
short g[N][N][N][M];
int s[N][N], n, m;
char a[N][N];
int empty(int u, int d, int l, int r) {
int sum = s[d][r] - s[d][l - 1] - s[u - 1][r] + s[u - 1][l - 1];
return sum == 0 || sum == (r - l + 1) * (d - u + 1);
}
short F(int L, int U, int D, int k);
short G(int U, int L, int R, int k);
short F(int L, int U, int D, int k) {
if (L > m)
return m;
short &res = f[L][U][D][k];
if (res != -1)
return res;
if (k == 0) {
int l = L - 1, r = m, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (empty(U, D, L, mid))
l = mid;
else
r = mid - 1;
}
// printf("%d %d %d %d %d\n",L,U,D,k,l);
return res = l;
}
int A = F(F(L, U, D, k - 1) + 1, U, D, k - 1);
int l = L - 1, r = m, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (G(G(U, L, mid, k - 1) + 1, L, mid, k - 1) >= D)
l = mid;
else
r = mid - 1;
}
// printf("%d %d %d %d %d\n",L,U,D,k,max(A,l));
return res = max(A, l);
}
short G(int U, int L, int R, int k) {
if (U > n)
return n;
short &res = g[U][L][R][k];
if (res != -1)
return res;
if (k == 0) {
int l = U - 1, r = n, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (empty(U, mid, L, R))
l = mid;
else
r = mid - 1;
}
return res = l;
}
int A = G(G(U, L, R, k - 1) + 1, L, R, k - 1);
int l = U - 1, r = n, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (F(F(L, U, mid, k - 1) + 1, U, mid, k - 1) >= R)
l = mid;
else
r = mid - 1;
}
return res = max(A, l);
}
int main() {
scanf("%d%d", &n, &m);
rep(i, 1, n) {
scanf("%s", a[i] + 1);
rep(j, 1, m) s[i][j] =
s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + (a[i][j] == '#');
}
int ans = 0;
memset(f, -1, sizeof f);
memset(g, -1, sizeof g);
while (F(1, 1, n, ans) < m)
ans++;
printf("%d\n", ans);
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 874,358 | 874,359 | u603486542 | cpp |
p03057 | #include <cstdio>
#include <iostream>
#define RI register int
#define CI const int &
using namespace std;
const int N = 200005, mod = 1e9 + 7;
int n, m, c[N], k, lst, f[N], pfx[N], ans;
char s[N];
inline int sum(CI x, CI y) {
int t = x + y;
return t >= mod ? t - mod : t;
}
namespace SP // one char solver
{
int f[N][2][2];
inline int solve(void) {
f[1][0][0] = f[1][1][1] = 1;
for (RI i = 2; i <= n; ++i)
f[i][0][0] = sum(f[i - 1][0][0], f[i - 1][0][1]),
f[i][0][1] = f[i - 1][0][0],
f[i][1][0] = sum(f[i - 1][1][0], f[i - 1][1][1]),
f[i][1][1] = f[i - 1][1][0];
return sum(f[n][0][0], sum(f[n][0][1], f[n][1][0]));
}
}; // namespace SP
int main() {
RI i;
for (scanf("%d%d%s", &n, &m, s + 1), lst = 1, i = 2; i <= n; ++i)
if (s[i] != s[i - 1])
c[++k] = i - lst, lst = i;
c[++k] = n - lst + 1;
if (k == 1)
return printf("%d", SP::solve()), 0;
if (n & 1)
return puts("0"), 0;
if (k & 1)
--k;
int lim = c[1] + !(c[1] & 1);
for (i = 3; i <= k; i += 2)
if (c[i] & 1)
lim = min(lim, c[i]);
for (n >>= 1, lim = lim + 1 >> 1, f[0] = pfx[0] = i = 1; i <= n; ++i)
f[i] = sum(pfx[i - 1], mod - (i - 1 - lim >= 0 ? pfx[i - 1 - lim] : 0)),
pfx[i] = sum(pfx[i - 1], f[i]);
for (i = 1; i <= min(n, lim); ++i)
ans = sum(ans, 2LL * f[n - i] * i % mod);
return printf("%d", ans), 0;
} | #include <cstdio>
#include <iostream>
#define RI register int
#define CI const int &
using namespace std;
const int N = 200005, mod = 1e9 + 7;
int n, m, c[N], k, lst, f[N], pfx[N], ans;
char s[N];
inline int sum(CI x, CI y) {
int t = x + y;
return t >= mod ? t - mod : t;
}
namespace SP // one char solver
{
int f[N][2][2];
inline int solve(void) {
f[1][0][0] = f[1][1][1] = 1;
for (RI i = 2; i <= n; ++i)
f[i][0][0] = sum(f[i - 1][0][0], f[i - 1][0][1]),
f[i][0][1] = f[i - 1][0][0],
f[i][1][0] = sum(f[i - 1][1][0], f[i - 1][1][1]),
f[i][1][1] = f[i - 1][1][0];
return sum(f[n][0][0], sum(f[n][0][1], f[n][1][0]));
}
}; // namespace SP
int main() {
RI i;
for (scanf("%d%d%s", &n, &m, s + 1), lst = 1, i = 2; i <= m; ++i)
if (s[i] != s[i - 1])
c[++k] = i - lst, lst = i;
c[++k] = n - lst + 1;
if (k == 1)
return printf("%d", SP::solve()), 0;
if (n & 1)
return puts("0"), 0;
if (k & 1)
--k;
int lim = c[1] + !(c[1] & 1);
for (i = 3; i <= k; i += 2)
if (c[i] & 1)
lim = min(lim, c[i]);
for (n >>= 1, lim = lim + 1 >> 1, f[0] = pfx[0] = i = 1; i <= n; ++i)
f[i] = sum(pfx[i - 1], mod - (i - 1 - lim >= 0 ? pfx[i - 1 - lim] : 0)),
pfx[i] = sum(pfx[i - 1], f[i]);
for (i = 1; i <= min(n, lim); ++i)
ans = sum(ans, 2LL * f[n - i] * i % mod);
return printf("%d", ans), 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 874,374 | 874,375 | u803115645 | cpp |
p03057 | #include <bits/stdc++.h>
#define rep(i, n) for ((i) = 1; (i) <= (n); (i)++)
using namespace std;
const int mod = 1e9 + 7;
int n, m, i, lst, dp[200005], s[200005], f[200005][2], tmp, mi = 0x3f3f3f3f, l;
string st;
int main() {
cin >> n >> m;
cin >> st;
st = " " + st;
i = 1;
lst = 1;
while (i <= n) {
if (st[i] != st[i - 1]) {
if (st[i] != st[1]) {
if (lst == 1 || ((i - lst) & 1)) {
mi = min(mi, i - lst);
}
} else {
lst = i;
}
}
i++;
}
if (mi < 0x3f3f3f3f) {
if (n & 1) {
puts("0");
return 0;
}
mi = mi / 2 + 1;
n /= 2;
l = 1;
/* s[1]=1;s[mi+1]+=mod-1;
rep(i,n){
tmp=(tmp+s[i])%mod;
dp[i]=tmp;
s[min(n,i+1)]=(s[min(n,i+1)]+dp[i])%mod;
s[min(n,i+mi)+1]=(s[min(n,i+mi)+1]+mod-dp[i])%mod;
}
cout<<dp[n]<<endl;*/
} else {
l = 2;
}
for (i = l; i <= n; i++) {
dp[i] = (s[i - l] + (i > mi ? -s[i - mi - 1] : (3ll - l) * i)) % mod;
s[i] = (s[i - 1] + dp[i]) % mod;
}
cout << (dp[n] + l - 1 + mod) % mod << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for ((i) = 1; (i) <= (n); (i)++)
using namespace std;
const int mod = 1e9 + 7;
int n, m, i, lst, dp[200005], s[200005], f[200005][2], tmp, mi = 0x3f3f3f3f, l;
string st;
int main() {
cin >> n >> m;
cin >> st;
st = " " + st;
i = 1;
lst = 1;
while (i <= m) {
if (st[i] != st[i - 1]) {
if (st[i] != st[1]) {
if (lst == 1 || ((i - lst) & 1)) {
mi = min(mi, i - lst);
}
} else {
lst = i;
}
}
i++;
}
if (mi < 0x3f3f3f3f) {
if (n & 1) {
puts("0");
return 0;
}
mi = mi / 2 + 1;
n /= 2;
l = 1;
/* s[1]=1;s[mi+1]+=mod-1;
rep(i,n){
tmp=(tmp+s[i])%mod;
dp[i]=tmp;
s[min(n,i+1)]=(s[min(n,i+1)]+dp[i])%mod;
s[min(n,i+mi)+1]=(s[min(n,i+mi)+1]+mod-dp[i])%mod;
}
cout<<dp[n]<<endl;*/
} else {
l = 2;
}
for (i = l; i <= n; i++) {
dp[i] = (s[i - l] + (i > mi ? -s[i - mi - 1] : (3ll - l) * i)) % mod;
s[i] = (s[i - 1] + dp[i]) % mod;
}
cout << (dp[n] + l - 1 + mod) % mod << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.condition.change"
] | 874,378 | 874,379 | u878185566 | cpp |
p03057 | #include <bits/stdc++.h>
#define rep(i, n) for ((i) = 1; (i) <= (n); (i)++)
using namespace std;
const int mod = 1e9 + 7;
int n, m, i, lst, dp[100005], s[100005], f[100005][2], tmp, mi = 0x3f3f3f3f, l;
string st;
int main() {
cin >> n >> m;
cin >> st;
st = " " + st;
i = 1;
lst = 1;
while (i <= n) {
if (st[i] != st[i - 1]) {
if (st[i] != st[1]) {
if (lst == 1 || ((i - lst) & 1)) {
mi = min(mi, i - lst);
}
} else {
lst = i;
}
}
i++;
}
if (mi < 0x3f3f3f3f) {
if (n & 1) {
puts("0");
return 0;
}
mi = mi / 2 + 1;
n /= 2;
l = 1;
/* s[1]=1;s[mi+1]+=mod-1;
rep(i,n){
tmp=(tmp+s[i])%mod;
dp[i]=tmp;
s[min(n,i+1)]=(s[min(n,i+1)]+dp[i])%mod;
s[min(n,i+mi)+1]=(s[min(n,i+mi)+1]+mod-dp[i])%mod;
}
cout<<dp[n]<<endl;*/
} else {
l = 2;
}
for (i = l; i <= n; i++) {
dp[i] = (s[i - l] + (i > mi ? -s[i - mi - 1] : (3ll - l) * i)) % mod;
s[i] = (s[i - 1] + dp[i]) % mod;
}
cout << (dp[n] + l - 1 + mod) % mod << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for ((i) = 1; (i) <= (n); (i)++)
using namespace std;
const int mod = 1e9 + 7;
int n, m, i, lst, dp[200005], s[200005], f[200005][2], tmp, mi = 0x3f3f3f3f, l;
string st;
int main() {
cin >> n >> m;
cin >> st;
st = " " + st;
i = 1;
lst = 1;
while (i <= m) {
if (st[i] != st[i - 1]) {
if (st[i] != st[1]) {
if (lst == 1 || ((i - lst) & 1)) {
mi = min(mi, i - lst);
}
} else {
lst = i;
}
}
i++;
}
if (mi < 0x3f3f3f3f) {
if (n & 1) {
puts("0");
return 0;
}
mi = mi / 2 + 1;
n /= 2;
l = 1;
/* s[1]=1;s[mi+1]+=mod-1;
rep(i,n){
tmp=(tmp+s[i])%mod;
dp[i]=tmp;
s[min(n,i+1)]=(s[min(n,i+1)]+dp[i])%mod;
s[min(n,i+mi)+1]=(s[min(n,i+mi)+1]+mod-dp[i])%mod;
}
cout<<dp[n]<<endl;*/
} else {
l = 2;
}
for (i = l; i <= n; i++) {
dp[i] = (s[i - l] + (i > mi ? -s[i - mi - 1] : (3ll - l) * i)) % mod;
s[i] = (s[i - 1] + dp[i]) % mod;
}
cout << (dp[n] + l - 1 + mod) % mod << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"identifier.change",
"control_flow.loop.condition.change"
] | 874,380 | 874,379 | u878185566 | cpp |
p03057 | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 201000, mod = 1e9 + 7;
char s[N];
int a[N], n, m;
void solve1() {
int f[N][2][2];
memset(f, 0, sizeof(f));
f[1][1][1] = f[1][0][0] = 1;
auto upd = [](int &a, int b) {
a += b;
if (a >= mod)
a -= mod;
};
for (int i = 2; i <= n; i++) {
upd(f[i][1][1], f[i - 1][1][0]);
upd(f[i][1][1], f[i - 1][1][1]);
upd(f[i][1][0], f[i - 1][1][1]);
upd(f[i][0][1], f[i - 1][0][0]);
upd(f[i][0][1], f[i - 1][0][1]);
upd(f[i][0][0], f[i - 1][0][1]);
}
cout << (0ll + f[n][1][1] + f[n][1][0] + f[n][0][1]) % mod << '\n';
}
void solve2() {
int _f[N], *f;
memset(_f, 0, sizeof(_f));
f = _f + 100;
int len = n | 1, now = 0, pos = n;
while (a[pos])
pos--;
for (int i = pos; i; i--)
if (!a[i]) {
if (now & 1)
len = min(len, now);
now = 0;
} else
now++;
len = min(len, now | 1);
f[-1] = f[1] = 1;
for (int i = 3; i <= n; i += 2) {
f[i] = 2ll * f[i - 2] % mod;
if (i > len)
f[i] = (f[i] - f[i - len - 3] + mod) % mod;
}
ll ans = 0;
for (int i = 1; i <= len; i += 2)
ans = (1ll * (i + 1) * f[n - i - 2] + ans) % mod;
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> s + 1;
for (int i = 1; i <= m; i++)
a[i] = s[i] == s[1];
int flag = 1;
for (int i = 1; i <= m; i++)
flag &= a[i];
if (flag)
solve1();
else
solve2();
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 501000, mod = 1e9 + 7;
char s[N];
int a[N], n, m;
void solve1() {
int f[N][2][2];
memset(f, 0, sizeof(f));
f[1][1][1] = f[1][0][0] = 1;
auto upd = [](int &a, int b) {
a += b;
if (a >= mod)
a -= mod;
};
for (int i = 2; i <= n; i++) {
upd(f[i][1][1], f[i - 1][1][0]);
upd(f[i][1][1], f[i - 1][1][1]);
upd(f[i][1][0], f[i - 1][1][1]);
upd(f[i][0][1], f[i - 1][0][0]);
upd(f[i][0][1], f[i - 1][0][1]);
upd(f[i][0][0], f[i - 1][0][1]);
}
cout << (0ll + f[n][1][1] + f[n][1][0] + f[n][0][1]) % mod << '\n';
}
void solve2() {
int _f[N], *f;
memset(_f, 0, sizeof(_f));
f = _f + 100;
int len = n | 1, now = 0, pos = m;
while (a[pos])
pos--;
for (int i = pos; i; i--)
if (!a[i]) {
if (now & 1)
len = min(len, now);
now = 0;
} else
now++;
len = min(len, now | 1);
f[-1] = f[1] = 1;
for (int i = 3; i <= n; i += 2) {
f[i] = 2ll * f[i - 2] % mod;
if (i > len)
f[i] = (f[i] - f[i - len - 3] + mod) % mod;
}
ll ans = 0;
for (int i = 1; i <= len; i += 2)
ans = (1ll * (i + 1) * f[n - i - 2] + ans) % mod;
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> s + 1;
for (int i = 1; i <= m; i++)
a[i] = s[i] == s[1];
int flag = 1;
for (int i = 1; i <= m; i++)
flag &= a[i];
if (flag)
solve1();
else
solve2();
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"identifier.change"
] | 874,410 | 874,411 | u684730254 | cpp |
p03057 | #include <bits/stdc++.h>
#define ll long long
#define mo 1000000007
#define N 200010
using namespace std;
int n, m, a[N], b[N], nb;
ll dp[N], s[N], ans;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
char ch = getchar();
while (ch != 'R' && ch != 'B')
ch = getchar();
a[i] = (ch == 'R');
}
for (int la = 0, i = 1; i <= m; i++)
if (a[i] != a[1]) {
b[++nb] = i - la - 1;
la = i;
}
if (nb == 0) {
s[0] = s[1] = ans = 1;
for (int i = 2; i < n; i++)
s[i] = (s[i - 1] + s[i - 2]) % mo;
for (int j = 0; j < n - 1; j++)
ans = (ans + s[j]) % mo;
ans = (ans + s[n - 2]) % mo;
} else {
int ma = b[1];
for (int i = 2; i <= nb; i++)
if (b[i] % 2)
ma = max(ma, b[i]);
if (ma % 2 == 0)
ma++;
ma++;
dp[0] = 1;
s[0] = 1;
for (int i = 1; i <= n; i++) {
if (i % 2)
dp[i] = 0;
else {
dp[i] = s[i - 1];
if (i - ma - 1 >= 0)
dp[i] = (dp[i] - s[i - ma - 1] + mo) % mo;
}
s[i] = (s[i - 1] + dp[i]) % mo;
}
for (int j = n - 2; j >= 0; j -= 2)
if (n - j <= ma)
ans = (ans + dp[j] * (n - j)) % mo;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define mo 1000000007
#define N 200010
using namespace std;
int n, m, a[N], b[N], nb;
ll dp[N], s[N], ans;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
char ch = getchar();
while (ch != 'R' && ch != 'B')
ch = getchar();
a[i] = (ch == 'R');
}
for (int la = 0, i = 1; i <= m; i++)
if (a[i] != a[1]) {
b[++nb] = i - la - 1;
la = i;
}
if (nb == 0) {
s[0] = s[1] = ans = 1;
for (int i = 2; i < n; i++)
s[i] = (s[i - 1] + s[i - 2]) % mo;
for (int j = 0; j < n - 1; j++)
ans = (ans + s[j]) % mo;
ans = (ans + s[n - 2]) % mo;
} else {
int ma = b[1];
for (int i = 2; i <= nb; i++)
if (b[i] % 2)
ma = min(ma, b[i]);
if (ma % 2 == 0)
ma++;
ma++;
dp[0] = 1;
s[0] = 1;
for (int i = 1; i <= n; i++) {
if (i % 2)
dp[i] = 0;
else {
dp[i] = s[i - 1];
if (i - ma - 1 >= 0)
dp[i] = (dp[i] - s[i - ma - 1] + mo) % mo;
}
s[i] = (s[i - 1] + dp[i]) % mo;
}
for (int j = n - 2; j >= 0; j -= 2)
if (n - j <= ma)
ans = (ans + dp[j] * (n - j)) % mo;
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 874,412 | 874,413 | u539443668 | cpp |
p03057 | #include <bits/stdc++.h>
#define ll long long
#define mo 1000000007
#define N 200010
using namespace std;
int n, m, a[N], b[N], nb;
ll dp[N], s[N], ans;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
char ch = getchar();
while (ch != 'R' && ch != 'B')
ch = getchar();
a[i] = (ch == 'R');
}
for (int la = 0, i = 1; i <= m; i++)
if (a[i] != a[1]) {
b[++nb] = i - la - 1;
la = i;
}
if (nb == 0) {
s[0] = s[1] = ans = 1;
for (int i = 2; i < n; i++)
s[i] = (s[i - 1] + s[i - 2]) % mo;
for (int j = 0; j < n - 1; j++)
ans = (ans + s[j]) % mo;
ans = (ans + s[n - 2]) % mo;
} else {
int ma = b[1];
for (int i = 2; i <= nb; i++)
if (b[i] % 2)
ma = max(ma, b[i]);
if (ma % 2 == 0)
ma++;
ma++;
dp[0] = 1;
s[0] = 1;
for (int i = 1; i <= n; i++) {
if (i % 2)
dp[i] = 0;
else {
dp[i] = s[i - 1];
if (i - ma - 1 >= 0)
dp[i] = (dp[i] - s[i - ma - 1]) % mo;
}
s[i] = (s[i - 1] + dp[i]) % mo;
}
for (int j = n - 2; j >= 0; j -= 2)
if (n - j <= ma)
ans = (ans + dp[j] * (n - j)) % mo;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define mo 1000000007
#define N 200010
using namespace std;
int n, m, a[N], b[N], nb;
ll dp[N], s[N], ans;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
char ch = getchar();
while (ch != 'R' && ch != 'B')
ch = getchar();
a[i] = (ch == 'R');
}
for (int la = 0, i = 1; i <= m; i++)
if (a[i] != a[1]) {
b[++nb] = i - la - 1;
la = i;
}
if (nb == 0) {
s[0] = s[1] = ans = 1;
for (int i = 2; i < n; i++)
s[i] = (s[i - 1] + s[i - 2]) % mo;
for (int j = 0; j < n - 1; j++)
ans = (ans + s[j]) % mo;
ans = (ans + s[n - 2]) % mo;
} else {
int ma = b[1];
for (int i = 2; i <= nb; i++)
if (b[i] % 2)
ma = min(ma, b[i]);
if (ma % 2 == 0)
ma++;
ma++;
dp[0] = 1;
s[0] = 1;
for (int i = 1; i <= n; i++) {
if (i % 2)
dp[i] = 0;
else {
dp[i] = s[i - 1];
if (i - ma - 1 >= 0)
dp[i] = (dp[i] - s[i - ma - 1] + mo) % mo;
}
s[i] = (s[i - 1] + dp[i]) % mo;
}
for (int j = n - 2; j >= 0; j -= 2)
if (n - j <= ma)
ans = (ans + dp[j] * (n - j)) % mo;
}
cout << ans << endl;
return 0;
} | [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change",
"assignment.change"
] | 874,414 | 874,413 | u539443668 | cpp |
p03057 | #include <bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef long double louble;
template <typename T1, typename T2> inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2> inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t)
return EOF;
}
return *s++;
}
inline int ty() {
int a = 0, b = 1, c = fetch();
while (!isdigit(c))
b ^= c == '-', c = fetch();
while (isdigit(c))
a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
template <typename T> inline int ts(T *s) {
int a = 0, c = fetch();
while (c <= 32 && c != EOF)
c = fetch();
while (c > 32 && c != EOF)
s[a++] = c, c = fetch();
s[a] = 0;
return a;
}
} // namespace ae86
using ae86::ts;
using ae86::ty;
const int _ = 200007, mo = 1000000007;
int n, m, s[_];
lint f[_] = {0};
int main() {
n = ty(), m = ty(), ts(s + 1);
for (int i = m; i >= 1; i--)
s[i] = s[i] == s[1];
lint ans = 0;
while (m > 1 && s[m])
m--;
if (m <= 1)
ans = 1;
int lim = n;
for (int l = 1, r = 1; l <= m; l = r + 1) {
while (l <= m && !s[l])
l++;
if (l > m)
break;
r = l;
while (r < m && s[r + 1])
r++;
int len = r - l + 1;
if (l == 1)
lim = min(lim, len + (1 - len % 2));
if (len & 1)
lim = min(lim, len);
}
if (lim >= n) {
f[0] = 1;
for (int i = 1, x = 0; i <= n; i++)
f[i] = x, x = (x + f[i - 1]) % mo;
for (int i = 2; i <= n; i++)
ans = (ans + f[n - i] * i % mo) % mo;
} else {
f[0] = 1;
for (int i = 2, x = f[0]; i <= n; i += 2) {
f[i] = x, x = (x + f[i]) % mo;
if (i > lim)
x = (x - f[i - lim - 1] + mo) % mo;
}
for (int i = 2; i <= lim + 1; i += 2)
ans = (ans + f[n - i] * i % mo) % mo;
}
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef long double louble;
template <typename T1, typename T2> inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2> inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t)
return EOF;
}
return *s++;
}
inline int ty() {
int a = 0, b = 1, c = fetch();
while (!isdigit(c))
b ^= c == '-', c = fetch();
while (isdigit(c))
a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
template <typename T> inline int ts(T *s) {
int a = 0, c = fetch();
while (c <= 32 && c != EOF)
c = fetch();
while (c > 32 && c != EOF)
s[a++] = c, c = fetch();
s[a] = 0;
return a;
}
} // namespace ae86
using ae86::ts;
using ae86::ty;
const int _ = 200007, mo = 1000000007;
int n, m, s[_];
lint f[_] = {0};
int main() {
n = ty(), m = ty(), ts(s + 1);
for (int i = m; i >= 1; i--)
s[i] = s[i] == s[1];
lint ans = 0;
while (m && s[m])
m--;
if (m <= 0)
ans = 1;
int lim = n;
for (int l = 1, r = 1; l <= m; l = r + 1) {
while (l <= m && !s[l])
l++;
if (l > m)
break;
r = l;
while (r < m && s[r + 1])
r++;
int len = r - l + 1;
if (l == 1)
lim = min(lim, len + (1 - len % 2));
if (len & 1)
lim = min(lim, len);
}
if (lim >= n) {
f[0] = 1;
for (int i = 1, x = 0; i <= n; i++)
f[i] = x, x = (x + f[i - 1]) % mo;
for (int i = 2; i <= n; i++)
ans = (ans + f[n - i] * i % mo) % mo;
} else {
f[0] = 1;
for (int i = 2, x = f[0]; i <= n; i += 2) {
f[i] = x, x = (x + f[i]) % mo;
if (i > lim)
x = (x - f[i - lim - 1] + mo) % mo;
}
for (int i = 2; i <= lim + 1; i += 2)
ans = (ans + f[n - i] * i % mo) % mo;
}
printf("%lld\n", ans);
return 0;
}
| [
"expression.operation.binary.remove",
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 874,418 | 874,419 | u326034736 | cpp |
p03057 | /*
¼ÙÉèS[1] =
R¡£ÄÇôÏÔÈ»£¬»·Éϲ»»á³öÏÖÁ½¸öÁ¬ÐøµÄ±ß¶¼ÊÇB£¬·ñÔòÔÚËüÃǽ»µã´¦µÚÒ»²½ÍùÁ½±ß×߶¼²»ºÏ·¨
ÌØÅеôSÖÐÈ«ÊÇRµÄÇé¿ö£¬¿¼ÂÇÒ»°ãÇé¿ö
Ê×ÏÈ°ÑËùÓÐÊÇBµÄλÖöϿª£¬ÄÇô¾ÍÐγÉÁËÈô¸É¸öRµÄÁ¬Ðø¶Î¡£¿ÉÒÔ·¢ÏÖÕâôһ¸öÐÔÖÊ£ºÃ¿¸öÁ¬Ðø¶ÎµÄ³¤¶È¾ùΪÆæÊý
Ö¤Ã÷¿¼ÂÇ·´Ö¤¡£¼ÙÉèÓÐÒ»¸öżÊýµÄ¶Î£¬¿¼ÂǶþ·Öͼ¿ÉÒÔ·¢ÏÖ£¬ÄÇôÓеĵã×ßµ½ÕâÒ»¶ÎµÄ¶Ëµã¾àÀëÓÀÔ¶ÊÇżÊý¡¢Óеĵã×ßµ½ÕâÒ»¶ÎµÄ¶Ëµã¾àÀëÓÀÔ¶ÊÇÆæÊý£¬ÒòΪ¶Ëµãͬɫ
¶øSµÄµÚÒ»¶ÎÁ¬ÐøR³¤¶ÈÊǹ̶¨µÄ£¬²»ÄÜͬʱΪżÊý»òÆæÊý£¬Ã¬¶Ü¡£ËùÒÔ¿ÉÒԵõ½½áÂÛ
ͬʱ£¬SÖÐÿ¸öRµÄÁ¬Ðø¶Î¶¼»á¶Ô»·ÉÏÿ¸öRµÄÁ¬Ðø¶ÎÓиöÉϽçµÄÏÞÖÆ
*/
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int Max_NM(200050);
const int MOD(1000000000 + 7);
typedef long long int LL;
int N, M, L, F[Max_NM], Pre[Max_NM][2], Ans;
char S[Max_NM];
constexpr int Add(int a, int b) { return a + b >= MOD ? a + b - MOD : a + b; }
constexpr int Sub(int a, int b) { return a - b < 0 ? a - b + MOD : a - b; }
constexpr int Mult(int a, int b) { return a * 1LL * b % MOD; }
inline void upd(int &a, int b) { a = Add(a, b); }
void dp(bool have) {
F[1] = 1, Pre[1][1 & 1] = 1;
for (int i = 2, j; i <= N; ++i) {
Pre[i][0] = Pre[i - 1][0], Pre[i][1] = Pre[i - 1][1];
upd(Pre[i][i & 1], F[i - 2]);
// jµ½iÊÇR£¬i - j + 1 <= L => j >= i - L + 1
// i - j + 1ÊÇÆæÊý£¬i - jÊÇżÊý£¬iºÍjÆæżÐÔÏàµÈ
j = max(1, i - L + 1);
if (j <= i) {
F[i] = Sub(Pre[i][i & 1], Pre[j - 1][i & 1]);
if (have)
upd(F[i], Sub(Pre[i][(i & 1) ^ 1], Pre[j - 1][(i & 1) ^ 1]));
}
}
}
int main() {
scanf("%d%d", &N, &M);
scanf("%s", S + 1);
bool haveB = false;
if (S[1] == 'B')
for (int i = 1; i <= M; ++i)
S[i] = 'R' + 'B' - S[i];
for (int i = 1; i <= M; ++i)
haveB |= (S[i] == 'B');
L = N;
for (int i = 1, length = 0, stop = 0; i <= M; ++i)
if (S[i] == 'B')
length = 0, stop = 1;
else {
++length;
if (i + 1 <= N && S[i + 1] == 'B')
if (stop == 0)
if (length & 1)
L = min(L, length);
else
L = min(L, length + 1);
else if (length & 1)
L = min(L, length);
}
dp(!haveB);
upd(Ans, F[N - 1]); // edge(1, 2) = B
for (int x = 1, val; x <= L && x < N; ++x) // edge(1, 2) = R
{
if (haveB && ((x & 1) == 0))
continue;
if (x + 1 == N)
val = 1;
else
val = F[N - x - 2];
upd(Ans, Mult(x, val));
}
if (haveB == false)
upd(Ans, 1);
printf("%d", Ans);
return 0;
} | /*
¼ÙÉèS[1] =
R¡£ÄÇôÏÔÈ»£¬»·Éϲ»»á³öÏÖÁ½¸öÁ¬ÐøµÄ±ß¶¼ÊÇB£¬·ñÔòÔÚËüÃǽ»µã´¦µÚÒ»²½ÍùÁ½±ß×߶¼²»ºÏ·¨
ÌØÅеôSÖÐÈ«ÊÇRµÄÇé¿ö£¬¿¼ÂÇÒ»°ãÇé¿ö
Ê×ÏÈ°ÑËùÓÐÊÇBµÄλÖöϿª£¬ÄÇô¾ÍÐγÉÁËÈô¸É¸öRµÄÁ¬Ðø¶Î¡£¿ÉÒÔ·¢ÏÖÕâôһ¸öÐÔÖÊ£ºÃ¿¸öÁ¬Ðø¶ÎµÄ³¤¶È¾ùΪÆæÊý
Ö¤Ã÷¿¼ÂÇ·´Ö¤¡£¼ÙÉèÓÐÒ»¸öżÊýµÄ¶Î£¬¿¼ÂǶþ·Öͼ¿ÉÒÔ·¢ÏÖ£¬ÄÇôÓеĵã×ßµ½ÕâÒ»¶ÎµÄ¶Ëµã¾àÀëÓÀÔ¶ÊÇżÊý¡¢Óеĵã×ßµ½ÕâÒ»¶ÎµÄ¶Ëµã¾àÀëÓÀÔ¶ÊÇÆæÊý£¬ÒòΪ¶Ëµãͬɫ
¶øSµÄµÚÒ»¶ÎÁ¬ÐøR³¤¶ÈÊǹ̶¨µÄ£¬²»ÄÜͬʱΪżÊý»òÆæÊý£¬Ã¬¶Ü¡£ËùÒÔ¿ÉÒԵõ½½áÂÛ
ͬʱ£¬SÖÐÿ¸öRµÄÁ¬Ðø¶Î¶¼»á¶Ô»·ÉÏÿ¸öRµÄÁ¬Ðø¶ÎÓиöÉϽçµÄÏÞÖÆ
*/
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const int Max_NM(200050);
const int MOD(1000000000 + 7);
typedef long long int LL;
int N, M, L, F[Max_NM], Pre[Max_NM][2], Ans;
char S[Max_NM];
constexpr int Add(int a, int b) { return a + b >= MOD ? a + b - MOD : a + b; }
constexpr int Sub(int a, int b) { return a - b < 0 ? a - b + MOD : a - b; }
constexpr int Mult(int a, int b) { return a * 1LL * b % MOD; }
inline void upd(int &a, int b) { a = Add(a, b); }
void dp(bool have) {
F[1] = 1, Pre[1][1 & 1] = 1;
for (int i = 2, j; i <= N; ++i) {
Pre[i][0] = Pre[i - 1][0], Pre[i][1] = Pre[i - 1][1];
upd(Pre[i][i & 1], F[i - 2]);
// jµ½iÊÇR£¬i - j + 1 <= L => j >= i - L + 1
// i - j + 1ÊÇÆæÊý£¬i - jÊÇżÊý£¬iºÍjÆæżÐÔÏàµÈ
j = max(1, i - L + 1);
if (j <= i) {
F[i] = Sub(Pre[i][i & 1], Pre[j - 1][i & 1]);
if (have)
upd(F[i], Sub(Pre[i][(i & 1) ^ 1], Pre[j - 1][(i & 1) ^ 1]));
}
}
}
int main() {
scanf("%d%d", &N, &M);
scanf("%s", S + 1);
bool haveB = false;
if (S[1] == 'B')
for (int i = 1; i <= M; ++i)
S[i] = 'R' + 'B' - S[i];
for (int i = 1; i <= M; ++i)
haveB |= (S[i] == 'B');
L = N;
for (int i = 1, length = 0, stop = 0; i <= M; ++i)
if (S[i] == 'B')
length = 0, stop = 1;
else {
++length;
if (i + 1 <= M && S[i + 1] == 'B')
if (stop == 0)
if (length & 1)
L = min(L, length);
else
L = min(L, length + 1);
else if (length & 1)
L = min(L, length);
}
dp(!haveB);
upd(Ans, F[N - 1]); // edge(1, 2) = B
for (int x = 1, val; x <= L && x < N; ++x) // edge(1, 2) = R
{
if (haveB && ((x & 1) == 0))
continue;
if (x + 1 == N)
val = 1;
else
val = F[N - x - 2];
upd(Ans, Mult(x, val));
}
if (haveB == false)
upd(Ans, 1);
printf("%d", Ans);
return 0;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 874,428 | 874,429 | u710399266 | cpp |
p03057 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int mod = 1e9 + 7;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-')
ch = getchar();
if (ch == '-')
o = -1, ch = getchar();
while (isdigit(ch))
x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
void inc(int &a, int b) { a = a + b >= mod ? a + b - mod : a + b; }
int n, m, f[N];
char s[N];
int main() {
cin >> n >> m;
scanf("%s", s + 1);
int p = n + 1;
for (int i = 2; i <= n; i++)
if (s[1] != s[i]) {
p = i;
break;
}
if (p == n + 1) {
f[0] = 1;
for (int i = 2, s = 1; i <= n; i++) {
f[i] = s;
inc(s, f[i - 1]);
}
int ans = 1;
for (int i = 2; i <= n; i++)
ans = (ans + 1ll * i * f[n - i]) % mod;
cout << ans;
} else {
--p;
int mx = p + !(p & 1), len = 0;
for (int i = p + 1; i <= n; i++) {
if (s[i] == s[1])
++len;
else {
if (len & 1)
mx = min(mx, len);
len = 0;
}
}
++mx;
f[0] = 1;
for (int i = 2, s = 1; i <= n; i += 2) {
f[i] = s;
if (i >= mx)
inc(s, mod - f[i - mx]);
inc(s, f[i]);
// cerr<<i<<' '<<f[i]<<endl;
}
int ans = 0;
for (int i = 2; i <= mx; i += 2)
ans = (ans + 1ll * i * f[n - i]) % mod;
cout << ans;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int mod = 1e9 + 7;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-')
ch = getchar();
if (ch == '-')
o = -1, ch = getchar();
while (isdigit(ch))
x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
void inc(int &a, int b) { a = a + b >= mod ? a + b - mod : a + b; }
int n, m, f[N];
char s[N];
int main() {
cin >> n >> m;
scanf("%s", s + 1);
int p = m + 1;
for (int i = 2; i <= m; i++)
if (s[1] != s[i]) {
p = i;
break;
}
if (p == m + 1) {
f[0] = 1;
for (int i = 2, s = 1; i <= n; i++) {
f[i] = s;
inc(s, f[i - 1]);
}
int ans = 1;
for (int i = 2; i <= n; i++)
ans = (ans + 1ll * i * f[n - i]) % mod;
cout << ans;
} else {
--p;
int mx = p + !(p & 1), len = 0;
for (int i = p + 1; i <= m; i++) {
if (s[i] == s[1])
++len;
else {
if (len & 1)
mx = min(mx, len);
len = 0;
}
}
++mx;
f[0] = 1;
for (int i = 2, s = 1; i <= n; i += 2) {
f[i] = s;
if (i >= mx)
inc(s, mod - f[i - mx]);
inc(s, f[i]);
// cerr<<i<<' '<<f[i]<<endl;
}
int ans = 0;
for (int i = 2; i <= mx; i += 2)
ans = (ans + 1ll * i * f[n - i]) % mod;
cout << ans;
}
return 0;
}
| [
"identifier.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"control_flow.branch.if.condition.change"
] | 874,430 | 874,431 | u030892114 | cpp |
p03057 | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long ll;
const ll N = 2e5 + 10, mo = 1e9 + 7;
ll f[N], n, m, lim, q[N];
char s[N];
void move(ll &a, ll b) { a = (a + b) % mo; }
int main() {
cin >> n >> m;
scanf("%s", s + 1);
if (s[1] == 'B') {
for (ll i = 1; i <= m; i++)
s[i] = 'B' + 'R' - s[i];
}
ll cnt = 0;
for (ll i = 1; i <= m; i++) {
if (s[i] == 'R')
cnt++;
else {
if (!lim)
lim = cnt | 1;
else if (cnt & 1)
lim = min(lim, cnt);
cnt = 0;
}
}
if (!lim) {
for (int i = 1; i <= n; i++) {
move(f[i], s[i - 2] + i - (i == 1));
s[i] = (s[i - 1] + f[i]) % mo;
}
cout << f[n] + 1 << endl;
return 0;
}
lim++;
for (ll i = 1; i <= n; i++) {
f[i] = q[i - 2];
if (i <= lim && (i % 2 == 0))
move(f[i], i);
q[i] = ((ll)q[i - 2] + f[i] - (i > lim ? f[i - lim] : 0) + mo) % mo;
}
cout << f[n] << endl;
} | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
typedef long long ll;
const ll N = 2e5 + 10, mo = 1e9 + 7;
ll f[N], n, m, lim, q[N];
char s[N];
void move(ll &a, ll b) { a = (a + b) % mo; }
int main() {
cin >> n >> m;
scanf("%s", s + 1);
if (s[1] == 'B') {
for (ll i = 1; i <= m; i++)
s[i] = 'B' + 'R' - s[i];
}
ll cnt = 0;
for (ll i = 1; i <= m; i++) {
if (s[i] == 'R')
cnt++;
else {
if (!lim)
lim = cnt | 1;
else if (cnt & 1)
lim = min(lim, cnt);
cnt = 0;
}
}
if (!lim) {
for (int i = 1; i <= n; i++) {
move(f[i], q[i - 2] + i - (i == 1));
q[i] = (q[i - 1] + f[i]) % mo;
}
cout << f[n] + 1 << endl;
return 0;
}
lim++;
for (ll i = 1; i <= n; i++) {
f[i] = q[i - 2];
if (i <= lim && (i % 2 == 0))
move(f[i], i);
q[i] = ((ll)q[i - 2] + f[i] - (i > lim ? f[i - lim] : 0) + mo) % mo;
}
cout << f[n] << endl;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.variable.change",
"assignment.value.change"
] | 874,434 | 874,435 | u493993074 | cpp |
p03057 | #include <bits/stdc++.h>
using namespace std;
const int P = 1000000007;
int n, m, dp[200005], sum[2][200005];
char s[200005];
int main() {
scanf("%d%d%s", &n, &m, s + 1);
if (count(s + 1, s + 1 + m, s[1]) == m) {
if (n == 1)
return puts("1"), 0;
int ans = 0;
for (int c = 0; c < 2; ++c) {
int dp[2] = {};
dp[c] = 1;
for (int i = 2; i <= n; ++i) {
int t = dp[1];
dp[1] = dp[0];
dp[0] = (dp[0] + t) % P;
}
ans = (ans + dp[0]) % P;
if (!c)
ans = (ans + dp[1]) % P;
}
printf("%d\n", ans);
return 0;
}
int lim = n - 1;
for (int i = 1, j; i <= m; i = j) {
for (j = i; j <= m && s[j] == s[i]; ++j)
;
if (s[i] == s[1])
continue;
if (j - i & 1)
lim = min(lim, j - i);
else if (i == 1)
lim = min(lim, j - i + 1);
}
dp[0] = 1;
sum[0][0] = sum[0][1] = 1;
sum[1][0] = sum[1][1] = 0;
for (int i = 2; i <= n; ++i) {
int d = max(0, i - lim - 1);
dp[i] = (sum[i & 1][i - 2] - (d == 0 ? 0 : sum[i & 1][d - 1])) % P;
sum[0][i] = sum[0][i - 1];
sum[1][i] = sum[1][i - 1];
sum[i & 1][i] = (sum[i & 1][i] + dp[i]) % P;
}
long long ans = 0;
for (int i = 0; i <= lim; ++i)
ans += sum[n & 1][n - (i + 1)] -
(n == lim + 1 ? 0 : sum[n & 1][n - (lim + 1) - 1]);
printf("%lld\n", (ans % P + P) % P);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int P = 1000000007;
int n, m, dp[200005], sum[2][200005];
char s[200005];
int main() {
scanf("%d%d%s", &n, &m, s + 1);
if (count(s + 1, s + 1 + m, s[1]) == m) {
if (n == 1)
return puts("1"), 0;
int ans = 0;
for (int c = 0; c < 2; ++c) {
int dp[2] = {};
dp[c] = 1;
for (int i = 2; i <= n; ++i) {
int t = dp[1];
dp[1] = dp[0];
dp[0] = (dp[0] + t) % P;
}
ans = (ans + dp[0]) % P;
if (!c)
ans = (ans + dp[1]) % P;
}
printf("%d\n", ans);
return 0;
}
int lim = n - 1;
for (int i = 1, j; i <= m; i = j) {
for (j = i; j <= m && s[j] == s[i]; ++j)
;
if (j > m || s[i] != s[1])
continue;
if (j - i & 1)
lim = min(lim, j - i);
else if (i == 1)
lim = min(lim, j - i + 1);
}
dp[0] = 1;
sum[0][0] = sum[0][1] = 1;
sum[1][0] = sum[1][1] = 0;
for (int i = 2; i <= n; ++i) {
int d = max(0, i - lim - 1);
dp[i] = (sum[i & 1][i - 2] - (d == 0 ? 0 : sum[i & 1][d - 1])) % P;
sum[0][i] = sum[0][i - 1];
sum[1][i] = sum[1][i - 1];
sum[i & 1][i] = (sum[i & 1][i] + dp[i]) % P;
}
long long ans = 0;
for (int i = 0; i <= lim; ++i)
ans += sum[n & 1][n - (i + 1)] -
(n == lim + 1 ? 0 : sum[n & 1][n - (lim + 1) - 1]);
printf("%lld\n", (ans % P + P) % P);
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.opposites",
"expression.operator.compare.change"
] | 874,436 | 874,437 | u760178976 | cpp |
p03057 | #include <bits/stdc++.h>
using namespace std;
const int N = 200100, mod = 1000000007;
typedef long long ll;
int f[N], sum[N], n, m;
char s[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> (s + 1);
int mn = max(n, m) + 1, sz = 0, flag = 0;
for (int i = 1; i <= m; ++i)
if (s[i] == s[1])
++sz;
else {
if (sz & 1)
mn = min(mn, sz);
else if (sz)
mn = min(mn, sz + 1);
sz = 0;
flag = 1;
}
int L = 0, R = 0;
if (flag) {
if (n & 1) {
cout << 0 << '\n';
return 0;
}
n /= 2;
L = 1;
R = min(n, (mn + 1) / 2);
} else
L = 2, R = n;
f[0] = sum[0] = 1;
for (int i = 1; i <= n; ++i) {
f[i] = sum[i - L];
if (i > R)
f[i] = (f[i] - sum[i - R - 1] + mod) % mod;
sum[i] = (sum[i - 1] + f[i]) % mod;
}
int ans = 0;
for (int i = L; i <= R; ++i)
ans = (ans + (ll)i * f[n - i]) % mod;
if (flag)
ans = ans * 2 % mod;
else
ans = (ans + 1) % mod;
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 200100, mod = 1000000007;
typedef long long ll;
int f[N], sum[N], n, m;
char s[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> (s + 1);
int mn = max(n, m) + 1, sz = 0, flag = 0;
for (int i = 1; i <= m; ++i)
if (s[i] == s[1])
++sz;
else {
if (sz & 1)
mn = min(mn, sz);
else if (sz && !flag)
mn = min(mn, sz + 1);
sz = 0;
flag = 1;
}
int L = 0, R = 0;
if (flag) {
if (n & 1) {
cout << 0 << '\n';
return 0;
}
n /= 2;
L = 1;
R = min(n, (mn + 1) / 2);
} else
L = 2, R = n;
f[0] = sum[0] = 1;
for (int i = 1; i <= n; ++i) {
f[i] = sum[i - L];
if (i > R)
f[i] = (f[i] - sum[i - R - 1] + mod) % mod;
sum[i] = (sum[i - 1] + f[i]) % mod;
}
int ans = 0;
for (int i = L; i <= R; ++i)
ans = (ans + (ll)i * f[n - i]) % mod;
if (flag)
ans = ans * 2 % mod;
else
ans = (ans + 1) % mod;
cout << ans << '\n';
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 874,440 | 874,441 | u922461964 | cpp |
p03057 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define N (200010)
#define P (1000000007)
#define M ()
#define inf (0x7f7f7f7f)
#define rg register int
#define Label puts("NAIVE")
#define spa print(' ')
#define ent print('\n')
#define rand() (((rand()) << (15)) ^ (rand()))
#define file(s) freopen(s ".in", "r", stdin), freopen(s ".out", "w", stdout)
typedef long double ld;
typedef long long LL;
typedef unsigned long long ull;
using namespace std;
namespace fastIO1 {
inline char read() {
static const int IN_LEN = 1000000;
static char buf[IN_LEN], *s, *t;
return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin),
(s == t ? -1 : *s++) : *s++);
}
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = read(); !isdigit(c); c = read()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = read())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
inline char readc(char &c) {
for (c = read(); !isalpha(c) && !isdigit(c); c = read())
if (c == -1)
return 0;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
if (ooh == obuf + OUT_LEN)
fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
*ooh++ = c;
}
template <class T> inline void print(T x) {
static int buf[30], cnt;
if (x == 0)
print('0');
else {
if (x < 0)
print('-'), x = -x;
for (cnt = 0; x; x /= 10)
buf[++cnt] = x % 10 + 48;
while (cnt)
print((char)buf[cnt--]);
}
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
} // namespace fastIO1
namespace fastIO2 {
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = getchar(); !isdigit(c); c = getchar()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = getchar())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
} // namespace fastIO2
using namespace fastIO1;
int n, m, f[N];
char s[N];
void spj() {
int f[N][2];
for (int i = 1; i <= n; i++)
if (s[i] == 'R')
return;
int ans = 0;
f[1][0] = 0, f[1][1] = 1;
for (int i = 2; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += (f[n][0] + f[n][1]) % P) %= P;
f[1][0] = 1, f[1][1] = 0, f[2][0] = 0, f[2][1] = 1;
for (int i = 3; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += f[n][1]) %= P;
printf("%d\n", ans);
exit(0);
}
int main() {
read(n), read(m);
for (int i = 1; i <= m; i++)
readc(s[i]);
if (s[1] == 'R') {
for (int i = 1; i <= m; i++)
s[i] ^= 'R' ^ 'B';
}
spj();
int lst = m, lim = n, cnt = 0;
while (s[lst] == 'B')
lst--;
for (int i = lst; ~i; i--)
if (!i || s[i] == 'R') {
if (cnt & 1)
lim = min(lim, cnt + 1);
else if ((!i) && cnt)
lim = min(lim, cnt + 2);
cnt = 0;
} else
cnt++;
f[0] = f[2] = 1;
for (int i = 4; i <= n; i++) {
f[i] = 1ll * f[i - 2] * 2 % P;
if (i - 2 >= lim)
f[i] = (f[i] - f[i - lim - 2] + P) % P;
}
int ans = 0;
for (int i = 2; i <= lim; i += 2)
(ans += 1ll * f[n - i] * i % P) %= P;
cout << ans;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define N (200010)
#define P (1000000007)
#define M ()
#define inf (0x7f7f7f7f)
#define rg register int
#define Label puts("NAIVE")
#define spa print(' ')
#define ent print('\n')
#define rand() (((rand()) << (15)) ^ (rand()))
#define file(s) freopen(s ".in", "r", stdin), freopen(s ".out", "w", stdout)
typedef long double ld;
typedef long long LL;
typedef unsigned long long ull;
using namespace std;
namespace fastIO1 {
inline char read() {
static const int IN_LEN = 1000000;
static char buf[IN_LEN], *s, *t;
return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin),
(s == t ? -1 : *s++) : *s++);
}
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = read(); !isdigit(c); c = read()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = read())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
inline char readc(char &c) {
for (c = read(); !isalpha(c) && !isdigit(c); c = read())
if (c == -1)
return 0;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
if (ooh == obuf + OUT_LEN)
fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
*ooh++ = c;
}
template <class T> inline void print(T x) {
static int buf[30], cnt;
if (x == 0)
print('0');
else {
if (x < 0)
print('-'), x = -x;
for (cnt = 0; x; x /= 10)
buf[++cnt] = x % 10 + 48;
while (cnt)
print((char)buf[cnt--]);
}
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
} // namespace fastIO1
namespace fastIO2 {
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = getchar(); !isdigit(c); c = getchar()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = getchar())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
} // namespace fastIO2
using namespace fastIO1;
int n, m, f[N];
char s[N];
void spj() {
int f[N][2];
for (int i = 1; i <= m; i++)
if (s[i] == 'R')
return;
int ans = 0;
f[1][0] = 0, f[1][1] = 1;
for (int i = 2; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += (f[n][0] + f[n][1]) % P) %= P;
f[1][0] = 1, f[1][1] = 0, f[2][0] = 0, f[2][1] = 1;
for (int i = 3; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += f[n][1]) %= P;
printf("%d\n", ans);
exit(0);
}
int main() {
read(n), read(m);
for (int i = 1; i <= m; i++)
readc(s[i]);
if (s[1] == 'R') {
for (int i = 1; i <= m; i++)
s[i] ^= 'R' ^ 'B';
}
spj();
int lst = m, lim = n, cnt = 0;
while (s[lst] == 'B')
lst--;
for (int i = lst; ~i; i--)
if (!i || s[i] == 'R') {
if (cnt & 1)
lim = min(lim, cnt + 1);
else if ((!i) && cnt)
lim = min(lim, cnt + 2);
cnt = 0;
} else
cnt++;
// cout<<lim<<endl;
f[0] = f[2] = 1;
for (int i = 4; i <= n; i += 2) {
f[i] = 1ll * f[i - 2] * 2 % P;
if (i - 2 >= lim)
f[i] = (f[i] - f[i - lim - 2] + P) % P;
}
int ans = 0;
for (int i = 2; i <= lim; i += 2)
(ans += 1ll * f[n - i] * i % P) %= P;
cout << ans;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 874,442 | 874,443 | u293624543 | cpp |
p03057 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define N (200010)
#define P (1000000007)
#define M ()
#define inf (0x7f7f7f7f)
#define rg register int
#define Label puts("NAIVE")
#define spa print(' ')
#define ent print('\n')
#define rand() (((rand()) << (15)) ^ (rand()))
#define file(s) freopen(s ".in", "r", stdin), freopen(s ".out", "w", stdout)
typedef long double ld;
typedef long long LL;
typedef unsigned long long ull;
using namespace std;
namespace fastIO1 {
inline char read() {
static const int IN_LEN = 1000000;
static char buf[IN_LEN], *s, *t;
return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin),
(s == t ? -1 : *s++) : *s++);
}
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = read(); !isdigit(c); c = read()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = read())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
inline char readc(char &c) {
for (c = read(); !isalpha(c) && !isdigit(c); c = read())
if (c == -1)
return 0;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
if (ooh == obuf + OUT_LEN)
fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
*ooh++ = c;
}
template <class T> inline void print(T x) {
static int buf[30], cnt;
if (x == 0)
print('0');
else {
if (x < 0)
print('-'), x = -x;
for (cnt = 0; x; x /= 10)
buf[++cnt] = x % 10 + 48;
while (cnt)
print((char)buf[cnt--]);
}
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
} // namespace fastIO1
namespace fastIO2 {
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = getchar(); !isdigit(c); c = getchar()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = getchar())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
} // namespace fastIO2
using namespace fastIO1;
int n, m, f[N];
char s[N];
void spj() {
int f[N][2];
for (int i = 1; i <= n; i++)
if (s[i] == 'R')
return;
int ans = 0;
f[1][0] = 0, f[1][1] = 1;
for (int i = 2; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += (f[n][0] + f[n][1]) % P) %= P;
f[1][0] = 1, f[1][1] = 0, f[2][0] = 0, f[2][1] = 1;
for (int i = 3; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += f[n][1]) %= P;
printf("%d\n", ans);
exit(0);
}
int main() {
read(n), read(m);
for (int i = 1; i <= m; i++)
readc(s[i]);
if (s[0] == 'R') {
for (int i = 1; i <= m; i++)
s[i] ^= 'R' ^ 'B';
}
spj();
int lst = m, lim = n, cnt = 0;
while (s[lst] == 'B')
lst--;
for (int i = lst; ~i; i--)
if (!i || s[i] == 'R') {
if (cnt & 1)
lim = min(lim, cnt + 1);
else if ((!i) && cnt)
lim = min(lim, cnt + 2);
cnt = 0;
} else
cnt++;
f[0] = f[2] = 1;
for (int i = 4; i <= n; i++) {
f[i] = 1ll * f[i - 2] * 2 % P;
if (i - 2 >= lim)
f[i] = (f[i] - f[i - lim - 2] + P) % P;
}
int ans = 0;
for (int i = 2; i <= lim; i += 2)
(ans += 1ll * f[n - i] * i % P) %= P;
cout << ans;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define N (200010)
#define P (1000000007)
#define M ()
#define inf (0x7f7f7f7f)
#define rg register int
#define Label puts("NAIVE")
#define spa print(' ')
#define ent print('\n')
#define rand() (((rand()) << (15)) ^ (rand()))
#define file(s) freopen(s ".in", "r", stdin), freopen(s ".out", "w", stdout)
typedef long double ld;
typedef long long LL;
typedef unsigned long long ull;
using namespace std;
namespace fastIO1 {
inline char read() {
static const int IN_LEN = 1000000;
static char buf[IN_LEN], *s, *t;
return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin),
(s == t ? -1 : *s++) : *s++);
}
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = read(); !isdigit(c); c = read()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = read())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
inline char readc(char &c) {
for (c = read(); !isalpha(c) && !isdigit(c); c = read())
if (c == -1)
return 0;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
if (ooh == obuf + OUT_LEN)
fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
*ooh++ = c;
}
template <class T> inline void print(T x) {
static int buf[30], cnt;
if (x == 0)
print('0');
else {
if (x < 0)
print('-'), x = -x;
for (cnt = 0; x; x /= 10)
buf[++cnt] = x % 10 + 48;
while (cnt)
print((char)buf[cnt--]);
}
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
} // namespace fastIO1
namespace fastIO2 {
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = getchar(); !isdigit(c); c = getchar()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = getchar())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
} // namespace fastIO2
using namespace fastIO1;
int n, m, f[N];
char s[N];
void spj() {
int f[N][2];
for (int i = 1; i <= m; i++)
if (s[i] == 'R')
return;
int ans = 0;
f[1][0] = 0, f[1][1] = 1;
for (int i = 2; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += (f[n][0] + f[n][1]) % P) %= P;
f[1][0] = 1, f[1][1] = 0, f[2][0] = 0, f[2][1] = 1;
for (int i = 3; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += f[n][1]) %= P;
printf("%d\n", ans);
exit(0);
}
int main() {
read(n), read(m);
for (int i = 1; i <= m; i++)
readc(s[i]);
if (s[1] == 'R') {
for (int i = 1; i <= m; i++)
s[i] ^= 'R' ^ 'B';
}
spj();
int lst = m, lim = n, cnt = 0;
while (s[lst] == 'B')
lst--;
for (int i = lst; ~i; i--)
if (!i || s[i] == 'R') {
if (cnt & 1)
lim = min(lim, cnt + 1);
else if ((!i) && cnt)
lim = min(lim, cnt + 2);
cnt = 0;
} else
cnt++;
// cout<<lim<<endl;
f[0] = f[2] = 1;
for (int i = 4; i <= n; i += 2) {
f[i] = 1ll * f[i - 2] * 2 % P;
if (i - 2 >= lim)
f[i] = (f[i] - f[i - lim - 2] + P) % P;
}
int ans = 0;
for (int i = 2; i <= lim; i += 2)
(ans += 1ll * f[n - i] * i % P) %= P;
cout << ans;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 874,444 | 874,443 | u293624543 | cpp |
p03057 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define N (200010)
#define P (1000000007)
#define M ()
#define inf (0x7f7f7f7f)
#define rg register int
#define Label puts("NAIVE")
#define spa print(' ')
#define ent print('\n')
#define rand() (((rand()) << (15)) ^ (rand()))
#define file(s) freopen(s ".in", "r", stdin), freopen(s ".out", "w", stdout)
typedef long double ld;
typedef long long LL;
typedef unsigned long long ull;
using namespace std;
namespace fastIO1 {
inline char read() {
static const int IN_LEN = 1000000;
static char buf[IN_LEN], *s, *t;
return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin),
(s == t ? -1 : *s++) : *s++);
}
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = read(); !isdigit(c); c = read()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = read())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
inline char readc(char &c) {
for (c = read(); !isalpha(c) && !isdigit(c); c = read())
if (c == -1)
return 0;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
if (ooh == obuf + OUT_LEN)
fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
*ooh++ = c;
}
template <class T> inline void print(T x) {
static int buf[30], cnt;
if (x == 0)
print('0');
else {
if (x < 0)
print('-'), x = -x;
for (cnt = 0; x; x /= 10)
buf[++cnt] = x % 10 + 48;
while (cnt)
print((char)buf[cnt--]);
}
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
} // namespace fastIO1
namespace fastIO2 {
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = getchar(); !isdigit(c); c = getchar()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = getchar())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
} // namespace fastIO2
using namespace fastIO1;
int n, m, f[N];
char s[N];
void spj() {
int f[N][2];
for (int i = 1; i <= n; i++)
if (s[i] == 'R')
return;
int ans = 0;
f[1][0] = 0, f[1][1] = 1;
for (int i = 2; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += (f[n][0] + f[n][1]) % P) %= P;
f[1][0] = 1, f[1][1] = 0, f[2][0] = 0, f[2][1] = 1;
for (int i = 3; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += f[n][1]) %= P;
printf("%d\n", ans);
exit(0);
}
int main() {
read(n), read(m);
for (int i = 1; i <= m; i++)
readc(s[i]);
if (s[0] == 'R') {
for (int i = 1; i <= m; i++)
s[i] ^= 'R' ^ 'B';
}
spj();
int lst = m, lim = n, cnt = 0;
while (s[lst] == 'B')
lst--;
for (int i = lst; ~i; i--)
if (!i || s[i] == 'B') {
if (cnt & 1)
lim = min(lim, cnt + 1);
else if ((!i) && cnt)
lim = min(lim, cnt + 2);
cnt = 0;
} else
cnt++;
f[0] = f[2] = 1;
for (int i = 4; i <= n; i++) {
f[i] = 1ll * f[i - 2] * 2 % P;
if (i - 2 >= lim)
f[i] = (f[i] - f[i - lim - 2] + P) % P;
}
int ans = 0;
for (int i = 2; i <= lim; i += 2)
(ans += 1ll * f[n - i] * i % P) %= P;
cout << ans;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define N (200010)
#define P (1000000007)
#define M ()
#define inf (0x7f7f7f7f)
#define rg register int
#define Label puts("NAIVE")
#define spa print(' ')
#define ent print('\n')
#define rand() (((rand()) << (15)) ^ (rand()))
#define file(s) freopen(s ".in", "r", stdin), freopen(s ".out", "w", stdout)
typedef long double ld;
typedef long long LL;
typedef unsigned long long ull;
using namespace std;
namespace fastIO1 {
inline char read() {
static const int IN_LEN = 1000000;
static char buf[IN_LEN], *s, *t;
return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin),
(s == t ? -1 : *s++) : *s++);
}
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = read(); !isdigit(c); c = read()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = read())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
inline char readc(char &c) {
for (c = read(); !isalpha(c) && !isdigit(c); c = read())
if (c == -1)
return 0;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
if (ooh == obuf + OUT_LEN)
fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
*ooh++ = c;
}
template <class T> inline void print(T x) {
static int buf[30], cnt;
if (x == 0)
print('0');
else {
if (x < 0)
print('-'), x = -x;
for (cnt = 0; x; x /= 10)
buf[++cnt] = x % 10 + 48;
while (cnt)
print((char)buf[cnt--]);
}
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
} // namespace fastIO1
namespace fastIO2 {
template <class T> inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = getchar(); !isdigit(c); c = getchar()) {
if (c == '-')
iosig = true;
if (c == -1)
return;
}
for (x = 0; isdigit(c); c = getchar())
x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig)
x = -x;
}
} // namespace fastIO2
using namespace fastIO1;
int n, m, f[N];
char s[N];
void spj() {
int f[N][2];
for (int i = 1; i <= m; i++)
if (s[i] == 'R')
return;
int ans = 0;
f[1][0] = 0, f[1][1] = 1;
for (int i = 2; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += (f[n][0] + f[n][1]) % P) %= P;
f[1][0] = 1, f[1][1] = 0, f[2][0] = 0, f[2][1] = 1;
for (int i = 3; i <= n; i++) {
f[i][0] = f[i - 1][1];
f[i][1] = (f[i - 1][0] + f[i - 1][1]) % P;
}
(ans += f[n][1]) %= P;
printf("%d\n", ans);
exit(0);
}
int main() {
read(n), read(m);
for (int i = 1; i <= m; i++)
readc(s[i]);
if (s[1] == 'R') {
for (int i = 1; i <= m; i++)
s[i] ^= 'R' ^ 'B';
}
spj();
int lst = m, lim = n, cnt = 0;
while (s[lst] == 'B')
lst--;
for (int i = lst; ~i; i--)
if (!i || s[i] == 'R') {
if (cnt & 1)
lim = min(lim, cnt + 1);
else if ((!i) && cnt)
lim = min(lim, cnt + 2);
cnt = 0;
} else
cnt++;
// cout<<lim<<endl;
f[0] = f[2] = 1;
for (int i = 4; i <= n; i += 2) {
f[i] = 1ll * f[i - 2] * 2 % P;
if (i - 2 >= lim)
f[i] = (f[i] - f[i - lim - 2] + P) % P;
}
int ans = 0;
for (int i = 2; i <= lim; i += 2)
(ans += 1ll * f[n - i] * i % P) %= P;
cout << ans;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"literal.string.change"
] | 874,445 | 874,443 | u293624543 | cpp |
p03057 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
#define FILL(a, n, x) memset((a), (x), sizeof((a)[0]) * (n))
#define COPY(a, n, b) memcpy((b), (a), sizeof((a)[0]) * (n))
using namespace std;
typedef long long li;
const int mod = 1e9 + 7;
inline int Add(int x) { return x >= mod ? x - mod : x; }
inline void Add(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
}
inline int Sub(int x) { return x < 0 ? x + mod : x; }
inline void Sub(int &x, int y) {
x -= y;
if (x < 0)
x += mod;
}
inline int Mul(int x, int y) { return (li)x * y % mod; }
// ----------------------------------------
const int maxn = 2e5;
int n, m, lim;
char s[maxn + 1];
int dp[maxn + 1];
int sum[maxn + 2];
void GetLim(void) {
int cnt = 0;
for (int i = 0; i < m; ++i) {
if (s[i] == 'R')
++cnt;
else
break;
}
if (cnt & 1)
lim = cnt;
else
lim = cnt + 1;
cnt = 0;
for (int i = 0; i < m; ++i) {
if (s[i] == 'R')
++cnt;
else {
if (cnt & 1)
lim = max(lim, cnt);
cnt = 0;
}
}
}
void SolveSame(void) {
static int dp[maxn + 1][2][2];
dp[0][0][0] = dp[0][1][1] = 1;
for (int i = 1; i < n; ++i) {
for (int x = 0; x <= 1; ++x) {
for (int y = 0; y <= 1; ++y) {
for (int z = 0; z <= 1; ++z) {
if (y != 1 || z != 1) {
Add(dp[i][x][z], dp[i - 1][x][y]);
}
}
}
}
}
int ans = Add(Add(dp[n - 1][0][0] + dp[n - 1][0][1]) + dp[n - 1][1][0]);
printf("%d\n", ans);
}
int main(void) {
scanf("%d%d%s", &n, &m, s);
if (s[0] == 'B') {
for (int i = 0; i < m; ++i) {
s[i] ^= 'R' ^ 'B';
}
}
if (count(s, s + m, 'R') == m) {
// the same
SolveSame();
return 0;
}
GetLim();
lim = lim + 1 >> 1;
if (n & 1) {
puts("0");
return 0;
}
n /= 2;
for (int i = 1; i <= lim; ++i) {
Add(dp[i], 2 * i);
}
for (int i = 1; i <= n; ++i) {
// printf("this is %d\n", i);
// calc dp[i]
int L = max(1, i - lim), R = i;
Add(dp[i], Sub(sum[R] - sum[L]));
sum[i + 1] = Add(sum[i] + dp[i]);
}
printf("%d\n", dp[n]);
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
#define FILL(a, n, x) memset((a), (x), sizeof((a)[0]) * (n))
#define COPY(a, n, b) memcpy((b), (a), sizeof((a)[0]) * (n))
using namespace std;
typedef long long li;
const int mod = 1e9 + 7;
inline int Add(int x) { return x >= mod ? x - mod : x; }
inline void Add(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
}
inline int Sub(int x) { return x < 0 ? x + mod : x; }
inline void Sub(int &x, int y) {
x -= y;
if (x < 0)
x += mod;
}
inline int Mul(int x, int y) { return (li)x * y % mod; }
// ----------------------------------------
const int maxn = 2e5;
int n, m, lim;
char s[maxn + 1];
int dp[maxn + 1];
int sum[maxn + 2];
void GetLim(void) {
int cnt = 0;
for (int i = 0; i < m; ++i) {
if (s[i] == 'R')
++cnt;
else
break;
}
if (cnt & 1)
lim = cnt;
else
lim = cnt + 1;
cnt = 0;
for (int i = 0; i < m; ++i) {
if (s[i] == 'R')
++cnt;
else {
if (cnt & 1)
lim = min(lim, cnt);
cnt = 0;
}
}
}
void SolveSame(void) {
static int dp[maxn + 1][2][2];
dp[0][0][0] = dp[0][1][1] = 1;
for (int i = 1; i < n; ++i) {
for (int x = 0; x <= 1; ++x) {
for (int y = 0; y <= 1; ++y) {
for (int z = 0; z <= 1; ++z) {
if (y != 1 || z != 1) {
Add(dp[i][x][z], dp[i - 1][x][y]);
}
}
}
}
}
int ans = Add(Add(dp[n - 1][0][0] + dp[n - 1][0][1]) + dp[n - 1][1][0]);
printf("%d\n", ans);
}
int main(void) {
scanf("%d%d%s", &n, &m, s);
if (s[0] == 'B') {
for (int i = 0; i < m; ++i) {
s[i] ^= 'R' ^ 'B';
}
}
if (count(s, s + m, 'R') == m) {
// the same
SolveSame();
return 0;
}
GetLim();
lim = lim + 1 >> 1;
if (n & 1) {
puts("0");
return 0;
}
n /= 2;
for (int i = 1; i <= lim; ++i) {
Add(dp[i], 2 * i);
}
for (int i = 1; i <= n; ++i) {
// printf("this is %d\n", i);
// calc dp[i]
int L = max(1, i - lim), R = i;
Add(dp[i], Sub(sum[R] - sum[L]));
sum[i + 1] = Add(sum[i] + dp[i]);
}
printf("%d\n", dp[n]);
return 0;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change"
] | 874,446 | 874,447 | u264510475 | cpp |
p03057 | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
#define FILL(a, n, x) memset((a), (x), sizeof((a)[0]) * (n))
#define COPY(a, n, b) memcpy((b), (a), sizeof((a)[0]) * (n))
using namespace std;
typedef long long li;
const int mod = 1e9 + 7;
inline int Add(int x) { return x >= mod ? x - mod : x; }
inline void Add(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
}
inline int Sub(int x) { return x < 0 ? x + mod : x; }
inline void Sub(int &x, int y) {
x -= y;
if (x < 0)
x += mod;
}
inline int Mul(int x, int y) { return (li)x * y % mod; }
// ----------------------------------------
const int maxn = 2e5;
int n, m, lim;
char s[maxn + 1];
int dp[maxn + 1];
int sum[maxn + 2];
void GetLim(void) {
int cnt = 0;
for (int i = 0; i < m; ++i) {
if (s[i] == 'R')
++cnt;
else
break;
}
if (cnt & 1)
lim = cnt;
else
lim = cnt + 1;
cnt = 0;
for (int i = 0; i < m; ++i) {
if (s[i] == 'R')
++cnt;
else {
if (cnt & 1)
lim = max(lim, cnt);
cnt = 0;
}
}
}
void SolveSame(void) {
static int dp[maxn + 1][2][2];
dp[0][0][0] = dp[0][1][1] = 1;
for (int i = 1; i < n; ++i) {
for (int x = 0; x <= 1; ++x) {
for (int y = 0; y <= 1; ++y) {
for (int z = 0; z <= 1; ++z) {
if (y != 1 || z != 1) {
Add(dp[i][x][z], dp[i - 1][x][y]);
}
}
}
}
}
int ans = Add(Add(dp[n - 1][0][0] + dp[n - 1][0][1]) + dp[n - 1][1][0]);
printf("%d\n", ans);
}
int main(void) {
scanf("%d%d%s", &n, &m, s);
if (s[0] == 'B') {
for (int i = 0; i < m; ++i) {
s[i] ^= 'R' ^ 'B';
}
}
if (count(s, s + m, 'R') == m) {
// the same
SolveSame();
return 0;
}
GetLim();
lim = lim + 1 >> 1;
if (n & 1) {
puts("0");
return 0;
}
n /= 2;
for (int i = 1; i <= lim; ++i) {
Add(dp[i], 2 * i);
}
for (int i = 1; i <= n; ++i) {
// calc dp[i]
int L = max(1, i - lim), R = i;
Add(dp[i], sum[R] - sum[L]);
sum[i + 1] = Add(sum[i] + dp[i]);
}
printf("%d\n", dp[n]);
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
#define FILL(a, n, x) memset((a), (x), sizeof((a)[0]) * (n))
#define COPY(a, n, b) memcpy((b), (a), sizeof((a)[0]) * (n))
using namespace std;
typedef long long li;
const int mod = 1e9 + 7;
inline int Add(int x) { return x >= mod ? x - mod : x; }
inline void Add(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
}
inline int Sub(int x) { return x < 0 ? x + mod : x; }
inline void Sub(int &x, int y) {
x -= y;
if (x < 0)
x += mod;
}
inline int Mul(int x, int y) { return (li)x * y % mod; }
// ----------------------------------------
const int maxn = 2e5;
int n, m, lim;
char s[maxn + 1];
int dp[maxn + 1];
int sum[maxn + 2];
void GetLim(void) {
int cnt = 0;
for (int i = 0; i < m; ++i) {
if (s[i] == 'R')
++cnt;
else
break;
}
if (cnt & 1)
lim = cnt;
else
lim = cnt + 1;
cnt = 0;
for (int i = 0; i < m; ++i) {
if (s[i] == 'R')
++cnt;
else {
if (cnt & 1)
lim = min(lim, cnt);
cnt = 0;
}
}
}
void SolveSame(void) {
static int dp[maxn + 1][2][2];
dp[0][0][0] = dp[0][1][1] = 1;
for (int i = 1; i < n; ++i) {
for (int x = 0; x <= 1; ++x) {
for (int y = 0; y <= 1; ++y) {
for (int z = 0; z <= 1; ++z) {
if (y != 1 || z != 1) {
Add(dp[i][x][z], dp[i - 1][x][y]);
}
}
}
}
}
int ans = Add(Add(dp[n - 1][0][0] + dp[n - 1][0][1]) + dp[n - 1][1][0]);
printf("%d\n", ans);
}
int main(void) {
scanf("%d%d%s", &n, &m, s);
if (s[0] == 'B') {
for (int i = 0; i < m; ++i) {
s[i] ^= 'R' ^ 'B';
}
}
if (count(s, s + m, 'R') == m) {
// the same
SolveSame();
return 0;
}
GetLim();
lim = lim + 1 >> 1;
if (n & 1) {
puts("0");
return 0;
}
n /= 2;
for (int i = 1; i <= lim; ++i) {
Add(dp[i], 2 * i);
}
for (int i = 1; i <= n; ++i) {
// printf("this is %d\n", i);
// calc dp[i]
int L = max(1, i - lim), R = i;
Add(dp[i], Sub(sum[R] - sum[L]));
sum[i + 1] = Add(sum[i] + dp[i]);
}
printf("%d\n", dp[n]);
return 0;
}
| [
"misc.opposites",
"assignment.value.change",
"identifier.change",
"call.function.change",
"call.add",
"call.arguments.change"
] | 874,448 | 874,447 | u264510475 | cpp |
p03057 | #include <bits/stdc++.h>
#define ll long long
#define mod 998244353
using namespace std;
const int N = 200010;
int n, m, ans, f[N], g[N];
char s[N];
void inc(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
}
void dec(int &x, int y) {
x -= y;
if (x < 0)
x += mod;
}
int main() {
// freopen("E.in","r",stdin);
// freopen("E.out","w",stdout);
scanf("%d%d%s", &n, &m, s + 1);
int p = 0;
while (p < m && s[p + 1] == s[1])
++p;
if (p == m) {
ans = f[0] = g[0] = 1;
for (int i = 0; i <= n; ++i) {
if (i > 1)
f[i] = g[max(i - 2, 0)];
if (i)
g[i] = (g[i - 1] + f[i]) % mod;
if (n - i != 1)
inc(ans, (ll)(n - i) * f[i] % mod);
}
cout << ans << endl;
} else {
if (n & 1)
puts("0"), exit(0);
int L = p | 1;
while (1) {
int tmp = 0;
while (p < m && s[p + 1] != s[1])
++p;
tmp -= p;
while (p < m && s[p + 1] == s[1])
++p;
tmp += p;
if (p == m)
break;
if (tmp & 1)
L = min(L, tmp);
}
f[0] = g[0] = 1;
L = (L + 1) >> 1;
n >>= 1;
for (int i = 0; i <= n; ++i) {
if (i)
f[i] = g[i - 1];
if (i > L)
dec(f[i], g[i - L - 1]);
if (i)
g[i] = (g[i - 1] + f[i]) % mod;
if (n - i <= L)
inc(ans, (ll)(n - i) * f[i] % mod);
}
cout << ans * 2 % mod << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define mod 1000000007
using namespace std;
const int N = 200010;
int n, m, ans, f[N], g[N];
char s[N];
void inc(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
}
void dec(int &x, int y) {
x -= y;
if (x < 0)
x += mod;
}
int main() {
// freopen("E.in","r",stdin);
// freopen("E.out","w",stdout);
scanf("%d%d%s", &n, &m, s + 1);
int p = 0;
while (p < m && s[p + 1] == s[1])
++p;
if (p == m) {
ans = f[0] = g[0] = 1;
for (int i = 0; i <= n; ++i) {
if (i > 1)
f[i] = g[i - 2];
if (i)
g[i] = (g[i - 1] + f[i]) % mod;
if (n - i != 1)
inc(ans, (ll)(n - i) * f[i] % mod);
}
cout << ans << endl;
} else {
if (n & 1)
puts("0"), exit(0);
int L = p | 1;
while (1) {
int tmp = 0;
while (p < m && s[p + 1] != s[1])
++p;
tmp -= p;
while (p < m && s[p + 1] == s[1])
++p;
tmp += p;
if (p == m)
break;
if (tmp & 1)
L = min(L, tmp);
}
f[0] = g[0] = 1;
L = (L + 1) >> 1;
n >>= 1;
for (int i = 0; i <= n; ++i) {
if (i)
f[i] = g[i - 1];
if (i > L)
dec(f[i], g[i - L - 1]);
if (i)
g[i] = (g[i - 1] + f[i]) % mod;
if (n - i <= L)
inc(ans, (ll)(n - i) * f[i] % mod);
}
cout << ans * 2 % mod << endl;
}
return 0;
}
| [
"preprocessor.define.value.change",
"literal.integer.change",
"call.remove",
"call.arguments.change"
] | 874,470 | 874,471 | u323092931 | cpp |
p03057 | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
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;
}
template <typename T, T MOD = 1000000007> struct Mint {
T v;
Mint() : v(0) {}
Mint(signed v) : v(v) {}
Mint(long long t) {
v = t % MOD;
if (v < 0)
v += MOD;
}
Mint pow(long long k) {
Mint res(1), tmp(v);
while (k) {
if (k & 1)
res *= tmp;
tmp *= tmp;
k >>= 1;
}
return res;
}
static Mint add_identity() { return Mint(0); }
static Mint mul_identity() { return Mint(1); }
Mint inv() { return pow(MOD - 2); }
Mint &operator+=(Mint a) {
v += a.v;
if (v >= MOD)
v -= MOD;
return *this;
}
Mint &operator-=(Mint a) {
v += MOD - a.v;
if (v >= MOD)
v -= MOD;
return *this;
}
Mint &operator*=(Mint a) {
v = 1LL * v * a.v % MOD;
return *this;
}
Mint &operator/=(Mint a) { return (*this) *= a.inv(); }
Mint operator+(Mint a) const { return Mint(v) += a; };
Mint operator-(Mint a) const { return Mint(v) -= a; };
Mint operator*(Mint a) const { return Mint(v) *= a; };
Mint operator/(Mint a) const { return Mint(v) /= a; };
Mint operator-() const { return v ? Mint(MOD - v) : Mint(v); }
bool operator==(const Mint a) const { return v == a.v; }
bool operator!=(const Mint a) const { return v != a.v; }
bool operator<(const Mint a) const { return v < a.v; }
// find x s.t. a^x = b
static T log(Mint a, Mint b) {
const T sq = 40000;
unordered_map<T, T> dp;
dp.reserve(sq);
Mint res(1);
for (Int r = 0; r < sq; r++) {
if (!dp.count(res.v))
dp[res.v] = r;
res *= a;
}
Mint p = a.inv().pow(sq);
res = b;
for (Int q = 0; q <= MOD / sq + 1; q++) {
if (dp.count(res.v)) {
T idx = q * sq + dp[res.v];
if (idx > 0)
return idx;
}
res *= p;
}
assert(0);
return T(-1);
}
static Mint comb(long long n, Int k) {
Mint res(1);
for (Int i = 0; i < k; i++) {
res *= Mint(n - i);
res /= Mint(i + 1);
}
return res;
}
};
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_v(U &u, const V... v) {
u = U(v...);
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_v(U &u, const V... v) {
for (auto &e : u)
fill_v<T>(e, v...);
}
// INSERT ABOVE HERE
signed main() {
using M = Mint<Int>;
Int n, m;
cin >> n >> m;
string s;
cin >> s;
vector<Int> vs(m);
for (Int i = 0; i < m; i++)
vs[i] = (s[0] != 'R') ^ (s[i] == 'R');
for (Int i = 0; i < m; i++)
s[i] = "BR"[vs[i]];
if (vs != vector<Int>(m, 1)) {
auto dp = make_v<M>(2, 2, n + 1);
fill_v<M>(dp, M(0));
dp[0][0][1] = M(1);
dp[1][1][1] = M(1);
for (Int i = 1; i < n; i++)
for (Int j = 0; j < 2; j++)
for (Int k = 0; k < 2; k++)
for (Int l = 0; l < 2; l++)
if (k || l)
dp[j][l][i + 1] += dp[j][k][i];
M ans{0};
for (Int j = 0; j < 2; j++)
for (Int k = 0; k < 2; k++)
if (j || k)
ans += dp[j][k][n];
cout << ans.v << endl;
return 0;
}
assert(vs != vector<Int>(m, 0));
if (n & 1) {
cout << 0 << endl;
return 0;
}
Int lim = n - 1;
for (Int i = 0; i < m; i++) {
if (s[i] == 'B')
continue;
Int j = i;
while (j < m && s[j] == 'R')
j++;
if (j == m)
break;
if (i == 0 && (j - i) % 2 == 0)
chmin(lim, j - i + 1);
if ((j - i) & 1)
chmin(lim, j - i);
i = j - 1;
}
vector<M> dp(n + 2, 0), sm(n + 2, 0);
dp[1] = M(1);
for (Int i = 2; i <= n + 1; i++) {
sm[i] = sm[i - 1] + dp[i - 1];
if (i & 1)
dp[i] = sm[i - 1] - sm[max<Int>(1, i - 1 - lim)];
}
M ans{0};
for (Int i = 0; i <= lim; i++)
ans += sm[n - i + 1] - sm[max<Int>(1, n - lim)];
cout << ans.v << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using Int = long long;
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;
}
template <typename T, T MOD = 1000000007> struct Mint {
T v;
Mint() : v(0) {}
Mint(signed v) : v(v) {}
Mint(long long t) {
v = t % MOD;
if (v < 0)
v += MOD;
}
Mint pow(long long k) {
Mint res(1), tmp(v);
while (k) {
if (k & 1)
res *= tmp;
tmp *= tmp;
k >>= 1;
}
return res;
}
static Mint add_identity() { return Mint(0); }
static Mint mul_identity() { return Mint(1); }
Mint inv() { return pow(MOD - 2); }
Mint &operator+=(Mint a) {
v += a.v;
if (v >= MOD)
v -= MOD;
return *this;
}
Mint &operator-=(Mint a) {
v += MOD - a.v;
if (v >= MOD)
v -= MOD;
return *this;
}
Mint &operator*=(Mint a) {
v = 1LL * v * a.v % MOD;
return *this;
}
Mint &operator/=(Mint a) { return (*this) *= a.inv(); }
Mint operator+(Mint a) const { return Mint(v) += a; };
Mint operator-(Mint a) const { return Mint(v) -= a; };
Mint operator*(Mint a) const { return Mint(v) *= a; };
Mint operator/(Mint a) const { return Mint(v) /= a; };
Mint operator-() const { return v ? Mint(MOD - v) : Mint(v); }
bool operator==(const Mint a) const { return v == a.v; }
bool operator!=(const Mint a) const { return v != a.v; }
bool operator<(const Mint a) const { return v < a.v; }
// find x s.t. a^x = b
static T log(Mint a, Mint b) {
const T sq = 40000;
unordered_map<T, T> dp;
dp.reserve(sq);
Mint res(1);
for (Int r = 0; r < sq; r++) {
if (!dp.count(res.v))
dp[res.v] = r;
res *= a;
}
Mint p = a.inv().pow(sq);
res = b;
for (Int q = 0; q <= MOD / sq + 1; q++) {
if (dp.count(res.v)) {
T idx = q * sq + dp[res.v];
if (idx > 0)
return idx;
}
res *= p;
}
assert(0);
return T(-1);
}
static Mint comb(long long n, Int k) {
Mint res(1);
for (Int i = 0; i < k; i++) {
res *= Mint(n - i);
res /= Mint(i + 1);
}
return res;
}
};
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value != 0>::type fill_v(U &u, const V... v) {
u = U(v...);
}
template <typename T, typename U, typename... V>
typename enable_if<is_same<T, U>::value == 0>::type fill_v(U &u, const V... v) {
for (auto &e : u)
fill_v<T>(e, v...);
}
// INSERT ABOVE HERE
signed main() {
using M = Mint<Int>;
Int n, m;
cin >> n >> m;
string s;
cin >> s;
vector<Int> vs(m);
for (Int i = 0; i < m; i++)
vs[i] = (s[0] != 'R') ^ (s[i] == 'R');
for (Int i = 0; i < m; i++)
s[i] = "BR"[vs[i]];
if (vs == vector<Int>(m, 1)) {
auto dp = make_v<M>(2, 2, n + 1);
fill_v<M>(dp, M(0));
dp[0][0][1] = M(1);
dp[1][1][1] = M(1);
for (Int i = 1; i < n; i++)
for (Int j = 0; j < 2; j++)
for (Int k = 0; k < 2; k++)
for (Int l = 0; l < 2; l++)
if (k || l)
dp[j][l][i + 1] += dp[j][k][i];
M ans{0};
for (Int j = 0; j < 2; j++)
for (Int k = 0; k < 2; k++)
if (j || k)
ans += dp[j][k][n];
cout << ans.v << endl;
return 0;
}
assert(vs != vector<Int>(m, 0));
if (n & 1) {
cout << 0 << endl;
return 0;
}
Int lim = n - 1;
for (Int i = 0; i < m; i++) {
if (s[i] == 'B')
continue;
Int j = i;
while (j < m && s[j] == 'R')
j++;
if (j == m)
break;
if (i == 0 && (j - i) % 2 == 0)
chmin(lim, j - i + 1);
if ((j - i) & 1)
chmin(lim, j - i);
i = j - 1;
}
vector<M> dp(n + 2, 0), sm(n + 2, 0);
dp[1] = M(1);
for (Int i = 2; i <= n + 1; i++) {
sm[i] = sm[i - 1] + dp[i - 1];
if (i & 1)
dp[i] = sm[i - 1] - sm[max<Int>(1, i - 1 - lim)];
}
M ans{0};
for (Int i = 0; i <= lim; i++)
ans += sm[n - i + 1] - sm[max<Int>(1, n - lim)];
cout << ans.v << endl;
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 874,472 | 874,473 | u687214625 | cpp |
p03057 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> struct SegmentTree {
private:
int n;
T E;
vector<T> node;
inline void updatef(T &x, T &y) {
x = y;
// x += y;
// x = max(x,y);
// x = min(x,y);
}
inline T queryf(T &x, T &y) {
// return x*y;
return (x + y) % mod;
// return max(x,y);
// return min(x,y);
}
public:
SegmentTree(int sz, T E_) : E(E_) {
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
}
SegmentTree(vector<T> &A, T E_) : E(E_) {
int sz = A.size();
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
rep(i, sz) node[i + n - 1] = A[i];
for (int i = n - 2; i >= 0; --i) {
node[i] = queryf(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(int k, T x) {
k += n - 1;
updatef(node[k], x);
while (k > 0) {
k = (k - 1) / 2;
node[k] = queryf(node[2 * k + 1], node[2 * k + 2]);
}
}
//[a,b)での和を返す
T get(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return E;
if (a <= l && r <= b)
return node[k];
T xl = get(a, b, 2 * k + 1, l, (l + r) / 2);
T xr = get(a, b, 2 * k + 2, (l + r) / 2, r);
return queryf(xl, xr);
}
};
vector<ll> inv, fact, invfact;
void mod_build(int n = 101010) {
fact.resize(n + 1);
inv.resize(n + 1);
invfact.resize(n + 1);
fact[0] = inv[0] = invfact[0] = 1;
inv[1] = 1;
rep(i, n) {
fact[i + 1] = fact[i] * (i + 1) % mod;
if (i > 0)
inv[i + 1] = mod - inv[mod % (i + 1)] * (mod / (i + 1)) % mod;
invfact[i + 1] = invfact[i] * inv[i + 1] % mod;
}
}
ll perm(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * invfact[n - k] % mod;
}
ll comb(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return (fact[n] * invfact[n - k] % mod) * invfact[k] % mod;
}
ll powmod(ll n, ll k) {
k %= mod - 1;
if (k < 0)
k += mod - 1;
ll ret = 1;
while (k) {
if (k & 1)
ret = ret * n % mod;
n = n * n % mod;
k >>= 1;
}
return ret;
}
int main() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
int len = 0;
while (len < n && s[len] == s[0])
++len;
if (len == m) {
vector<ll> ans(n + 1);
ans[0] = 2, ans[1] = 1;
rep(i, n - 1) ans[i + 2] = (ans[i + 1] + ans[i]) % mod;
cout << ans[n] << endl;
return 0;
}
if (n % 2) {
cout << 0 << endl;
return 0;
}
if (len % 2 == 0)
++len;
int cnt = 0;
rep(i, n) {
if (s[i] != s[0]) {
if (cnt % 2)
len = min(len, cnt);
cnt = 0;
} else
++cnt;
}
n /= 2;
len = (len + 1) / 2;
SegmentTree<ll> sg(n + 5, 0);
sg.update(0, 1);
rep(i, n + 1) {
ll ret = sg.get(max(0, i + 1 - len), i + 1);
sg.update(i + 1, ret);
}
ll ans = 0;
rep(i, max(n, len)) { ans += sg.get(max(0, n - len), n - i); }
cout << 2 * ans % mod << endl;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> struct SegmentTree {
private:
int n;
T E;
vector<T> node;
inline void updatef(T &x, T &y) {
x = y;
// x += y;
// x = max(x,y);
// x = min(x,y);
}
inline T queryf(T &x, T &y) {
// return x*y;
return (x + y) % mod;
// return max(x,y);
// return min(x,y);
}
public:
SegmentTree(int sz, T E_) : E(E_) {
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
}
SegmentTree(vector<T> &A, T E_) : E(E_) {
int sz = A.size();
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
rep(i, sz) node[i + n - 1] = A[i];
for (int i = n - 2; i >= 0; --i) {
node[i] = queryf(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(int k, T x) {
k += n - 1;
updatef(node[k], x);
while (k > 0) {
k = (k - 1) / 2;
node[k] = queryf(node[2 * k + 1], node[2 * k + 2]);
}
}
//[a,b)での和を返す
T get(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return E;
if (a <= l && r <= b)
return node[k];
T xl = get(a, b, 2 * k + 1, l, (l + r) / 2);
T xr = get(a, b, 2 * k + 2, (l + r) / 2, r);
return queryf(xl, xr);
}
};
vector<ll> inv, fact, invfact;
void mod_build(int n = 101010) {
fact.resize(n + 1);
inv.resize(n + 1);
invfact.resize(n + 1);
fact[0] = inv[0] = invfact[0] = 1;
inv[1] = 1;
rep(i, n) {
fact[i + 1] = fact[i] * (i + 1) % mod;
if (i > 0)
inv[i + 1] = mod - inv[mod % (i + 1)] * (mod / (i + 1)) % mod;
invfact[i + 1] = invfact[i] * inv[i + 1] % mod;
}
}
ll perm(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * invfact[n - k] % mod;
}
ll comb(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return (fact[n] * invfact[n - k] % mod) * invfact[k] % mod;
}
ll powmod(ll n, ll k) {
k %= mod - 1;
if (k < 0)
k += mod - 1;
ll ret = 1;
while (k) {
if (k & 1)
ret = ret * n % mod;
n = n * n % mod;
k >>= 1;
}
return ret;
}
int main() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
int len = 0;
while (len < m && s[len] == s[0])
++len;
if (len == m) {
vector<ll> ans(n + 1);
ans[0] = 2, ans[1] = 1;
rep(i, n - 1) ans[i + 2] = (ans[i + 1] + ans[i]) % mod;
cout << ans[n] << endl;
return 0;
}
if (n % 2) {
cout << 0 << endl;
return 0;
}
if (len % 2 == 0)
++len;
int cnt = 0;
rep(i, m) {
if (s[i] != s[0]) {
if (cnt % 2)
len = min(len, cnt);
cnt = 0;
} else
++cnt;
}
n /= 2;
len = (len + 1) / 2;
SegmentTree<ll> sg(n + 5, 0);
sg.update(0, 1);
rep(i, n + 1) {
ll ret = sg.get(max(0, i + 1 - len), i + 1);
sg.update(i + 1, ret);
}
ll ans = 0;
rep(i, min(n, len)) { ans += sg.get(max(0, n - len), n - i); }
cout << 2 * ans % mod << endl;
return 0;
}
| [
"identifier.change",
"control_flow.loop.condition.change",
"misc.opposites"
] | 874,478 | 874,475 | u352642493 | cpp |
p03057 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> struct SegmentTree {
private:
int n;
T E;
vector<T> node;
inline void updatef(T &x, T &y) {
x = y;
// x += y;
// x = max(x,y);
// x = min(x,y);
}
inline T queryf(T &x, T &y) {
// return x*y;
return (x + y) % mod;
// return max(x,y);
// return min(x,y);
}
public:
SegmentTree(int sz, T E_) : E(E_) {
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
}
SegmentTree(vector<T> &A, T E_) : E(E_) {
int sz = A.size();
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
rep(i, sz) node[i + n - 1] = A[i];
for (int i = n - 2; i >= 0; --i) {
node[i] = queryf(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(int k, T x) {
k += n - 1;
updatef(node[k], x);
while (k > 0) {
k = (k - 1) / 2;
node[k] = queryf(node[2 * k + 1], node[2 * k + 2]);
}
}
//[a,b)での和を返す
T get(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return E;
if (a <= l && r <= b)
return node[k];
T xl = get(a, b, 2 * k + 1, l, (l + r) / 2);
T xr = get(a, b, 2 * k + 2, (l + r) / 2, r);
return queryf(xl, xr);
}
};
vector<ll> inv, fact, invfact;
void mod_build(int n = 101010) {
fact.resize(n + 1);
inv.resize(n + 1);
invfact.resize(n + 1);
fact[0] = inv[0] = invfact[0] = 1;
inv[1] = 1;
rep(i, n) {
fact[i + 1] = fact[i] * (i + 1) % mod;
if (i > 0)
inv[i + 1] = mod - inv[mod % (i + 1)] * (mod / (i + 1)) % mod;
invfact[i + 1] = invfact[i] * inv[i + 1] % mod;
}
}
ll perm(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * invfact[n - k] % mod;
}
ll comb(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return (fact[n] * invfact[n - k] % mod) * invfact[k] % mod;
}
ll powmod(ll n, ll k) {
k %= mod - 1;
if (k < 0)
k += mod - 1;
ll ret = 1;
while (k) {
if (k & 1)
ret = ret * n % mod;
n = n * n % mod;
k >>= 1;
}
return ret;
}
int main() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
int len = 0;
while (len < n && s[len] == s[0])
++len;
if (len == m) {
vector<ll> ans(n + 1);
ans[0] = 2, ans[1] = 1;
rep(i, n - 1) ans[i + 2] = (ans[i + 1] + ans[i]) % mod;
cout << ans[n] << endl;
return 0;
}
if (n % 2) {
cout << 0 << endl;
return 0;
}
if (len % 2 == 0)
++len;
int cnt = 0;
rep(i, n) {
if (s[i] != s[0]) {
if (cnt % 2)
len = min(len, cnt);
cnt = 0;
} else
++cnt;
}
n /= 2;
len = (len + 1) / 2;
SegmentTree<ll> sg(n + 5, 0);
sg.update(0, 1);
rep(i, n + 1) {
ll ret = sg.get(max(0, i + 1 - len), i + 1);
sg.update(i + 1, ret);
}
ll ans = 0;
rep(i, max(n, len)) { ans += sg.get(max(0, n - len), n - i); }
cout << 2 * ans % mod << endl;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
template <typename T> struct SegmentTree {
private:
int n;
T E;
vector<T> node;
inline void updatef(T &x, T &y) {
x = y;
// x += y;
// x = max(x,y);
// x = min(x,y);
}
inline T queryf(T &x, T &y) {
// return x*y;
return (x + y) % mod;
// return max(x,y);
// return min(x,y);
}
public:
SegmentTree(int sz, T E_) : E(E_) {
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
}
SegmentTree(vector<T> &A, T E_) : E(E_) {
int sz = A.size();
n = 1;
while (n < sz)
n <<= 1;
node.resize(2 * n - 1, E);
rep(i, sz) node[i + n - 1] = A[i];
for (int i = n - 2; i >= 0; --i) {
node[i] = queryf(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(int k, T x) {
k += n - 1;
updatef(node[k], x);
while (k > 0) {
k = (k - 1) / 2;
node[k] = queryf(node[2 * k + 1], node[2 * k + 2]);
}
}
//[a,b)での和を返す
T get(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return E;
if (a <= l && r <= b)
return node[k];
T xl = get(a, b, 2 * k + 1, l, (l + r) / 2);
T xr = get(a, b, 2 * k + 2, (l + r) / 2, r);
return queryf(xl, xr);
}
};
vector<ll> inv, fact, invfact;
void mod_build(int n = 101010) {
fact.resize(n + 1);
inv.resize(n + 1);
invfact.resize(n + 1);
fact[0] = inv[0] = invfact[0] = 1;
inv[1] = 1;
rep(i, n) {
fact[i + 1] = fact[i] * (i + 1) % mod;
if (i > 0)
inv[i + 1] = mod - inv[mod % (i + 1)] * (mod / (i + 1)) % mod;
invfact[i + 1] = invfact[i] * inv[i + 1] % mod;
}
}
ll perm(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * invfact[n - k] % mod;
}
ll comb(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return (fact[n] * invfact[n - k] % mod) * invfact[k] % mod;
}
ll powmod(ll n, ll k) {
k %= mod - 1;
if (k < 0)
k += mod - 1;
ll ret = 1;
while (k) {
if (k & 1)
ret = ret * n % mod;
n = n * n % mod;
k >>= 1;
}
return ret;
}
int main() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
int len = 0;
while (len < m && s[len] == s[0])
++len;
if (len == m) {
vector<ll> ans(n + 5);
ans[0] = 2, ans[1] = 1;
rep(i, n - 1) ans[i + 2] = (ans[i + 1] + ans[i]) % mod;
cout << ans[n] << endl;
return 0;
}
if (n % 2) {
cout << 0 << endl;
return 0;
}
if (len % 2 == 0)
++len;
int cnt = 0;
rep(i, m) {
if (s[i] != s[0]) {
if (cnt % 2)
len = min(len, cnt);
cnt = 0;
} else
++cnt;
}
n /= 2;
len = (len + 1) / 2;
SegmentTree<ll> sg(n + 5, 0);
sg.update(0, 1);
rep(i, n + 1) {
ll ret = sg.get(max(0, i + 1 - len), i + 1);
sg.update(i + 1, ret);
}
ll ans = 0;
rep(i, min(n, len)) { ans += sg.get(max(0, n - len), n - i); }
cout << 2 * ans % mod << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.condition.change",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"misc.opposites"
] | 874,478 | 874,479 | u352642493 | cpp |
p03057 | #include <algorithm>
#include <cstdio>
#define Pr(f, ...) printf(f, ##__VA_ARGS__), fflush(stdout)
#define rep(i, s, t) for (int i = s; i <= (t); ++i)
#define dec(i, s, t) for (int i = s; i >= (t); --i)
#define lop(i, s, t) for (int i = s; i < (t); ++i)
using namespace std;
const int N = 200050, P = 1e9 + 7;
int n, m, limit, f[N], sum[N];
char s[N];
int main(int argc, char *argv[]) {
// freopen("d.in.cpp","r",stdin);
scanf("%d%d%s", &n, &m, s);
if (s[0] == 'B')
lop(i, 0, m) s[i] = s[i] == 'R' ? 'B' : 'R';
// Pr("%d,%d,%s\n",n,m,s);
while (m && s[m - 1] == 'R')
--m;
if (m == 0) {
f[0] = 2, f[1] = 1;
rep(i, 2, n) f[i] = (f[i - 1] + f[i - 2]) % P;
printf("%d\n", f[n]);
return 0;
}
if (n % 2 != 0) {
puts("0");
return 0;
}
limit = n - 1;
for (int p = 0, prv = 0; p < m; ++p) {
while (p < m && s[p] == 'R')
++p;
if (prv == 0) {
if (p - prv % 2 == 1)
limit = p - prv;
else
limit = p - prv + 1;
}
if (p - prv % 2 == 1)
limit = min(limit, p - prv);
prv = p;
}
f[1] = sum[1] = 0, f[2] = sum[2] = 2;
for (int i = 4; i <= n; i += 2) {
sum[i - 1] = (sum[i - 2] + f[i - 1]) % P;
if (i <= limit + 1)
(f[i] += i) %= P;
(f[i] += (sum[i - 1] - sum[max(1, i - limit - 2)] + P) % P) %= P;
sum[i] = (sum[i - 1] + f[i]) % P;
}
printf("%d\n", f[n]);
return 0;
} | #include <algorithm>
#include <cstdio>
#define Pr(f, ...) printf(f, ##__VA_ARGS__), fflush(stdout)
#define rep(i, s, t) for (int i = s; i <= (t); ++i)
#define dec(i, s, t) for (int i = s; i >= (t); --i)
#define lop(i, s, t) for (int i = s; i < (t); ++i)
using namespace std;
const int N = 200050, P = 1e9 + 7;
int n, m, limit, f[N], sum[N];
char s[N];
int main(int argc, char *argv[]) {
// freopen("d.in.cpp","r",stdin);
scanf("%d%d%s", &n, &m, s);
if (s[0] == 'B')
lop(i, 0, m) s[i] = s[i] == 'R' ? 'B' : 'R';
// Pr("%d,%d,%s\n",n,m,s);
while (m && s[m - 1] == 'R')
--m;
if (m == 0) {
f[0] = 2, f[1] = 1;
rep(i, 2, n) f[i] = (f[i - 1] + f[i - 2]) % P;
printf("%d\n", f[n]);
return 0;
}
if (n % 2 != 0) {
puts("0");
return 0;
}
limit = n - 1;
for (int p = 0, prv = 0; p < m; ++p) {
while (p < m && s[p] == 'R')
++p;
if (prv == 0) {
if (p - prv % 2 == 1)
limit = p - prv;
else
limit = p - prv + 1;
}
if ((p - prv) % 2 == 1)
limit = min(limit, p - prv);
// printf("%d\n",p-prv);
prv = p + 1;
}
// Pr("limit=%d\n",limit);
f[1] = sum[1] = 0, f[2] = sum[2] = 2;
for (int i = 4; i <= n; i += 2) {
sum[i - 1] = (sum[i - 2] + f[i - 1]) % P;
if (i <= limit + 1)
(f[i] += i) %= P;
(f[i] += (sum[i - 1] - sum[max(1, i - limit - 2)] + P) % P) %= P;
sum[i] = (sum[i - 1] + f[i]) % P;
}
printf("%d\n", f[n]);
return 0;
} | [
"control_flow.branch.if.condition.change",
"assignment.change"
] | 874,480 | 874,481 | u071794493 | cpp |
p03057 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <unistd.h>
#include <vector>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef pair<double, ll> pdlg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
typedef vector<ll> vll;
typedef vector<vector<ll>> matrix;
#define REP(i, x, y) for (ll i = (ll)x; i < (ll)y; i++)
#define DREP(i, x, y, d) for (ll i = (ll)x; i < (ll)y; i += (ll)d)
#define PER(i, x, y) for (ll i = (ll)x; i > (ll)y; i--)
#define DPER(i, x, y, d) for (ll i = (ll)x; i > (ll)y; i -= (ll)d)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 1000000007;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-12;
ll modadd(ll x, ll y) { return ((x + y) % mod + mod) % mod; }
ll modminus(ll x, ll y) { return (x - y + mod) % mod; }
ll multiply(ll x, ll y) { return (x % mod) * (y % mod) % mod; }
ll modpower(ll x, ll y) {
if (y == 0) {
return 1;
} else if (y == 1) {
return x % mod;
} else if (y % 2 == 0) {
ll p = modpower(x, y / 2);
return p * p % mod;
} else {
ll p = modpower(x, y / 2);
return (p * p) % mod * (x % mod) % mod;
}
}
ll divide(ll x, ll y) { return multiply(x, modpower(y, mod - 2)); }
ll frac[1000000];
ll invfrac[1000000];
void fracinvfrac(ll n) {
frac[0] = 1;
for (int i = 1; i <= n; i++) {
frac[i] = multiply(frac[i - 1], i);
}
invfrac[n] = divide(1, frac[n]);
for (int i = n - 1; i >= 0; i--) {
invfrac[i] = multiply(invfrac[i + 1], i + 1);
}
}
ll modcombi(ll x, ll y) {
if (x < y || y < 0) {
return 0;
} else if (y == 0) {
return 1;
} else {
return multiply(multiply(frac[x], invfrac[x - y]), invfrac[y]);
}
}
ll N, M;
ll dp[200010][2];
ll solve(ll num) {
dp[0][0] = 1;
REP(i, 0, num) {
dp[i + 1][0] = modadd(dp[i + 1][0], dp[i][0]);
dp[i + 1][0] = modadd(dp[i + 1][0], dp[i][1]);
dp[i + 1][1] = modadd(dp[i + 1][1], dp[i][0]);
}
return (dp[num - 1][0] + dp[num - 1][1] + dp[num - 2][0]) % mod;
}
ll dpb[200010][2];
ll solveb(ll num, ll len) {
// cout << num << " " << len << endl;
ll p = num / 2;
ll q = len / 2;
dpb[0][0] = 1;
dpb[0][1] = 1;
// ll sum = 0;
REP(i, 0, p) {
dpb[i + 1][0] = modadd(dpb[i + 1][0], dpb[i][1]);
if (i - (q + 1) >= 0) {
dpb[i + 1][0] = modminus(dpb[i + 1][0], dpb[i - (q + 1)][1]);
}
// dpb[i + 1][0] = modadd(dpb[i + 1][0], dpb[i][1]);
dpb[i + 1][1] = modadd(modadd(dpb[i + 1][1], dpb[i + 1][0]), dpb[i][1]);
// sum = modadd(sum, dpb[i + 1][1]);
// if (i >= q) {
// sum = modminus(sum, dpb[i + 1 - q][0]);
// }
// if (i == 0) {
// sum--;
// }
}
// dpb[0][0] = 1;
// dpb[0][1] = 1;
// REP(i, 0, num) {
// dpb[i + 1][0] = modadd(dpb[i + 1][0], dpb[i][0]);
// dpb[i + 1][0] = modadd(dpb[i + 1][0], dpb[i][1]);
// dpb[i + 1][1] = modadd(dpb[i + 1][1], dpb[i][0]);
// }
// dp[0][0] = 1;
// REP(i, 0, num) {
// dp[i + 1][0] = modadd(dp[i + 1][0], dp[i][0]);
// dp[i + 1][0] = modadd(dp[i + 1][0], dp[i][1]);
// dp[i + 1][1] = modadd(dp[i + 1][1], dp[i][0]);
// }
// REP(i, 0, p) {
// cout << dpb[i][0] << " " << dpb[i][1] << endl;
// }
ll ans = 0;
REP(i, 0, q + 1) {
if (p - 1 - i >= 0) {
ll val = multiply((i + 1) * 2, dpb[p - 1 - i][0]);
// cout << val << endl;
ans = modadd(ans, val);
}
}
return ans;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
string S;
cin >> S;
if (N & 1) {
bool ok = true;
char c = S[0];
REP(i, 0, M) {
if (S[i] != c) {
ok = false;
}
}
if (ok) {
cout << solve(N) << endl;
} else {
cout << 0 << endl;
}
return 0;
} else {
ll len = 0;
char c = S[0];
ll num = 0;
while (num < M && S[num] == c) {
num++;
}
len = num;
if (len == M) {
cout << solve(N) << endl;
return 0;
}
if (!(len & 1)) {
len++;
}
ll tmp = 0;
num++;
while (num < M) {
if (num == c) {
tmp++;
} else {
if (tmp & 1) {
len = min(len, tmp);
}
tmp = 0;
}
num++;
}
// cout << len << endl;
cout << solveb(N, len) << endl;
}
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <unistd.h>
#include <vector>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef pair<double, ll> pdlg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
typedef vector<ll> vll;
typedef vector<vector<ll>> matrix;
#define REP(i, x, y) for (ll i = (ll)x; i < (ll)y; i++)
#define DREP(i, x, y, d) for (ll i = (ll)x; i < (ll)y; i += (ll)d)
#define PER(i, x, y) for (ll i = (ll)x; i > (ll)y; i--)
#define DPER(i, x, y, d) for (ll i = (ll)x; i > (ll)y; i -= (ll)d)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 1000000007;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-12;
ll modadd(ll x, ll y) { return ((x + y) % mod + mod) % mod; }
ll modminus(ll x, ll y) { return (x - y + mod) % mod; }
ll multiply(ll x, ll y) { return (x % mod) * (y % mod) % mod; }
ll modpower(ll x, ll y) {
if (y == 0) {
return 1;
} else if (y == 1) {
return x % mod;
} else if (y % 2 == 0) {
ll p = modpower(x, y / 2);
return p * p % mod;
} else {
ll p = modpower(x, y / 2);
return (p * p) % mod * (x % mod) % mod;
}
}
ll divide(ll x, ll y) { return multiply(x, modpower(y, mod - 2)); }
ll frac[1000000];
ll invfrac[1000000];
void fracinvfrac(ll n) {
frac[0] = 1;
for (int i = 1; i <= n; i++) {
frac[i] = multiply(frac[i - 1], i);
}
invfrac[n] = divide(1, frac[n]);
for (int i = n - 1; i >= 0; i--) {
invfrac[i] = multiply(invfrac[i + 1], i + 1);
}
}
ll modcombi(ll x, ll y) {
if (x < y || y < 0) {
return 0;
} else if (y == 0) {
return 1;
} else {
return multiply(multiply(frac[x], invfrac[x - y]), invfrac[y]);
}
}
ll N, M;
ll dp[200010][2];
ll solve(ll num) {
dp[0][0] = 1;
REP(i, 0, num) {
dp[i + 1][0] = modadd(dp[i + 1][0], dp[i][0]);
dp[i + 1][0] = modadd(dp[i + 1][0], dp[i][1]);
dp[i + 1][1] = modadd(dp[i + 1][1], dp[i][0]);
}
return (dp[num - 1][0] + dp[num - 1][1] + dp[num - 2][0]) % mod;
}
ll dpb[200010][2];
ll solveb(ll num, ll len) {
// cout << num << " " << len << endl;
ll p = num / 2;
ll q = len / 2;
dpb[0][0] = 1;
dpb[0][1] = 1;
// ll sum = 0;
REP(i, 0, p) {
dpb[i + 1][0] = modadd(dpb[i + 1][0], dpb[i][1]);
if (i - (q + 1) >= 0) {
dpb[i + 1][0] = modminus(dpb[i + 1][0], dpb[i - (q + 1)][1]);
}
// dpb[i + 1][0] = modadd(dpb[i + 1][0], dpb[i][1]);
dpb[i + 1][1] = modadd(modadd(dpb[i + 1][1], dpb[i + 1][0]), dpb[i][1]);
// sum = modadd(sum, dpb[i + 1][1]);
// if (i >= q) {
// sum = modminus(sum, dpb[i + 1 - q][0]);
// }
// if (i == 0) {
// sum--;
// }
}
// dpb[0][0] = 1;
// dpb[0][1] = 1;
// REP(i, 0, num) {
// dpb[i + 1][0] = modadd(dpb[i + 1][0], dpb[i][0]);
// dpb[i + 1][0] = modadd(dpb[i + 1][0], dpb[i][1]);
// dpb[i + 1][1] = modadd(dpb[i + 1][1], dpb[i][0]);
// }
// dp[0][0] = 1;
// REP(i, 0, num) {
// dp[i + 1][0] = modadd(dp[i + 1][0], dp[i][0]);
// dp[i + 1][0] = modadd(dp[i + 1][0], dp[i][1]);
// dp[i + 1][1] = modadd(dp[i + 1][1], dp[i][0]);
// }
// REP(i, 0, p) {
// cout << dpb[i][0] << " " << dpb[i][1] << endl;
// }
ll ans = 0;
REP(i, 0, q + 1) {
if (p - 1 - i >= 0) {
ll val = multiply((i + 1) * 2, dpb[p - 1 - i][0]);
// cout << val << endl;
ans = modadd(ans, val);
}
}
return ans;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
string S;
cin >> S;
if (N & 1) {
bool ok = true;
char c = S[0];
REP(i, 0, M) {
if (S[i] != c) {
ok = false;
}
}
if (ok) {
cout << solve(N) << endl;
} else {
cout << 0 << endl;
}
return 0;
} else {
ll len = 0;
char c = S[0];
ll num = 0;
while (num < M && S[num] == c) {
num++;
}
len = num;
if (len == M) {
cout << solve(N) << endl;
return 0;
}
if (!(len & 1)) {
len++;
}
ll tmp = 0;
num++;
while (num < M) {
if (S[num] == c) {
tmp++;
} else {
if (tmp & 1) {
len = min(len, tmp);
}
tmp = 0;
}
num++;
}
// cout << len << endl;
cout << solveb(N, len) << endl;
}
}
| [
"control_flow.branch.if.condition.change"
] | 874,484 | 874,485 | u006204672 | cpp |
p03057 | #include <algorithm>
#include <cstdio>
using std::min;
const int MOD = 1000000007;
const int MAXN = 200011, MAXM = 200011;
inline int sum(const int &a, const int &b) {
return (a + b >= MOD) ? (a + b - MOD) : (a + b);
}
inline int mul(const int &a, const int &b) {
return (int)((1LL * a * b) % (long long)(MOD));
}
inline void add(int &f, const int &v) {
f += v;
if (f >= MOD)
f -= MOD;
}
int N, M;
int A[MAXM];
char input[MAXM];
int F[MAXN];
inline bool AllZero() {
int Cnt = 0;
for (int i = 1; i <= M; ++i)
Cnt += !A[i];
return Cnt == M;
}
int main() {
scanf("%d%d", &N, &M);
scanf("%s", input);
for (int i = 1; i <= M; ++i)
A[i] = input[i - 1] != input[0];
if (AllZero()) {
int F[2][2], T[2][2];
F[0][0] = F[1][1] = 1;
F[0][1] = F[1][0] = 0;
for (int i = 2; i <= N; ++i) {
for (int s = 0; s < 2; ++s)
for (int n = 0; n < 2; ++n)
T[s][n] = 0;
for (int s = 0; s < 2; ++s)
for (int n = 0; n < 2; ++n)
for (int c = 0; c < 2; ++c)
if (n + c < 2)
T[s][c] += F[s][n];
for (int s = 0; s < 2; ++s)
for (int n = 0; n < 2; ++n)
F[s][n] = T[s][n];
}
int Ans = 0;
for (int s = 0; s < 2; ++s)
for (int n = 0; n < 2; ++n)
if (s + n < 2)
add(Ans, F[s][n]);
printf("%d\n", Ans);
} else {
int Lim = N;
for (int i = 1, c = 0, p = 0; i <= M; ++i) {
if (A[i]) {
if (c & 1)
Lim = min(Lim, c + 1);
else if (!p)
Lim = min(Lim, c + 2);
c = 0;
p = i;
} else
++c;
}
F[0] = F[2] = 1;
for (int i = 4; i <= N; i += 2) {
F[i] = sum(F[i - 2], F[i - 2]);
if (i >= Lim + 2) {
add(F[i], MOD - F[i - (Lim + 2)]);
}
}
int Ans = 0;
for (int i = 2; i <= Lim; i += 2) {
add(Ans, mul(F[N - i], i));
}
printf("%d\n", Ans);
}
return 0;
} | #include <algorithm>
#include <cstdio>
using std::min;
const int MOD = 1000000007;
const int MAXN = 200011, MAXM = 200011;
inline int sum(const int &a, const int &b) {
return (a + b >= MOD) ? (a + b - MOD) : (a + b);
}
inline int mul(const int &a, const int &b) {
return (int)((1LL * a * b) % (long long)(MOD));
}
inline void add(int &f, const int &v) {
f += v;
if (f >= MOD)
f -= MOD;
}
int N, M;
int A[MAXM];
char input[MAXM];
int F[MAXN];
inline bool AllZero() {
int Cnt = 0;
for (int i = 1; i <= M; ++i)
Cnt += !A[i];
return Cnt == M;
}
int main() {
scanf("%d%d", &N, &M);
scanf("%s", input);
for (int i = 1; i <= M; ++i)
A[i] = input[i - 1] != input[0];
if (AllZero()) {
int F[2][2], T[2][2];
F[0][0] = F[1][1] = 1;
F[0][1] = F[1][0] = 0;
for (int i = 2; i <= N; ++i) {
for (int s = 0; s < 2; ++s)
for (int n = 0; n < 2; ++n)
T[s][n] = 0;
for (int s = 0; s < 2; ++s)
for (int n = 0; n < 2; ++n)
for (int c = 0; c < 2; ++c)
if (n + c < 2)
add(T[s][c], F[s][n]);
for (int s = 0; s < 2; ++s)
for (int n = 0; n < 2; ++n)
F[s][n] = T[s][n];
}
int Ans = 0;
for (int s = 0; s < 2; ++s)
for (int n = 0; n < 2; ++n)
if (s + n < 2)
add(Ans, F[s][n]);
printf("%d\n", Ans);
} else {
int Lim = N;
for (int i = 1, c = 0, p = 0; i <= M; ++i) {
if (A[i]) {
if (c & 1)
Lim = min(Lim, c + 1);
else if (!p)
Lim = min(Lim, c + 2);
c = 0;
p = i;
} else
++c;
}
F[0] = F[2] = 1;
for (int i = 4; i <= N; i += 2) {
F[i] = sum(F[i - 2], F[i - 2]);
if (i >= Lim + 2) {
add(F[i], MOD - F[i - (Lim + 2)]);
}
}
int Ans = 0;
for (int i = 2; i <= Lim; i += 2) {
add(Ans, mul(F[N - i], i));
}
printf("%d\n", Ans);
}
return 0;
} | [
"call.add",
"call.arguments.change"
] | 874,486 | 874,487 | u577683651 | cpp |
p03057 | // minamoto
#include <bits/stdc++.h>
#define R register
#define inline __inline__ __attribute__((always_inline))
#define fp(i, a, b) for (R int i = (a), I = (b) + 1; i < I; ++i)
#define fd(i, a, b) for (R int i = (a), I = (b)-1; i > I; --i)
#define go(u) for (int i = head[u], v = e[i].v; i; i = e[i].nx, v = e[i].v)
template <class T> inline bool cmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <class T> inline bool cmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
using namespace std;
const int N = 2e5 + 5, P = 1e9 + 7;
inline void upd(R int &x, R int y) { (x += y) >= P ? x -= P : 0; }
inline int add(R int x, R int y) { return x + y >= P ? x + y - P : x + y; }
inline int dec(R int x, R int y) { return x - y < 0 ? x - y + P : x - y; }
inline int mul(R int x, R int y) { return 1ll * x * y - 1ll * x * y / P * P; }
char s[N];
int f[N], dp[2][5], n, m, res, t;
void solve1() {
dp[0][0] = dp[0][3] = 1, t = 0;
for (R int i = 1; i < n; ++i, t ^= 1) {
dp[t ^ 1][0] = dp[t ^ 1][1] = dp[t ^ 1][2] = dp[t ^ 1][3] = 0;
dp[t ^ 1][0] = add(dp[t][0], dp[t][1]), dp[t ^ 1][1] = dp[t][0],
dp[t ^ 1][2] = add(dp[t][2], dp[t][3]), dp[t ^ 1][3] = dp[t][2];
}
res = add(dp[t][0], add(dp[t][1], dp[t][2]));
printf("%d\n", res);
}
void solve2() {
int lim = n, cur = 0, las = m;
while (s[las] == 'R')
--las;
fd(i, las, 1) if (s[i] == 'B') {
if (cur & 1)
cmin(lim, cur + 1);
cur = 0;
}
else ++cur;
cmin(lim, cur + 1 + (cur & 1 ^ 1));
f[0] = f[2] = 1;
for (R int i = 4; i <= n; i += 2) {
f[i] = mul(f[i - 2], 2);
if (i >= lim + 2)
f[i] = dec(f[i], f[i - (lim + 2)]);
}
res = 0;
for (R int i = 2; i <= lim; i += 2)
upd(res, mul(f[n - i], i));
printf("%d\n", res);
}
int main() {
// freopen("testdata.in","r",stdin);
scanf("%d%d%s", &n, &m, s + 1);
if (s[1] == 'B')
fp(i, 1, m) s[i] ^= 'B' ^ 'R';
bool flag = 0;
fp(i, 1, n) if (s[i] == 'B') {
flag = 1;
break;
}
if (!flag)
solve1();
else
solve2();
return 0;
} | // minamoto
#include <bits/stdc++.h>
#define R register
#define inline __inline__ __attribute__((always_inline))
#define fp(i, a, b) for (R int i = (a), I = (b) + 1; i < I; ++i)
#define fd(i, a, b) for (R int i = (a), I = (b)-1; i > I; --i)
#define go(u) for (int i = head[u], v = e[i].v; i; i = e[i].nx, v = e[i].v)
template <class T> inline bool cmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <class T> inline bool cmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
using namespace std;
const int N = 2e5 + 5, P = 1e9 + 7;
inline void upd(R int &x, R int y) { (x += y) >= P ? x -= P : 0; }
inline int add(R int x, R int y) { return x + y >= P ? x + y - P : x + y; }
inline int dec(R int x, R int y) { return x - y < 0 ? x - y + P : x - y; }
inline int mul(R int x, R int y) { return 1ll * x * y - 1ll * x * y / P * P; }
char s[N];
int f[N], dp[2][5], n, m, res, t;
void solve1() {
dp[0][0] = dp[0][3] = 1, t = 0;
for (R int i = 1; i < n; ++i, t ^= 1) {
dp[t ^ 1][0] = dp[t ^ 1][1] = dp[t ^ 1][2] = dp[t ^ 1][3] = 0;
dp[t ^ 1][0] = add(dp[t][0], dp[t][1]), dp[t ^ 1][1] = dp[t][0],
dp[t ^ 1][2] = add(dp[t][2], dp[t][3]), dp[t ^ 1][3] = dp[t][2];
}
res = add(dp[t][0], add(dp[t][1], dp[t][2]));
printf("%d\n", res);
}
void solve2() {
int lim = n, cur = 0, las = m;
while (s[las] == 'R')
--las;
fd(i, las, 1) if (s[i] == 'B') {
if (cur & 1)
cmin(lim, cur + 1);
cur = 0;
}
else ++cur;
cmin(lim, cur + 1 + (cur & 1 ^ 1));
f[0] = f[2] = 1;
for (R int i = 4; i <= n; i += 2) {
f[i] = mul(f[i - 2], 2);
if (i >= lim + 2)
f[i] = dec(f[i], f[i - (lim + 2)]);
}
res = 0;
for (R int i = 2; i <= lim; i += 2)
upd(res, mul(f[n - i], i));
printf("%d\n", res);
}
int main() {
// freopen("testdata.in","r",stdin);
scanf("%d%d%s", &n, &m, s + 1);
if (s[1] == 'B')
fp(i, 1, m) s[i] ^= 'B' ^ 'R';
bool flag = 0;
fp(i, 1, m) if (s[i] == 'B') {
flag = 1;
break;
}
if (!flag)
solve1();
else
solve2();
return 0;
} | [
"identifier.change",
"call.arguments.change"
] | 874,488 | 874,489 | u561765782 | cpp |
p03057 | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
const int Q = 1 << 19;
char s[Q];
int n, m;
const int MOD = 1e9 + 7;
inline int add(int a, int b) {
a += b;
return a >= MOD ? a - MOD : a;
}
inline int sub(int a, int b) {
a -= b;
return a < 0 ? a + MOD : a;
}
inline int mul(int a, int b) { return 1LL * a * b % MOD; }
int dp[Q];
void DP(int n, int lim) {
dp[0] = 1;
int sm = 1;
for (int i = 1; i <= n; i++) {
if (i > lim)
sm = sub(sm, dp[i - lim - 1]);
dp[i] = sm;
sm = add(sm, dp[i]);
}
}
void s1() {
exit(-1);
dp[0] = 1;
int sm = 0;
for (int i = 1; i <= n; i++) {
if (i >= 2)
sm = add(sm, dp[i - 2]);
dp[i] = sm;
}
int als = 1;
for (int i = 2; i <= n; i++) {
als = add(als, mul(i, dp[n - i]));
}
printf("%d\n", als);
}
void s2(int fir) {
if (n & 1) {
puts("0");
return;
}
int mus = fir + (fir % 2 == 0);
for (int len = 0, i = fir + 2; i <= m; i++) {
if (s[i] == s[1])
++len;
else {
if (len & 1)
mus = min(mus, len);
len = 0;
}
}
n /= 2, mus = (mus + 1) / 2;
// printf("%d %d WCNM\n",n,mus);
DP(n, mus);
// for(int i=0;i<=n;i++)
// printf("%d ????\n",dp[i]);
int als = 0;
for (int i = 1; i <= n && i <= mus; i++) {
als = add(als, mul(2 * i, dp[n - i]));
}
printf("%d", als);
}
int main() {
scanf("%d%d%s", &n, &m, s + 1);
for (int i = 2; i <= m; i++)
if (s[i] != s[1]) {
s2(i - 1);
return 0;
}
s1();
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
const int Q = 1 << 19;
char s[Q];
int n, m;
const int MOD = 1e9 + 7;
inline int add(int a, int b) {
a += b;
return a >= MOD ? a - MOD : a;
}
inline int sub(int a, int b) {
a -= b;
return a < 0 ? a + MOD : a;
}
inline int mul(int a, int b) { return 1LL * a * b % MOD; }
int dp[Q];
void DP(int n, int lim) {
dp[0] = 1;
int sm = 1;
for (int i = 1; i <= n; i++) {
if (i > lim)
sm = sub(sm, dp[i - lim - 1]);
dp[i] = sm;
sm = add(sm, dp[i]);
}
}
void s1() {
dp[0] = 1;
int sm = 0;
for (int i = 1; i <= n; i++) {
if (i >= 2)
sm = add(sm, dp[i - 2]);
dp[i] = sm;
}
int als = 1;
for (int i = 2; i <= n; i++) {
als = add(als, mul(i, dp[n - i]));
}
printf("%d\n", als);
}
void s2(int fir) {
if (n & 1) {
puts("0");
return;
}
int mus = fir + (fir % 2 == 0);
for (int len = 0, i = fir + 2; i <= m; i++) {
if (s[i] == s[1])
++len;
else {
if (len & 1)
mus = min(mus, len);
len = 0;
}
}
n /= 2, mus = (mus + 1) / 2;
// printf("%d %d WCNM\n",n,mus);
DP(n, mus);
// for(int i=0;i<=n;i++)
// printf("%d ????\n",dp[i]);
int als = 0;
for (int i = 1; i <= n && i <= mus; i++) {
als = add(als, mul(2 * i, dp[n - i]));
}
printf("%d", als);
}
int main() {
scanf("%d%d%s", &n, &m, s + 1);
for (int i = 2; i <= m; i++)
if (s[i] != s[1]) {
s2(i - 1);
return 0;
}
s1();
return 0;
} | [
"call.remove"
] | 874,494 | 874,495 | u140310696 | cpp |
p03057 | #include <bits/stdc++.h>
using namespace std;
#define pii pair<int, int>
#define mp make_pair
#define pb push_back
#define lg long long
#define db double
#define lb(x) ((x) & -(x))
#define ft first
#define sd second
#define HII cerr << "HI" << endl
#define LLLINE cerr << "@@@@@@@@@@@@@@@@@@@@" << endl
template <class _T_> void read(_T_ &d) {
d = 0;
int f = 1;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
if (c == '-')
f *= -1;
for (; c >= '0' && c <= '9'; c = getchar())
d = d * 10 + c - '0';
d *= f;
}
/************************************************/
#define Md 1000000007
#define MN 200005
int n, m;
char c[MN];
lg Pow(lg x, lg y) {
lg res = 1;
for (; y; y >>= 1, x = x * x % Md)
if (y & 1)
res = res * x % Md;
return res;
}
int Fix(int x) {
if (x < 0)
return x + Md;
if (x >= Md)
return x - Md;
return x;
}
int dp[MN], tmp[MN];
int miu[MN];
int main() {
read(n);
read(m);
scanf("%s", c + 1);
miu[1] = 1;
for (int i = 1; i < MN; ++i) {
for (int j = i + i; j < MN; j += i) {
miu[j] -= miu[i];
}
}
char Hd = c[1];
int cnt = 0, mx;
for (int i = 1; i <= m; ++i) {
if (c[i] == Hd)
++cnt;
else
break;
}
if (cnt & 1)
mx = cnt;
else
mx = cnt + 1;
if ((n & 1) && cnt != m)
return puts("0"), 0;
if (cnt == m) {
int res = 0;
tmp[0] = tmp[1] = 1;
dp[0] = 1;
if (n > 2)
res = n;
for (int i = 1; i < n - 1; ++i) {
dp[i] = (i >= 2 ? tmp[i - 2] : 0);
tmp[i] = Fix(tmp[i - 1] + dp[i]);
res = Fix(res + 1ll * dp[i] * (n - i) % Md);
}
printf("%d", res + 1);
return 0;
}
int res = (cnt == m);
cnt = 0;
for (int i = 1; i <= m; ++i) {
if (c[i] == Hd)
++cnt;
else {
if (!cnt)
continue;
if (cnt & 1)
mx = min(mx, cnt);
cnt = 0;
}
}
// for(int i=1;i<=5;++i)cerr<<miu[i]<<' ';cerr<<endl;
tmp[0] = tmp[1] = 1;
dp[0] = 1;
mx += 2;
if (n < mx)
res += n;
for (int i = 2; i <= n; i += 2) {
dp[i] = Fix(tmp[i - 1] - (mx > i ? 0 : tmp[i - mx]));
tmp[i] = tmp[i + 1] = Fix(tmp[i - 1] + dp[i]);
// cerr<<dp[i]<<' '<<i<<endl;
if ((n - i) % 2 == 0 && n - i < mx)
res = Fix(res + 1ll * dp[i] * (n - i) % Md);
}
cout << res;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pii pair<int, int>
#define mp make_pair
#define pb push_back
#define lg long long
#define db double
#define lb(x) ((x) & -(x))
#define ft first
#define sd second
#define HII cerr << "HI" << endl
#define LLLINE cerr << "@@@@@@@@@@@@@@@@@@@@" << endl
template <class _T_> void read(_T_ &d) {
d = 0;
int f = 1;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
if (c == '-')
f *= -1;
for (; c >= '0' && c <= '9'; c = getchar())
d = d * 10 + c - '0';
d *= f;
}
/************************************************/
#define Md 1000000007
#define MN 200005
int n, m;
char c[MN];
lg Pow(lg x, lg y) {
lg res = 1;
for (; y; y >>= 1, x = x * x % Md)
if (y & 1)
res = res * x % Md;
return res;
}
int Fix(int x) {
if (x < 0)
return x + Md;
if (x >= Md)
return x - Md;
return x;
}
int dp[MN], tmp[MN];
int miu[MN];
int main() {
read(n);
read(m);
scanf("%s", c + 1);
miu[1] = 1;
for (int i = 1; i < MN; ++i) {
for (int j = i + i; j < MN; j += i) {
miu[j] -= miu[i];
}
}
char Hd = c[1];
int cnt = 0, mx;
for (int i = 1; i <= m; ++i) {
if (c[i] == Hd)
++cnt;
else
break;
}
if (cnt & 1)
mx = cnt;
else
mx = cnt + 1;
if ((n & 1) && cnt != m)
return puts("0"), 0;
if (cnt == m) {
int res = 0;
tmp[0] = 1;
dp[0] = 1;
if (n >= 2)
res = n;
for (int i = 1; i < n - 1; ++i) {
dp[i] = (i >= 2 ? tmp[i - 2] : 0);
tmp[i] = Fix(tmp[i - 1] + dp[i]);
res = Fix(res + 1ll * dp[i] * (n - i) % Md);
}
printf("%d", res + 1);
return 0;
}
int res = (cnt == m);
cnt = 0;
for (int i = 1; i <= m; ++i) {
if (c[i] == Hd)
++cnt;
else {
if (!cnt)
continue;
if (cnt & 1)
mx = min(mx, cnt);
cnt = 0;
}
}
// for(int i=1;i<=5;++i)cerr<<miu[i]<<' ';cerr<<endl;
tmp[0] = tmp[1] = 1;
dp[0] = 1;
mx += 2;
if (n < mx)
res += n;
for (int i = 2; i <= n; i += 2) {
dp[i] = Fix(tmp[i - 1] - (mx > i ? 0 : tmp[i - mx]));
tmp[i] = tmp[i + 1] = Fix(tmp[i - 1] + dp[i]);
// cerr<<dp[i]<<' '<<i<<endl;
if ((n - i) % 2 == 0 && n - i < mx)
res = Fix(res + 1ll * dp[i] * (n - i) % Md);
}
cout << res;
return 0;
}
| [
"assignment.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 874,511 | 874,512 | u236677506 | cpp |
p03057 | /*{{{*/
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define CASET \
int ___T; \
scanf("%d", &___T); \
for (int cs = 1; cs <= ___T; cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
template <class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(LL &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U> void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const LL &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U> void _W(const pair<T, U> &x) {
_W(x.F);
putchar(' ');
_W(x.S);
}
template <class T> void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin())
putchar(' ');
}
void W() {}
template <class T, class... U> void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
#ifdef HOME
#define DEBUG(...) \
{ \
printf("# "); \
printf(__VA_ARGS__); \
puts(""); \
}
#else
#define DEBUG(...)
#endif
int MOD = 1e9 + 7;
void ADD(LL &x, LL v) {
x = (x + v) % MOD;
if (x < 0)
x += MOD;
}
/*}}}*/
const int SIZE = 1e6 + 10;
LL dp[SIZE][2][2];
void solve_same(int N) {
dp[1][0][0] = 1;
dp[1][1][1] = 1;
REPP(i, 1, N) {
REP(j, 2) {
ADD(dp[i + 1][j][0], dp[i][j][1]);
ADD(dp[i + 1][j][1], dp[i][j][0]);
ADD(dp[i + 1][j][1], dp[i][j][1]);
}
}
LL an = 0;
ADD(an, dp[N][0][1]);
ADD(an, dp[N][1][1]);
ADD(an, dp[N][1][0]);
W(an);
}
LL mypow(LL x, LL y) {
x %= MOD;
LL res = 1 % MOD;
while (y) {
if (y & 1)
res = res * x % MOD;
y >>= 1;
x = x * x % MOD;
}
return res;
}
LL dp2[SIZE], dp2_sum[SIZE];
void solve(int ma, int N) {
LL an = 0;
if (ma + 1 >= N) {
ADD(an, (mypow(2, N / 2) - 1) * 2);
} else {
ma = (ma + 1) / 2;
dp2[0] = dp2_sum[0] = 1;
FOR(i, 1, N / 2) {
dp2_sum[i] = dp2_sum[i - 1];
dp2[i] = dp2_sum[i - 1];
if (i > ma)
ADD(dp2[i], -dp2_sum[i - ma - 1]);
ADD(dp2_sum[i], dp2[i]);
}
ADD(an, dp2[N / 2]);
FOR(i, 2, ma) { ADD(an, (i - 1) * dp2[N / 2 - i]); }
ADD(an, an);
}
W(an);
}
int main() {
int N, M;
R(N, M);
string s;
R(s);
bool same = 1;
REPP(i, 1, M) {
if (s[i] != s[i - 1])
same = 0;
}
if (same)
solve_same(N);
else {
if (N % 2) {
W(0);
return 0;
}
VI AA;
for (int i = 0, j; i < M; i = j) {
for (j = i + 1; j < M && s[j] == s[i]; j++)
;
if (s[i] == s[0])
AA.PB(j - i);
}
int ma = -1;
if (AA[0] % 2)
ma = AA[0];
else
ma = AA[0] + 1;
REPP(i, 1, SZ(AA)) {
if (AA[i] % 2 == 1)
ma = min(ma, AA[i]);
}
solve(ma, N);
}
return 0;
}
| /*{{{*/
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define CASET \
int ___T; \
scanf("%d", &___T); \
for (int cs = 1; cs <= ___T; cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
template <class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(LL &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U> void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const LL &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U> void _W(const pair<T, U> &x) {
_W(x.F);
putchar(' ');
_W(x.S);
}
template <class T> void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin())
putchar(' ');
}
void W() {}
template <class T, class... U> void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
#ifdef HOME
#define DEBUG(...) \
{ \
printf("# "); \
printf(__VA_ARGS__); \
puts(""); \
}
#else
#define DEBUG(...)
#endif
int MOD = 1e9 + 7;
void ADD(LL &x, LL v) {
x = (x + v) % MOD;
if (x < 0)
x += MOD;
}
/*}}}*/
const int SIZE = 1e6 + 10;
LL dp[SIZE][2][2];
void solve_same(int N) {
dp[1][0][0] = 1;
dp[1][1][1] = 1;
REPP(i, 1, N) {
REP(j, 2) {
ADD(dp[i + 1][j][0], dp[i][j][1]);
ADD(dp[i + 1][j][1], dp[i][j][0]);
ADD(dp[i + 1][j][1], dp[i][j][1]);
}
}
LL an = 0;
ADD(an, dp[N][0][1]);
ADD(an, dp[N][1][1]);
ADD(an, dp[N][1][0]);
W(an);
}
LL mypow(LL x, LL y) {
x %= MOD;
LL res = 1 % MOD;
while (y) {
if (y & 1)
res = res * x % MOD;
y >>= 1;
x = x * x % MOD;
}
return res;
}
LL dp2[SIZE], dp2_sum[SIZE];
void solve(int ma, int N) {
LL an = 0;
if (ma + 1 >= N) {
ADD(an, (mypow(2, N / 2) - 1) * 2);
} else {
ma = (ma + 1) / 2;
dp2[0] = dp2_sum[0] = 1;
FOR(i, 1, N / 2) {
dp2_sum[i] = dp2_sum[i - 1];
dp2[i] = dp2_sum[i - 1];
if (i > ma)
ADD(dp2[i], -dp2_sum[i - ma - 1]);
ADD(dp2_sum[i], dp2[i]);
}
ADD(an, dp2[N / 2]);
FOR(i, 2, ma) { ADD(an, (i - 1) * dp2[N / 2 - i]); }
ADD(an, an);
}
W(an);
}
int main() {
int N, M;
R(N, M);
string s;
R(s);
bool same = 1;
REPP(i, 1, M) {
if (s[i] != s[i - 1])
same = 0;
}
if (same)
solve_same(N);
else {
if (N % 2) {
W(0);
return 0;
}
VI AA;
for (int i = 0, j; i < M; i = j) {
for (j = i + 1; j < M && s[j] == s[i]; j++)
;
if (s[i] == s[0] && j != M)
AA.PB(j - i);
}
int ma = -1;
if (AA[0] % 2)
ma = AA[0];
else
ma = AA[0] + 1;
REPP(i, 1, SZ(AA)) {
if (AA[i] % 2 == 1)
ma = min(ma, AA[i]);
}
solve(ma, N);
}
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 874,519 | 874,520 | u284124505 | cpp |
p03057 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define MP make_pair
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int MOD = 1e9 + 7;
int n, m;
char S[200005];
vector<int> sizs;
int dp[200005], prs[200005];
int main() {
scanf("%d%d%s", &n, &m, S);
int ccnt = 1;
for (int i = 1; i < m; i++)
if (S[i] != S[i - 1]) {
sizs.push_back(ccnt);
ccnt = 1;
} else
ccnt++;
sizs.push_back(ccnt);
if (sizs.size() == 1) {
dp[1] = 2;
dp[2] = MOD - 1;
rep(i, n) {
if (i >= 1)
dp[i] = (dp[i] + dp[i - 1]) % MOD;
}
rep(i, n) {
if (i >= 1)
dp[i] = (dp[i] + dp[i - 1]) % MOD;
if (i >= 2)
dp[i] = (dp[i] + dp[i - 2]) % MOD;
}
printf("%d\n", dp[n - 1] + 1);
} else {
int maxl = min(n, sizs[0] + 2);
rep(i, sizs.size()) if (i < sizs.size() && !(i & 1) && sizs[i] & 1) maxl =
min(maxl, sizs[i] + 1);
rep1(i, maxl) if (!(i & 1)) dp[i] = i;
rep1(i, n) {
if (i >= 2)
dp[i] = (dp[i] + prs[i - 2]) % MOD;
if (i >= 2 + maxl)
dp[i] = (dp[i] + (MOD - 1LL) * prs[i - 2 - maxl]) % MOD;
if (i >= 2)
prs[i] = (dp[i] + prs[i - 2]) % MOD;
}
printf("%d\n", dp[n]);
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define MP make_pair
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int MOD = 1e9 + 7;
int n, m;
char S[200005];
vector<int> sizs;
int dp[200005], prs[200005];
int main() {
scanf("%d%d%s", &n, &m, S);
int ccnt = 1;
for (int i = 1; i < m; i++)
if (S[i] != S[i - 1]) {
sizs.push_back(ccnt);
ccnt = 1;
} else
ccnt++;
sizs.push_back(ccnt);
if (sizs.size() == 1) {
dp[1] = 2;
dp[2] = MOD - 1;
rep(i, n) {
if (i >= 1)
dp[i] = (dp[i] + dp[i - 1]) % MOD;
}
rep(i, n) {
if (i >= 1)
dp[i] = (dp[i] + dp[i - 1]) % MOD;
if (i >= 2)
dp[i] = (dp[i] + dp[i - 2]) % MOD;
}
printf("%d\n", dp[n - 1] + 1);
} else {
int maxl = min(n, sizs[0] + 2);
rep(i, sizs.size()) if (i + 1 < sizs.size() && !(i & 1) && (sizs[i] & 1))
maxl = min(maxl, sizs[i] + 1);
rep1(i, maxl) if (!(i & 1)) dp[i] = i;
rep1(i, n) {
if (i >= 2)
dp[i] = (dp[i] + prs[i - 2]) % MOD;
if (i >= 2 + maxl)
dp[i] = (dp[i] + (MOD - 1LL) * prs[i - 2 - maxl]) % MOD;
if (i >= 2)
prs[i] = (dp[i] + prs[i - 2]) % MOD;
}
printf("%d\n", dp[n]);
}
return 0;
} | [
"control_flow.branch.if.condition.change"
] | 874,524 | 874,525 | u103391254 | cpp |
p03057 | #include <bits/stdc++.h>
using namespace std;
const int md = (int)1e9 + 7;
inline void add(int &x, int y) {
x += y;
if (x >= md) {
x -= md;
}
}
inline void sub(int &x, int y) {
x -= y;
if (x < 0) {
x += md;
}
}
inline int mul(int x, int y) { return (int)((long long)x * y % md); }
int main() {
#ifdef wxh010910
freopen("input.txt", "r", stdin);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
string s;
cin >> n >> m >> s;
if (s[0] == 'B') {
for (auto &c : s) {
c ^= 'R' ^ 'B';
}
}
int first = m;
for (int i = 0; i < m; ++i) {
if (s[i] == 'B') {
first = i;
break;
}
}
if (first == m) {
vector<int> dp(4);
dp[0] = dp[3] = 1;
for (int i = 1; i < n; ++i) {
vector<int> new_dp(4);
for (int a = 0; a < 2; ++a) {
for (int b = 0; b < 2; ++b) {
for (int c = 0; c < 2; ++c) {
if (!b || !c) {
add(new_dp[a * 2 + b], dp[a * 2 + c]);
}
}
}
}
swap(dp, new_dp);
}
int ans = 0;
for (int i = 0; i < 3; ++i) {
add(ans, dp[i]);
}
cout << ans << "\n";
return 0;
}
int last = m - 1;
while (s[last] == 'R') {
--last;
}
int limit = n, cur = 0;
for (int i = last; i >= -1; --i) {
if (i == -1 || s[i] == 'B') {
if (cur) {
if (cur & 1) {
limit = min(limit, cur + 1);
} else if (i == -1) {
limit = min(limit, cur + 2);
}
cur = 0;
}
} else {
++cur;
}
}
vector<int> dp(n + 1);
dp[0] = dp[2] = 1;
for (int i = 3; i <= n; ++i) {
dp[i] = mul(dp[i - 2], 2);
if (i >= limit + 2) {
sub(dp[i], dp[i - (limit + 2)]);
}
}
int ans = 0;
for (int i = 2; i <= limit; ++i) {
add(ans, mul(dp[n - i], i));
}
cout << ans << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int md = (int)1e9 + 7;
inline void add(int &x, int y) {
x += y;
if (x >= md) {
x -= md;
}
}
inline void sub(int &x, int y) {
x -= y;
if (x < 0) {
x += md;
}
}
inline int mul(int x, int y) { return (int)((long long)x * y % md); }
int main() {
#ifdef wxh010910
freopen("input.txt", "r", stdin);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
string s;
cin >> n >> m >> s;
if (s[0] == 'B') {
for (auto &c : s) {
c ^= 'R' ^ 'B';
}
}
int first = m;
for (int i = 0; i < m; ++i) {
if (s[i] == 'B') {
first = i;
break;
}
}
if (first == m) {
vector<int> dp(4);
dp[0] = dp[3] = 1;
for (int i = 1; i < n; ++i) {
vector<int> new_dp(4);
for (int a = 0; a < 2; ++a) {
for (int b = 0; b < 2; ++b) {
for (int c = 0; c < 2; ++c) {
if (!b || !c) {
add(new_dp[a * 2 + b], dp[a * 2 + c]);
}
}
}
}
swap(dp, new_dp);
}
int ans = 0;
for (int i = 0; i < 3; ++i) {
add(ans, dp[i]);
}
cout << ans << "\n";
return 0;
}
int last = m - 1;
while (s[last] == 'R') {
--last;
}
int limit = n, cur = 0;
for (int i = last; i >= -1; --i) {
if (i == -1 || s[i] == 'B') {
if (cur) {
if (cur & 1) {
limit = min(limit, cur + 1);
} else if (i == -1) {
limit = min(limit, cur + 2);
}
cur = 0;
}
} else {
++cur;
}
}
vector<int> dp(n + 1);
dp[0] = dp[2] = 1;
for (int i = 4; i <= n; ++i) {
dp[i] = mul(dp[i - 2], 2);
if (i >= limit + 2) {
sub(dp[i], dp[i - (limit + 2)]);
}
}
int ans = 0;
for (int i = 2; i <= limit; i += 2) {
add(ans, mul(dp[n - i], i));
}
cout << ans << "\n";
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.update.change",
"assignment.change"
] | 874,532 | 874,533 | u877679608 | cpp |
p03057 | #include <bits/stdc++.h>
#define ll long long
#define inf 1010000000
#define infll 1010000000000000000ll
#define pii pair<int, int>
#define pll pair<ll, ll>
#define mpr make_pair
#define fi first
#define se second
#define vi vector<int>
#define pb push_back
#define mod 1000000007
#define ad(x, y) (x = (x + (y)) % mod)
#define up(x, y) (x < (y) ? x = (y) : 0)
#define dn(x, y) (x > (y) ? x = (y) : 0)
#define N 200009
using namespace std;
int n, m, dp[N][2][2], f[N];
char ch[N];
vi e;
void solve0() {
int i, j, k, l;
dp[1][0][0] = dp[1][1][1] = 1;
for (i = 2; i <= n; i++)
for (j = 0; j < 2; j++)
for (k = 0; k < 2; k++)
for (l = 0; k + l < 2; l++)
ad(dp[i][j][l], dp[i - 1][j][k]);
printf("%d\n", ((dp[n][0][0] + dp[n][0][1]) % mod + dp[n][1][0]) % mod);
}
int main() {
scanf("%d%d%s", &n, &m, ch + 1);
int i;
if (ch[1] == 'B')
for (i = 1; i <= n; i++)
ch[i] = (ch[i] == 'R' ? 'B' : 'R');
for (i = 2; i <= n; i++)
if (ch[i] == 'B')
break;
if (i > n) {
solve0();
return 0;
}
memset(dp, 0, sizeof(dp));
for (i = n; i; i--)
if (ch[i] == 'B')
break;
int lim = n, now = 0;
for (; i >= 0; i--) {
if (!i || ch[i] == 'B') {
if (now)
e.pb(now);
now = 0;
} else
now++;
}
reverse(e.begin(), e.end());
for (i = 0; i < e.size(); i++) {
if (i == 0 && !(e[i] & 1))
dn(lim, e[i] + 2);
if (e[i] & 1)
dn(lim, e[i] + 1);
}
f[0] = f[2] = 1;
for (i = 3; i <= n; i++)
f[i] = ((ll)f[i - 2] - (i - 2 - lim >= 0 ? f[i - 2 - lim] : 0) + f[i - 2] +
mod) %
mod;
int ans = 0;
for (i = 2; i <= lim; i += 2)
ad(ans, (ll)f[n - i] * i);
printf("%d\n", ans);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define inf 1010000000
#define infll 1010000000000000000ll
#define pii pair<int, int>
#define pll pair<ll, ll>
#define mpr make_pair
#define fi first
#define se second
#define vi vector<int>
#define pb push_back
#define mod 1000000007
#define ad(x, y) (x = (x + (y)) % mod)
#define up(x, y) (x < (y) ? x = (y) : 0)
#define dn(x, y) (x > (y) ? x = (y) : 0)
#define N 200009
using namespace std;
int n, m, dp[N][2][2], f[N];
char ch[N];
vi e;
void solve0() {
int i, j, k, l;
dp[1][0][0] = dp[1][1][1] = 1;
for (i = 2; i <= n; i++)
for (j = 0; j < 2; j++)
for (k = 0; k < 2; k++)
for (l = 0; k + l < 2; l++)
ad(dp[i][j][l], dp[i - 1][j][k]);
printf("%d\n", ((dp[n][0][0] + dp[n][0][1]) % mod + dp[n][1][0]) % mod);
}
int main() {
scanf("%d%d%s", &n, &m, ch + 1);
int i;
if (ch[1] == 'B')
for (i = 1; i <= m; i++)
ch[i] = (ch[i] == 'R' ? 'B' : 'R');
for (i = 2; i <= m; i++)
if (ch[i] == 'B')
break;
if (i > m) {
solve0();
return 0;
}
memset(dp, 0, sizeof(dp));
for (i = m; i; i--)
if (ch[i] == 'B')
break;
int lim = n, now = 0;
for (; i >= 0; i--) {
if (!i || ch[i] == 'B') {
if (now)
e.pb(now);
now = 0;
} else
now++;
}
reverse(e.begin(), e.end());
for (i = 0; i < e.size(); i++) {
if (i == 0 && !(e[i] & 1))
dn(lim, e[i] + 2);
if (e[i] & 1)
dn(lim, e[i] + 1);
}
f[0] = f[2] = 1;
for (i = 3; i <= n; i++)
f[i] = ((ll)f[i - 2] - (i - 2 - lim >= 0 ? f[i - 2 - lim] : 0) + f[i - 2] +
mod) %
mod;
int ans = 0;
for (i = 2; i <= lim; i += 2)
ad(ans, (ll)f[n - i] * i);
printf("%d\n", ans);
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.value.change",
"control_flow.loop.for.initializer.change"
] | 874,538 | 874,539 | u070528238 | cpp |
p03058 | #include <bits/stdc++.h>
const int N = 2005;
struct edge {
int to, nxt;
} e[N << 1];
int n, m, head[N], tot;
void link(int x, int y) {
e[++tot] = (edge){y, head[x]}, head[x] = tot;
e[++tot] = (edge){x, head[y]}, head[y] = tot;
}
typedef std::bitset<N> bitset;
int f[N], next[N][N], lca[N][N];
bitset path[N], sub[N];
void dfs(int x) {
path[x].set(x), sub[x].set(x);
for (int i = head[x]; i; i = e[i].nxt)
if (e[i].to != f[x]) {
path[e[i].to] = path[x], f[e[i].to] = x, dfs(e[i].to);
for (int j = sub[e[i].to]._Find_first(); j < N;
j = sub[e[i].to]._Find_next(j)) {
next[i][j] = e[i].to;
for (int k = sub[x]._Find_first(); k < N; k = sub[x]._Find_next(k))
lca[j][k] = lca[k][j] = x;
}
sub[x] |= sub[e[i].to];
}
}
bitset near[N], U;
std::queue<std::pair<int, int>> q;
int edge_num = 0;
void _link(int x, int y) {
near[x].set(y), near[y].set(x), q.emplace(x, y), ++edge_num;
}
inline bitset get_path(int x, int y) {
bitset ret = path[x] ^ path[y];
ret.set(lca[x][y]);
return ret;
}
inline bitset subtree(int x, int y) {
if (sub[x].test(y))
std::swap(x, y);
if (sub[y].test(x))
return sub[x] | U ^ sub[next[y][x]];
else
return sub[x] | sub[y];
}
inline bitset get(int x, int y) { return subtree(x, y) | get_path(x, y); }
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n >> m;
for (int i = 1; i <= n; ++i)
U.set(i), near[i].set(i);
for (int i = 1, x, y; i < n; ++i)
std::cin >> x >> y, link(x, y);
dfs(1);
for (int i = 0, x, y; i < m; ++i)
std::cin >> x >> y, _link(x, y);
while (q.size()) {
auto tmp = q.front();
q.pop();
bitset t =
(near[tmp.first] ^ near[tmp.second]) & get(tmp.first, tmp.second);
for (int x = t._Find_first(); x < N; x = t._Find_next(x)) {
int v = near[tmp.first].test(x) ? tmp.second : tmp.first;
_link(x, v);
}
}
std::cout << edge_num << '\n';
return 0;
} | #include <bits/stdc++.h>
const int N = 2005;
struct edge {
int to, nxt;
} e[N << 1];
int n, m, head[N], tot;
void link(int x, int y) {
e[++tot] = (edge){y, head[x]}, head[x] = tot;
e[++tot] = (edge){x, head[y]}, head[y] = tot;
}
typedef std::bitset<N> bitset;
int f[N], next[N][N], lca[N][N];
bitset path[N], sub[N];
void dfs(int x) {
path[x].set(x), sub[x].set(x);
for (int i = head[x]; i; i = e[i].nxt)
if (e[i].to != f[x]) {
path[e[i].to] = path[x], f[e[i].to] = x, dfs(e[i].to);
for (int j = sub[e[i].to]._Find_first(); j < N;
j = sub[e[i].to]._Find_next(j)) {
next[x][j] = e[i].to;
for (int k = sub[x]._Find_first(); k < N; k = sub[x]._Find_next(k))
lca[j][k] = lca[k][j] = x;
}
sub[x] |= sub[e[i].to];
}
}
bitset near[N], U;
std::queue<std::pair<int, int>> q;
int edge_num = 0;
void _link(int x, int y) {
near[x].set(y), near[y].set(x), q.emplace(x, y), ++edge_num;
}
inline bitset get_path(int x, int y) {
bitset ret = path[x] ^ path[y];
ret.set(lca[x][y]);
return ret;
}
inline bitset subtree(int x, int y) {
if (sub[x].test(y))
std::swap(x, y);
if (sub[y].test(x))
return sub[x] | U ^ sub[next[y][x]];
else
return sub[x] | sub[y];
}
inline bitset get(int x, int y) { return subtree(x, y) | get_path(x, y); }
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n >> m;
for (int i = 1; i <= n; ++i)
U.set(i), near[i].set(i);
for (int i = 1, x, y; i < n; ++i)
std::cin >> x >> y, link(x, y);
dfs(1);
for (int i = 0, x, y; i < m; ++i)
std::cin >> x >> y, _link(x, y);
while (q.size()) {
auto tmp = q.front();
q.pop();
bitset t =
(near[tmp.first] ^ near[tmp.second]) & get(tmp.first, tmp.second);
for (int x = t._Find_first(); x < N; x = t._Find_next(x)) {
int v = near[tmp.first].test(x) ? tmp.second : tmp.first;
_link(x, v);
}
}
std::cout << edge_num << '\n';
return 0;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 874,546 | 874,547 | u561635563 | cpp |
p03061 | #include <algorithm>
#include <chrono>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <vector>
using namespace std;
long gcd(long a, long b) {
if (a < b)
return gcd(b, a);
else {
if (b == 1)
return 1;
else if (b == 0)
return a;
else
return gcd(b, a % b);
}
}
int main() {
int n;
cin >> n;
long a[n + 10];
a[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
long l[n + 10];
long r[n + 10];
l[0] = 0;
r[n + 1] = 0;
for (int i = 1; i <= n; i++) {
l[i] = gcd(l[i - 1], a[i - 1]);
}
for (int i = n; i > 0; i--) {
r[i] = gcd(r[i + 1], a[i]);
}
long m[n + 10];
for (int i = 1; i <= n; i++) {
m[i] = gcd(l[i - 1], r[i]);
}
long ans;
ans = m[1];
for (int i = 1; i <= n; i++) {
ans = max(ans, m[i]);
}
cout << ans << endl;
}
| #include <algorithm>
#include <chrono>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <vector>
using namespace std;
long gcd(long a, long b) {
if (a < b)
return gcd(b, a);
else {
if (b == 1)
return 1;
else if (b == 0)
return a;
else
return gcd(b, a % b);
}
}
int main() {
int n;
cin >> n;
long a[n + 10];
a[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
long l[n + 10];
long r[n + 10];
l[0] = 0;
r[n + 1] = 0;
for (int i = 1; i <= n; i++) {
l[i] = gcd(l[i - 1], a[i - 1]);
}
for (int i = n; i > 0; i--) {
r[i] = gcd(r[i + 1], a[i]);
}
long m[n + 10];
for (int i = 1; i <= n; i++) {
m[i] = gcd(l[i], r[i + 1]);
}
long ans;
ans = m[1];
for (int i = 1; i <= n; i++) {
ans = max(ans, m[i]);
}
cout << ans << endl;
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 874,548 | 874,549 | u714120941 | cpp |
p03061 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, st, n) for (int i = st; i < n; ++i)
using pii = pair<int, int>;
const int inf = 1e9 + 7;
int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
int dx[] = {1, -1, 0, 0, -1, 1, 1, -1};
#define ceil(a, b) a / b + !!(a % b)
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) {
return a / gcd(max(a, b), min(a, b)) * b; //先に割る!!
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int a[n];
rep(i, n) cin >> a[i];
int l[n];
l[0] = a[0];
rrep(i, 1, n) l[i] = gcd(a[i], l[i - 1]);
int r[n];
r[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; --i) {
r[i] = gcd(a[i], r[i + 1]);
}
int ans = 0;
if (n == 1) {
cout << a[0] << endl;
return 0;
} else if (n == 2) {
cout << gcd(a[0], a[1]) << endl;
return 0;
}
ans = max(r[1], l[n - 2]);
rep(i, n - 2) {
int tmp = gcd(l[i], r[i + 2]);
chmax(ans, tmp);
}
cout << ans << endl;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, st, n) for (int i = st; i < n; ++i)
using pii = pair<int, int>;
const int inf = 1e9 + 7;
int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
int dx[] = {1, -1, 0, 0, -1, 1, 1, -1};
#define ceil(a, b) a / b + !!(a % b)
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) {
return a / gcd(max(a, b), min(a, b)) * b; //先に割る!!
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int a[n];
rep(i, n) cin >> a[i];
int l[n];
l[0] = a[0];
rrep(i, 1, n) l[i] = gcd(a[i], l[i - 1]);
int r[n];
r[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; --i) {
r[i] = gcd(a[i], r[i + 1]);
}
int ans = 0;
if (n == 1) {
cout << a[0] << endl;
return 0;
} else if (n == 2) {
cout << max(a[0], a[1]) << endl;
return 0;
}
ans = max(r[1], l[n - 2]);
rep(i, n - 2) {
int tmp = gcd(l[i], r[i + 2]);
chmax(ans, tmp);
}
cout << ans << endl;
}
| [
"identifier.change",
"call.function.change",
"io.output.change"
] | 874,551 | 874,552 | u277556971 | cpp |
p03061 | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, st, n) for (int i = st; i < n; ++i)
using pii = pair<int, int>;
const int inf = 1e9 + 7;
int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
int dx[] = {1, -1, 0, 0, -1, 1, 1, -1};
#define ceil(a, b) a / b + !!(a % b)
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) {
return a / gcd(max(a, b), min(a, b)) * b; //先に割る!!
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int a[n];
rep(i, n) cin >> a[i];
int l[n];
l[0] = a[0];
rrep(i, 1, n) l[i] = gcd(a[i], l[i - 1]);
int r[n];
r[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; --i) {
r[i] = gcd(a[i], r[i + 1]);
}
int ans = 0;
if (n == 1) {
cout << a[0] << endl;
return 0;
} else if (n == 2) {
cout << gcd(a[0], a[1]) << endl;
return 0;
}
ans = max(r[1], l[n - 1]);
rep(i, n - 2) {
int tmp = gcd(l[i], r[i + 2]);
chmax(ans, tmp);
}
cout << ans << endl;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, st, n) for (int i = st; i < n; ++i)
using pii = pair<int, int>;
const int inf = 1e9 + 7;
int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
int dx[] = {1, -1, 0, 0, -1, 1, 1, -1};
#define ceil(a, b) a / b + !!(a % b)
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
template <typename T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) {
return a / gcd(max(a, b), min(a, b)) * b; //先に割る!!
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int a[n];
rep(i, n) cin >> a[i];
int l[n];
l[0] = a[0];
rrep(i, 1, n) l[i] = gcd(a[i], l[i - 1]);
int r[n];
r[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; --i) {
r[i] = gcd(a[i], r[i + 1]);
}
int ans = 0;
if (n == 1) {
cout << a[0] << endl;
return 0;
} else if (n == 2) {
cout << max(a[0], a[1]) << endl;
return 0;
}
ans = max(r[1], l[n - 2]);
rep(i, n - 2) {
int tmp = gcd(l[i], r[i + 2]);
chmax(ans, tmp);
}
cout << ans << endl;
}
| [
"identifier.change",
"call.function.change",
"io.output.change",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 874,553 | 874,552 | u277556971 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b != 0) {
return gcd(b, a % b);
}
return a;
}
int main() {
int N, p = 0;
cin >> N;
vector<int> A(N), right(N), left(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
right.at(N - 1) = A.at(N - 1);
left.at(0) = A.at(0);
for (int i = 1; i < N; i++) {
left.at(i) = gcd(A.at(i - 1), left.at(i - 1));
}
for (int i = N - 2; i >= 0; i--) {
right.at(i) = gcd(A.at(i + 1), right.at(i + 1));
}
right.at(N - 1) = left.at(0) = 0;
int c, ma = max(right.at(0), left.at(N - 1));
for (int i = 0; i < N; i++) {
c = gcd(right.at(i), left.at(i));
if (c > ma) {
ma = c;
}
}
cout << right.at(0) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b != 0) {
return gcd(b, a % b);
}
return a;
}
int main() {
int N, p = 0;
cin >> N;
vector<int> A(N), right(N), left(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
right.at(N - 1) = A.at(N - 1);
left.at(0) = A.at(0);
for (int i = 1; i < N; i++) {
left.at(i) = gcd(A.at(i - 1), left.at(i - 1));
}
for (int i = N - 2; i >= 0; i--) {
right.at(i) = gcd(A.at(i + 1), right.at(i + 1));
}
right.at(N - 1) = left.at(0) = 0;
int c, ma = max(right.at(0), left.at(N - 1));
for (int i = 0; i < N; i++) {
c = gcd(right.at(i), left.at(i));
if (c > ma) {
ma = c;
}
}
cout << ma << endl;
return 0;
} | [
"io.output.change",
"call.remove"
] | 874,567 | 874,568 | u313578168 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b != 0) {
return gcd(b, a % b);
}
return a;
}
int main() {
int N, p = 0;
cin >> N;
vector<int> A(N), right(N), left(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
right.at(N - 1) = A.at(N - 1);
left.at(0) = A.at(0);
for (int i = 1; i < N; i++) {
left.at(i) = gcd(A.at(i - 1), left.at(i - 1));
}
for (int i = N - 2; i > 0; i--) {
right.at(i) = gcd(A.at(i + 1), right.at(i + 1));
}
right.at(N - 1) = left.at(0) = 0;
int c, ma = max(right.at(0), left.at(N - 1));
for (int i = 0; i < N; i++) {
c = gcd(right.at(i), left.at(i));
if (c > ma) {
ma = c;
}
}
cout << ma << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b != 0) {
return gcd(b, a % b);
}
return a;
}
int main() {
int N, p = 0;
cin >> N;
vector<int> A(N), right(N), left(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
right.at(N - 1) = A.at(N - 1);
left.at(0) = A.at(0);
for (int i = 1; i < N; i++) {
left.at(i) = gcd(A.at(i - 1), left.at(i - 1));
}
for (int i = N - 2; i >= 0; i--) {
right.at(i) = gcd(A.at(i + 1), right.at(i + 1));
}
right.at(N - 1) = left.at(0) = 0;
int c, ma = max(right.at(0), left.at(N - 1));
for (int i = 0; i < N; i++) {
c = gcd(right.at(i), left.at(i));
if (c > ma) {
ma = c;
}
}
cout << ma << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 874,569 | 874,568 | u313578168 | cpp |
p03061 | #include <iostream>
#include <vector>
using namespace std;
int GCD(int a, int b) { return a % b == 0 ? b : GCD(b, a % b); }
int main() {
int N;
cin >> N;
vector<int> A(N, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
vector<int> left(N - 1, 0);
vector<int> right(N - 1, 0);
left[0] = A[0];
right[0] = A[N - 1];
for (int i = 0; i < N - 2; i++) {
left[i + 1] = GCD(A[i + 1], left[i]);
right[i + 1] = GCD(A[N - i - 2], right[i]);
}
int k, MaxGCD = max(left[N - 2], right[N - 2]);
for (int i = 0; i < N - 2; i++) {
k = GCD(left[i], right[N - i - 2]);
MaxGCD = max(MaxGCD, k);
}
cout << MaxGCD << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int GCD(int a, int b) { return a % b == 0 ? b : GCD(b, a % b); }
int main() {
int N;
cin >> N;
vector<int> A(N, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
vector<int> left(N - 1, 0);
vector<int> right(N - 1, 0);
left[0] = A[0];
right[0] = A[N - 1];
for (int i = 0; i < N - 2; i++) {
left[i + 1] = GCD(A[i + 1], left[i]);
right[i + 1] = GCD(A[N - i - 2], right[i]);
}
int k, MaxGCD = max(left[N - 2], right[N - 2]);
for (int i = 0; i < N - 2; i++) {
k = GCD(left[i], right[N - i - 3]);
MaxGCD = max(MaxGCD, k);
}
cout << MaxGCD << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 874,570 | 874,571 | u070471279 | cpp |
p03061 | #include <iostream>
#include <vector>
using namespace std;
int GCD(int a, int b) { return a % b == 0 ? b : GCD(b, a % b); }
int main() {
int N;
cin >> N;
vector<int> A(N, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
vector<int> left(N - 1, 0);
vector<int> right(N - 1, 0);
left[0] = A[0];
right[0] = A[N - 1];
for (int i = 0; i < N - 1; i++) {
left[i + 1] = GCD(A[i + 1], left[i]);
right[i + 1] = GCD(A[N - i - 1], right[i]);
}
int k, MaxGCD = max(left[N - 1], right[N - 1]);
for (int i = 0; i < N - 2; i++) {
k = GCD(left[i], right[N - i - 2]);
MaxGCD = max(MaxGCD, k);
}
cout << MaxGCD << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int GCD(int a, int b) { return a % b == 0 ? b : GCD(b, a % b); }
int main() {
int N;
cin >> N;
vector<int> A(N, 0);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
vector<int> left(N - 1, 0);
vector<int> right(N - 1, 0);
left[0] = A[0];
right[0] = A[N - 1];
for (int i = 0; i < N - 2; i++) {
left[i + 1] = GCD(A[i + 1], left[i]);
right[i + 1] = GCD(A[N - i - 2], right[i]);
}
int k, MaxGCD = max(left[N - 2], right[N - 2]);
for (int i = 0; i < N - 2; i++) {
k = GCD(left[i], right[N - i - 3]);
MaxGCD = max(MaxGCD, k);
}
cout << MaxGCD << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 874,572 | 874,571 | u070471279 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b)
return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
int n, i;
std::cin >> n;
long long int a[n];
long long int front[n], back[n];
for (i = 0; i < n; i++) {
std::cin >> a[i];
}
if (n == 2)
std::cout << max(a[0], a[1]) << std::endl;
if (n >= 3) {
front[0] = a[0];
back[n - 1] = a[n - 1];
for (i = 1; i < n; i++) {
front[i] = euclidean_gcd(front[i - 1], a[i]);
}
for (i = n - 2; i >= 0; i--) {
back[i] = euclidean_gcd(back[i + 1], a[i]);
}
int x;
int ans = max(front[n - 1], back[0]);
for (i = 1; i < n - 1; i++) {
x = euclidean_gcd(front[i - 1], back[i + 1]);
if (x > ans)
ans = x;
}
std::cout << ans << std::endl;
}
// std::cout <<ans << std::endl;
} | #include <bits/stdc++.h>
using namespace std;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b)
return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
int n, i;
std::cin >> n;
long long int a[n];
long long int front[n], back[n];
for (i = 0; i < n; i++) {
std::cin >> a[i];
}
if (n == 2)
std::cout << max(a[0], a[1]) << std::endl;
if (n >= 3) {
front[0] = a[0];
back[n - 1] = a[n - 1];
for (i = 1; i < n; i++) {
front[i] = euclidean_gcd(front[i - 1], a[i]);
}
for (i = n - 2; i >= 0; i--) {
back[i] = euclidean_gcd(back[i + 1], a[i]);
}
int x;
int ans = max(front[n - 2], back[1]);
for (i = 1; i < n - 1; i++) {
x = euclidean_gcd(front[i - 1], back[i + 1]);
if (x > ans)
ans = x;
}
std::cout << ans << std::endl;
}
// std::cout <<ans << std::endl;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 874,573 | 874,574 | u409569205 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b)
return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
int n, i;
std::cin >> n;
long long int a[n];
long long int front[n], back[n];
for (i = 0; i < n; i++) {
std::cin >> a[i];
}
if (n == 2)
std::cout << max(a[0], a[1]) << std::endl;
if (n >= 3) {
front[0] = a[0];
back[n - 1] = a[n - 1];
for (i = 1; i < n; i++) {
front[i] = euclidean_gcd(front[i - 1], a[i]);
}
for (i = n - 2; i >= 0; i--) {
back[i] = euclidean_gcd(back[i + 1], a[i]);
}
int x;
int ans = max(front[n - 1], back[1]);
for (i = 1; i < n - 1; i++) {
x = euclidean_gcd(front[i - 1], back[i + 1]);
if (x > ans)
ans = x;
}
std::cout << ans << std::endl;
}
// std::cout <<ans << std::endl;
} | #include <bits/stdc++.h>
using namespace std;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b)
return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
int n, i;
std::cin >> n;
long long int a[n];
long long int front[n], back[n];
for (i = 0; i < n; i++) {
std::cin >> a[i];
}
if (n == 2)
std::cout << max(a[0], a[1]) << std::endl;
if (n >= 3) {
front[0] = a[0];
back[n - 1] = a[n - 1];
for (i = 1; i < n; i++) {
front[i] = euclidean_gcd(front[i - 1], a[i]);
}
for (i = n - 2; i >= 0; i--) {
back[i] = euclidean_gcd(back[i + 1], a[i]);
}
int x;
int ans = max(front[n - 2], back[1]);
for (i = 1; i < n - 1; i++) {
x = euclidean_gcd(front[i - 1], back[i + 1]);
if (x > ans)
ans = x;
}
std::cout << ans << std::endl;
}
// std::cout <<ans << std::endl;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 874,575 | 874,574 | u409569205 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b)
return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
int n, i;
std::cin >> n;
long long int a[n];
long long int front[n], back[n];
for (i = 0; i < n; i++) {
std::cin >> a[i];
}
if (n == 2)
std::cout << euclidean_gcd(a[0], a[1]) << std::endl;
if (n >= 3) {
front[0] = a[0];
back[n - 1] = a[n - 1];
for (i = 1; i < n; i++) {
front[i] = euclidean_gcd(front[i - 1], a[i]);
}
for (i = n - 2; i >= 0; i--) {
back[i] = euclidean_gcd(back[i + 1], a[i]);
}
int x;
int ans = max(front[n - 1], back[1]);
for (i = 1; i < n - 1; i++) {
x = euclidean_gcd(front[i - 1], back[i + 1]);
if (x > ans)
ans = x;
}
std::cout << ans << std::endl;
}
// std::cout <<ans << std::endl;
} | #include <bits/stdc++.h>
using namespace std;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b)
return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
int main() {
int n, i;
std::cin >> n;
long long int a[n];
long long int front[n], back[n];
for (i = 0; i < n; i++) {
std::cin >> a[i];
}
if (n == 2)
std::cout << max(a[0], a[1]) << std::endl;
if (n >= 3) {
front[0] = a[0];
back[n - 1] = a[n - 1];
for (i = 1; i < n; i++) {
front[i] = euclidean_gcd(front[i - 1], a[i]);
}
for (i = n - 2; i >= 0; i--) {
back[i] = euclidean_gcd(back[i + 1], a[i]);
}
int x;
int ans = max(front[n - 2], back[1]);
for (i = 1; i < n - 1; i++) {
x = euclidean_gcd(front[i - 1], back[i + 1]);
if (x > ans)
ans = x;
}
std::cout << ans << std::endl;
}
// std::cout <<ans << std::endl;
} | [
"identifier.change",
"call.function.change",
"expression.operation.binary.change",
"literal.number.change",
"variable_access.subscript.index.change",
"call.arguments.change"
] | 874,576 | 874,574 | u409569205 | cpp |
p03061 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N;
cin >> N;
vector<int> data(N);
for (int i = 0; i < N; i++) {
cin >> data[i];
}
vector<int> left_gcd(N);
vector<int> right_gcd(N);
left_gcd[0] = data[0];
right_gcd[N - 1] = data[N - 1];
for (int i = 1; i < N - 1; i++) {
left_gcd[i] = __gcd(left_gcd[i - 1], data[i]);
right_gcd[N - 1 - i] = __gcd(right_gcd[N - i], data[N - 1 - i]);
}
int max = right_gcd[1];
for (int i = 1; i < N - 1; i++) {
int a = __gcd(left_gcd[i - 1], right_gcd[i + 1]);
if (max < a)
max = a;
}
if (left_gcd[N - 1] > max)
max = left_gcd[N - 1];
cout << max;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N;
cin >> N;
vector<int> data(N);
for (int i = 0; i < N; i++) {
cin >> data[i];
}
vector<int> left_gcd(N);
vector<int> right_gcd(N);
left_gcd[0] = data[0];
right_gcd[N - 1] = data[N - 1];
for (int i = 1; i < N - 1; i++) {
left_gcd[i] = __gcd(left_gcd[i - 1], data[i]);
right_gcd[N - 1 - i] = __gcd(right_gcd[N - i], data[N - 1 - i]);
}
int max = right_gcd[1];
for (int i = 1; i < N - 1; i++) {
int a = __gcd(left_gcd[i - 1], right_gcd[i + 1]);
if (max < a)
max = a;
}
if (left_gcd[N - 2] > max)
max = left_gcd[N - 2];
cout << max;
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 874,581 | 874,582 | u465631492 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0)
return b;
else if (b == 0)
return a;
if (a >= b)
return gcd(a % b, b);
else
return gcd(a, b % a);
}
int main(void) {
int n;
vector<int> a, l, r;
cin >> n;
a.resize(n);
l.resize(n);
r.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
l[0] = a[0];
for (int i = 1; i < n; i++) {
l[i] = gcd(l[i - 1], a[i]);
}
r[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
r[i] = gcd(r[i + 1], a[i]);
}
int max = 0;
int g = 0;
for (int i = 0; i < n; i++) {
if (i = 0)
g = gcd(0, r[i + 1]);
else if (i = n - 1)
g = gcd(l[i - 1], 0);
else
g = gcd(l[i - 1], r[i + 1]);
if (g > max)
max = g;
}
cout << max;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0)
return b;
else if (b == 0)
return a;
if (a >= b)
return gcd(a % b, b);
else
return gcd(a, b % a);
}
int main(void) {
int n;
vector<int> a, l, r;
cin >> n;
a.resize(n);
l.resize(n);
r.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
l[0] = a[0];
for (int i = 1; i < n; i++) {
l[i] = gcd(l[i - 1], a[i]);
}
r[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
r[i] = gcd(r[i + 1], a[i]);
}
int max = 0;
int g = 0;
for (int i = 0; i < n; i++) {
if (i == 0)
g = gcd(0, r[i + 1]);
else if (i == n - 1)
g = gcd(l[i - 1], 0);
else
g = gcd(l[i - 1], r[i + 1]);
if (g > max)
max = g;
}
cout << max;
return 0;
} | [
"expression.operation.compare.replace.add",
"assignment.replace.remove",
"misc.typo"
] | 874,586 | 874,587 | u688509741 | cpp |
p03061 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// ascending order
#define vsort(v) sort(v.begin(), v.end())
// descending order
#define vsort_r(v) sort(v.begin(), v.end(), greater<int>())
#define vunique(v) unique(v.begin(), v.end())
#define mp make_pair
#define ts(x) to_string(x)
#define rep(i, a, b) for (int i = (int)a; i < (int)b; i++)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; i--)
#define bit(a) bitset<8>(a)
#define des_priority_queue priority_queue<int, vector<int>, greater<int>>
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1e18;
#define MAX_V 1000000
int N;
vector<int> A;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, 0, N) {
int tmp;
cin >> tmp;
A.push_back(tmp);
}
int L[N + 2], R[N + 2];
L[0] = R[N + 1] = 0;
rep(i, 0, N + 1) { L[i + 1] = gcd(L[i], A[i]); }
for (int i = N; i >= 0; i--) {
R[i] = gcd(R[i + 1], A[i]);
}
vector<int> m;
rep(i, 1, N + 1) { m.push_back(gcd(L[i], R[i + 1])); }
vsort_r(m);
cout << m[0] << endl;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// ascending order
#define vsort(v) sort(v.begin(), v.end())
// descending order
#define vsort_r(v) sort(v.begin(), v.end(), greater<int>())
#define vunique(v) unique(v.begin(), v.end())
#define mp make_pair
#define ts(x) to_string(x)
#define rep(i, a, b) for (int i = (int)a; i < (int)b; i++)
#define repm(i, a, b) for (int i = (int)a; i > (int)b; i--)
#define bit(a) bitset<8>(a)
#define des_priority_queue priority_queue<int, vector<int>, greater<int>>
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1e18;
#define MAX_V 1000000
int N;
vector<int> A;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, 0, N) {
int tmp;
cin >> tmp;
A.push_back(tmp);
}
int L[N + 2], R[N + 2];
L[0] = R[N + 1] = 0;
rep(i, 0, N + 1) { L[i + 1] = gcd(L[i], A[i]); }
for (int i = N; i >= 0; i--) {
R[i] = gcd(R[i + 1], A[i]);
}
vector<int> m;
rep(i, 0, N + 1) { m.push_back(gcd(L[i], R[i + 1])); }
vsort_r(m);
cout << m[0] << endl;
}
| [
"literal.number.change",
"call.arguments.change"
] | 874,588 | 874,589 | u355254193 | cpp |
p03061 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define ll long long
#define pb push_back
#define INF (ll)1e18
#define IINF (int)1e9
#define FASTIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define MOD 1000000000 + 7
#define F first
#define S second
#define sp << " " <<
/*rrrohan*/
using namespace std;
/*less than or equal to -> l + r + 1*/
/*class dsu{
private:
vector <int> r,p;
public:
dsu(int n){
p.resize(n+1);
r.resize(n+1);
for(int i = 0; i < n+1; i++){
p[i] = i;
r[i] = 0;
}
}
int findset(int i){
return (p[i] == i) ? i : (p[i] = findset(p[i]));
}
bool issameset(int a, int b){
return findset(a) == findset(b);
}
void unionset(int i, int j){
if(!issameset(i,j)){
int x = findset(i), y = findset(j);
if(r[x] > r[y]){
p[y] = x;
}else{
p[x] = y;
if(r[x] == r[y]){
r[y]++;
}
}
}
}
};
*/
ll gcd(ll a, ll b) // O(log(a+b))
{
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
ll arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
ll l[n];
ll r[n];
l[0] = arr[0], r[n - 1] = arr[n - 1];
for (int i = 1; i < n; i++) {
l[i] = gcd(l[i - 1], arr[i]);
}
for (int i = n - 2; i >= 0; i--) {
r[i] = gcd(arr[i + 1], r[i]);
}
ll mx = 0;
if (n > 2) {
for (int i = 1; i < n - 1; i++) {
mx = max(mx, gcd(l[i - 1], r[i + 1]));
}
// cout << r[0] << " " << l[n-1] << endl;
mx = max(mx, r[0]);
mx = max(mx, l[n - 1]);
cout << mx;
} else if (n == 2) {
cout << max(arr[0], arr[1]);
} else
cout << arr[0];
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define ll long long
#define pb push_back
#define INF (ll)1e18
#define IINF (int)1e9
#define FASTIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define MOD 1000000000 + 7
#define F first
#define S second
#define sp << " " <<
/*rrrohan*/
using namespace std;
/*less than or equal to -> l + r + 1*/
ll gcd(ll a, ll b) // O(log(a+b))
{
if (b == 0)
return a;
return gcd(b, a % b);
}
/*class dsu{
private:
vector <int> r,p;
public:
dsu(int n){
p.resize(n+1);
r.resize(n+1);
for(int i = 0; i < n+1; i++){
p[i] = i;
r[i] = 0;
}
}
int findset(int i){
return (p[i] == i) ? i : (p[i] = findset(p[i]));
}
bool issameset(int a, int b){
return findset(a) == findset(b);
}
void unionset(int i, int j){
if(!issameset(i,j)){
int x = findset(i), y = findset(j);
if(r[x] > r[y]){
p[y] = x;
}else{
p[x] = y;
if(r[x] == r[y]){
r[y]++;
}
}
}
}
};
*/
int main() {
int n;
cin >> n;
ll arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
ll l[n];
ll r[n];
l[0] = arr[0], r[n - 1] = arr[n - 1];
for (int i = 1; i < n; i++) {
l[i] = gcd(l[i - 1], arr[i]);
}
for (int i = n - 2; i >= 0; i--) {
r[i] = gcd(arr[i], r[i + 1]);
}
ll mx = 0;
if (n > 2) {
for (int i = 1; i < n - 1; i++) {
mx = max(mx, gcd(l[i - 1], r[i + 1]));
}
mx = max(mx, r[1]);
mx = max(mx, l[n - 2]);
cout << mx;
} else if (n == 2) {
cout << max(arr[0], arr[1]);
} else
cout << arr[0];
}
| [
"expression.operation.binary.remove",
"assignment.change",
"literal.number.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 874,598 | 874,599 | u923177560 | cpp |
p03061 | #include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int gcd(int a, int b) {
if (b < a) {
int t = b;
b = a;
a = t;
}
if (a == 0)
return b;
return b % a == 0 ? a : gcd(b % a, a);
}
int main() {
int n;
cin >> n;
vector<int> a(n), l(n + 1), r(n + 1);
for (size_t i = 0; i < n; i++) {
cin >> a[i];
}
for (size_t i = 1; i < n + 1; i++) {
if (i == 1) {
l[i] = a[i - 1];
} else {
// cout << "gcd " << l[i-1] << ":" << a[i-1] << endl;
l[i] = gcd(l[i - 1], a[i - 1]);
}
}
// cout << "==" << endl;
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1) {
r[i] = a[i];
} else {
// cout << "gcd " << r[i+1] << ":" << a[i+1] << endl;
r[i] = gcd(r[i + 1], a[i]);
}
}
// cout << "here" << endl;
int ans = 0;
for (size_t i = 0; i < n; i++) {
ans = max(ans, gcd(l[i], r[i]));
}
cout << ans << endl;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int gcd(int a, int b) {
if (b < a) {
int t = b;
b = a;
a = t;
}
if (a == 0)
return b;
return b % a == 0 ? a : gcd(b % a, a);
}
int main() {
int n;
cin >> n;
vector<int> a(n), l(n + 1), r(n + 1);
for (size_t i = 0; i < n; i++) {
cin >> a[i];
}
for (size_t i = 1; i < n + 1; i++) {
if (i == 1) {
l[i] = a[i - 1];
} else {
// cout << "gcd " << l[i-1] << ":" << a[i-1] << endl;
l[i] = gcd(l[i - 1], a[i - 1]);
}
}
// cout << "==" << endl;
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1) {
r[i] = a[i];
} else {
// cout << "gcd " << r[i+1] << ":" << a[i] << endl;
r[i] = gcd(r[i + 1], a[i]);
}
}
// cout << "here" << endl;
int ans = 0;
for (size_t i = 0; i < n; i++) {
ans = max(ans, gcd(l[i], r[i + 1]));
}
cout << ans << endl;
}
| [
"assignment.change"
] | 874,600 | 874,601 | u432551953 | cpp |
p03061 | #include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int gcd(int a, int b) {
if (b < a) {
int t = b;
b = a;
a = t;
}
if (a == 0)
return b;
return b % a == 0 ? a : gcd(b % a, a);
}
int main() {
int n;
cin >> n;
vector<int> a(n), l(n + 1), r(n + 1);
for (size_t i = 0; i < n; i++) {
cin >> a[i];
}
for (size_t i = 1; i < n + 1; i++) {
if (i == 1) {
l[i] = a[i - 1];
} else {
// cout << "gcd " << l[i-1] << ":" << a[i-1] << endl;
l[i] = gcd(l[i - 1], a[i - 1]);
}
}
// cout << "==" << endl;
for (int i = n - 1; i > 0; i--) {
if (i == n - 1) {
r[i] = a[i];
} else {
// cout << "gcd " << r[i+1] << ":" << a[i+1] << endl;
r[i] = gcd(r[i + 1], a[i + 1]);
}
}
// cout << "here" << endl;
int ans = 0;
for (size_t i = 0; i < n; i++) {
ans = max(ans, gcd(l[i], r[i]));
}
cout << ans << endl;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int gcd(int a, int b) {
if (b < a) {
int t = b;
b = a;
a = t;
}
if (a == 0)
return b;
return b % a == 0 ? a : gcd(b % a, a);
}
int main() {
int n;
cin >> n;
vector<int> a(n), l(n + 1), r(n + 1);
for (size_t i = 0; i < n; i++) {
cin >> a[i];
}
for (size_t i = 1; i < n + 1; i++) {
if (i == 1) {
l[i] = a[i - 1];
} else {
// cout << "gcd " << l[i-1] << ":" << a[i-1] << endl;
l[i] = gcd(l[i - 1], a[i - 1]);
}
}
// cout << "==" << endl;
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1) {
r[i] = a[i];
} else {
// cout << "gcd " << r[i+1] << ":" << a[i] << endl;
r[i] = gcd(r[i + 1], a[i]);
}
}
// cout << "here" << endl;
int ans = 0;
for (size_t i = 0; i < n; i++) {
ans = max(ans, gcd(l[i], r[i + 1]));
}
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"assignment.change"
] | 874,602 | 874,601 | u432551953 | cpp |
p03061 | #include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int gcd(int a, int b) {
if (b < a) {
int t = b;
b = a;
a = t;
}
if (a == 0)
return b;
return b % a == 0 ? a : gcd(b % a, a);
}
int main() {
int n;
cin >> n;
vector<int> a(n), l(n + 1), r(n + 1);
for (size_t i = 0; i < n; i++) {
cin >> a[i];
}
for (size_t i = 1; i < n + 1; i++) {
if (i == 1) {
l[i] = a[i - 1];
} else {
// cout << "gcd " << l[i-1] << ":" << a[i-1] << endl;
l[i] = gcd(l[i - 1], a[i - 1]);
}
}
// cout << "==" << endl;
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1) {
r[i] = a[i];
} else {
// cout << "gcd " << r[i+1] << ":" << a[i+1] << endl;
r[i] = gcd(r[i + 1], a[i + 1]);
}
}
// cout << "here" << endl;
int ans = 0;
for (size_t i = 0; i < n; i++) {
ans = max(ans, gcd(l[i], r[i]));
}
cout << ans << endl;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int gcd(int a, int b) {
if (b < a) {
int t = b;
b = a;
a = t;
}
if (a == 0)
return b;
return b % a == 0 ? a : gcd(b % a, a);
}
int main() {
int n;
cin >> n;
vector<int> a(n), l(n + 1), r(n + 1);
for (size_t i = 0; i < n; i++) {
cin >> a[i];
}
for (size_t i = 1; i < n + 1; i++) {
if (i == 1) {
l[i] = a[i - 1];
} else {
// cout << "gcd " << l[i-1] << ":" << a[i-1] << endl;
l[i] = gcd(l[i - 1], a[i - 1]);
}
}
// cout << "==" << endl;
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1) {
r[i] = a[i];
} else {
// cout << "gcd " << r[i+1] << ":" << a[i] << endl;
r[i] = gcd(r[i + 1], a[i]);
}
}
// cout << "here" << endl;
int ans = 0;
for (size_t i = 0; i < n; i++) {
ans = max(ans, gcd(l[i], r[i + 1]));
}
cout << ans << endl;
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 874,603 | 874,601 | u432551953 | cpp |
p03061 | #include <bits/stdc++.h>
using namespace std;
int a[100005], n, sum1[100005], sum2[100005], ans;
inline void swap(int x, int y) {
int t = x;
x = y;
y = t;
}
int gcd(int a, int b) {
if (a < b)
swap(a, b);
if (b == 0) {
return a;
} else
return gcd(b, a % b);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sum1[1] = a[1];
for (int i = 2; i <= n; i++) {
sum1[i] = gcd(sum1[i - 1], a[i]);
}
sum2[n] = a[n];
for (int i = n - 1; i >= 1; i--) {
sum1[i] = gcd(sum2[i + 1], a[i]);
}
for (int i = 1; i <= n; i++) {
ans = max(ans, gcd(sum1[i - 1], sum2[i + 1]));
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int a[100005], n, sum1[100005], sum2[100005], ans;
inline void swap(int x, int y) {
int t = x;
x = y;
y = t;
}
int gcd(int a, int b) {
if (a < b)
swap(a, b);
if (b == 0) {
return a;
} else
return gcd(b, a % b);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sum1[1] = a[1];
for (int i = 2; i <= n; i++) {
sum1[i] = gcd(sum1[i - 1], a[i]);
}
sum2[n] = a[n];
for (int i = n - 1; i >= 1; i--) {
sum2[i] = gcd(sum2[i + 1], a[i]);
}
for (int i = 1; i <= n; i++) {
ans = max(ans, gcd(sum1[i - 1], sum2[i + 1]));
}
cout << ans;
return 0;
} | [
"assignment.variable.change",
"identifier.change"
] | 874,611 | 874,612 | u858623137 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.