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 |
|---|---|---|---|---|---|---|---|
p03074 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define REP(i, n) FOR(i, 0, n - 1)
#define NREP(i, n) FOR(i, 1, n)
using ll = long long;
using pii = pair<int, int>;
using piii = pair<pii, pii>;
const int dx[4] = {0, -1, 1, 0};
const int dy[4] = {-1, 0, 0, 1};
const int INF = 1e9 + 7;
int gcd(int x, int y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(y, x % y);
}
template <class T1, class T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> void Add(T &a, const T &b, const T &mod = 1000000007) {
int val = ((a % mod) + (b % mod)) % mod;
if (val < 0) {
val += mod;
}
a = val;
}
////////////////////////////////////////
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> sum;
if (S[0] == '0')
sum.push_back(0);
for (int i = 0; i < N; ++i) {
int j = i;
while (j < S.size() && S[j] == S[i]) {
j++;
}
sum.push_back(j - i);
i = j;
}
if (S.back() == '0')
sum.push_back(0);
vector<int> fuck(sum.size() + 1, 0);
for (int i = 0; i < sum.size(); ++i) {
fuck[i + 1] = fuck[i] + sum[i];
}
int res = 0;
for (int left = 0; left < fuck.size(); left += 2) {
int right = left + K * 2 + 1;
if (right >= fuck.size())
right = (int)fuck.size() - 1;
res = max(res, fuck[right] - fuck[left]);
}
cout << res << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define REP(i, n) FOR(i, 0, n - 1)
#define NREP(i, n) FOR(i, 1, n)
using ll = long long;
using pii = pair<int, int>;
using piii = pair<pii, pii>;
const int dx[4] = {0, -1, 1, 0};
const int dy[4] = {-1, 0, 0, 1};
const int INF = 1e9 + 7;
int gcd(int x, int y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(y, x % y);
}
template <class T1, class T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <class T> void Add(T &a, const T &b, const T &mod = 1000000007) {
int val = ((a % mod) + (b % mod)) % mod;
if (val < 0) {
val += mod;
}
a = val;
}
////////////////////////////////////////
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> sum;
if (S[0] == '0')
sum.push_back(0);
for (int i = 0; i < N;) {
int j = i;
while (j < S.size() && S[j] == S[i]) {
j++;
}
sum.push_back(j - i);
i = j;
}
if (S.back() == '0')
sum.push_back(0);
vector<int> fuck(sum.size() + 1, 0);
for (int i = 0; i < sum.size(); ++i) {
fuck[i + 1] = fuck[i] + sum[i];
}
int res = 0;
for (int left = 0; left < fuck.size(); left += 2) {
int right = left + K * 2 + 1;
if (right >= fuck.size())
right = (int)fuck.size() - 1;
res = max(res, fuck[right] - fuck[left]);
}
cout << res << endl;
return 0;
}
| [
"control_flow.loop.for.update.change"
] | 885,640 | 885,641 | u414877092 | cpp |
p03074 | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#pragma warning(disable : 4996)
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 100000000;
const int MAX_N = 100000;
int main(int argc, char *args[]) {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> Nums;
int now = 1;
int cnt = 0;
for (int i = 0; i < N; i++) {
if (S[i] == (char)('0' + now)) {
cnt++;
} else {
Nums.push_back(cnt);
now = 1 - now;
cnt = 1;
}
}
if (cnt != 0) {
Nums.push_back(cnt);
}
if (Nums.size() % 2 == 0)
Nums.push_back(0);
int Add = 2 * K + 1;
vector<int> sum(Nums.size() + 1);
for (int i = 0; i < Nums.size(); i += 2) {
sum[i + 1] = sum[i] + Nums[i];
}
int ans = 0;
for (int i = 0; i < Nums.size(); i += 2) {
int left = i;
int right = min(i + Add, (int)Nums.size());
int tmp = sum[right] - sum[left];
ans = max(tmp, ans);
}
cout << ans << endl;
} | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#pragma warning(disable : 4996)
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <list>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int INF = 100000000;
const int MAX_N = 100000;
int main(int argc, char *args[]) {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> Nums;
int now = 1;
int cnt = 0;
for (int i = 0; i < N; i++) {
if (S[i] == (char)('0' + now)) {
cnt++;
} else {
Nums.push_back(cnt);
now = 1 - now;
cnt = 1;
}
}
if (cnt != 0) {
Nums.push_back(cnt);
}
if (Nums.size() % 2 == 0)
Nums.push_back(0);
int Add = 2 * K + 1;
vector<int> sum(Nums.size() + 1);
for (int i = 0; i < Nums.size(); i++) {
sum[i + 1] = sum[i] + Nums[i];
}
int ans = 0;
for (int i = 0; i < Nums.size(); i += 2) {
int left = i;
int right = min(i + Add, (int)Nums.size());
int tmp = sum[right] - sum[left];
ans = max(tmp, ans);
}
cout << ans << endl;
} | [] | 885,648 | 885,649 | u455067221 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
using ll = long long;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define MOD 1000000007
const ll INF = 1e18;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int n, k, cnt = 0;
string s;
int main(int argc, char const *argv[]) {
cin >> n >> k >> s;
vector<int> nums;
if (s[0] == '0')
nums.pb(0);
for (int i = 0; i < sz(s);) {
int j = i;
while (j < sz(s) && s[j] == s[i])
j++;
nums.pb(j - i);
i = j;
}
if (s.back() == '0')
nums.pb(0);
vector<int> sums((int)(sz(s) + 1), 0);
rep(i, sz(nums)) sums[i + 1] = sums[i] + nums[i];
int res = 0;
for (int left = 0; left < sums.size(); left += 2) {
int right = left + k * 2 + 1;
if (right >= sums.size())
right = (int)sums.size() - 1;
res = max(res, sums[right] - sums[left]);
}
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
using ll = long long;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define MOD 1000000007
const ll INF = 1e18;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int n, k, cnt = 0;
string s;
int main(int argc, char const *argv[]) {
cin >> n >> k >> s;
vector<int> nums;
if (s[0] == '0')
nums.pb(0);
for (int i = 0; i < sz(s);) {
int j = i;
while (j < sz(s) && s[j] == s[i])
j++;
nums.pb(j - i);
i = j;
}
if (s.back() == '0')
nums.pb(0);
vector<int> sums((int)(sz(nums) + 1), 0);
rep(i, sz(nums)) sums[i + 1] = sums[i] + nums[i];
int res = 0;
for (int left = 0; left < sums.size(); left += 2) {
int right = left + k * 2 + 1;
if (right >= sums.size())
right = (int)sums.size() - 1;
res = max(res, sums[right] - sums[left]);
}
cout << res << endl;
return 0;
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 885,652 | 885,653 | u863279562 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
using ll = long long;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define MOD 1000000007
const ll INF = 1e18;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int n, k, cnt = 0;
string s;
int main(int argc, char const *argv[]) {
cin >> n >> k >> s;
vector<int> nums;
if (s[0] == '0')
nums.pb(0);
for (int i = 0; i < sz(s);) {
int j = i;
while (j < sz(s) && s[j] == s[i])
j++;
nums.pb(j - i);
i = j;
}
if (s.back() == '0')
nums.pb(0);
vector<int> sums(sz(s) + 1, 0);
rep(i, sz(nums)) sums[i + 1] = sums[i] + nums[i];
int res = 0;
for (int left = 0; left < sums.size(); left += 2) {
int right = left + k * 2 + 1;
if (right >= sums.size())
right = (int)sums.size() - 1;
res = max(res, sums[right] - sums[left]);
}
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
using ll = long long;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define MOD 1000000007
const ll INF = 1e18;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int n, k, cnt = 0;
string s;
int main(int argc, char const *argv[]) {
cin >> n >> k >> s;
vector<int> nums;
if (s[0] == '0')
nums.pb(0);
for (int i = 0; i < sz(s);) {
int j = i;
while (j < sz(s) && s[j] == s[i])
j++;
nums.pb(j - i);
i = j;
}
if (s.back() == '0')
nums.pb(0);
vector<int> sums((int)(sz(nums) + 1), 0);
rep(i, sz(nums)) sums[i + 1] = sums[i] + nums[i];
int res = 0;
for (int left = 0; left < sums.size(); left += 2) {
int right = left + k * 2 + 1;
if (right >= sums.size())
right = (int)sums.size() - 1;
res = max(res, sums[right] - sums[left]);
}
cout << res << endl;
return 0;
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 885,654 | 885,653 | u863279562 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
int main() {
int d[100001], a[100001], sum[100001];
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
d[i] = c - '0';
}
for (int i = 1; i <= n; i++) {
a[i] = d[i - 1] ^ d[i];
}
sum[0] = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
int x = 0;
int maxn = 0;
for (int i = 1; i <= n; i++) {
x ^= a[i];
int b = upper_bound(sum, sum + n + 1, 2 * k - (!b) + sum[i]) - sum;
maxn = max(maxn, b - i);
}
cout << maxn << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int d[100001], a[100001], sum[100001];
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
d[i] = c - '0';
}
for (int i = 1; i <= n; i++) {
a[i] = d[i - 1] ^ d[i];
}
sum[0] = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
int x = 0;
int maxn = 0;
for (int i = 1; i <= n; i++) {
x ^= a[i];
int b = upper_bound(sum, sum + n + 1, 2 * k - (!x) + sum[i]) - sum;
maxn = max(maxn, b - i);
}
cout << maxn << endl;
return 0;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 885,659 | 885,660 | u597691811 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
int main() {
int d[100001], a[100001], sum[100001];
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
d[i] = c - '0';
}
for (int i = 1; i <= n; i++) {
a[i] = d[i - 1] ^ d[i];
}
sum[0] = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
int x = 0;
int maxn = 0;
for (int i = 1; i <= n; i++) {
x ^= a[i];
int b = upper_bound(sum, sum + n + 1, 2 * k - (!b) + sum[i]) - sum;
maxn = max(maxn, b - i);
}
cout << maxn << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int d[100001], a[100001], sum[100001];
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
d[i] = c - '0';
}
for (int i = 1; i <= n; i++) {
a[i] = d[i - 1] ^ d[i];
}
sum[0] = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
int x = 0;
int maxn = 0;
for (int i = 1; i <= n; i++) {
x ^= a[i];
int b = upper_bound(sum, sum + n + 1, 2 * k - (!x) + sum[i]) - sum;
maxn = max(maxn, b - i);
}
cout << maxn << endl;
return 0;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 885,665 | 885,660 | u597691811 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
int main() {
int d[100001], a[100001], sum[100001];
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
d[i] = c - '0';
}
for (int i = 1; i <= n; i++) {
a[i] = d[i - 1] ^ d[i];
}
sum[0] = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
int x = 0;
int maxn = 0;
for (int i = 1; i <= n; i++) {
x ^= a[i];
int b = upper_bound(sum, sum + n + 1, 2 * k - (!b) + sum[i]) - sum;
maxn = max(maxn, b - i);
}
cout << maxn << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int d[100001], a[100001], sum[100001];
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
d[i] = c - '0';
}
for (int i = 1; i <= n; i++) {
a[i] = d[i - 1] ^ d[i];
}
sum[0] = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
int b = 0;
int maxn = 0;
for (int i = 1; i <= n; i++) {
b ^= a[i];
int x = upper_bound(sum, sum + n + 1, 2 * k - (!b) + sum[i]) - sum;
maxn = max(maxn, x - i);
}
cout << maxn << endl;
return 0;
} | [
"variable_declaration.name.change",
"identifier.change",
"assignment.variable.change",
"assignment.value.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 885,665 | 885,667 | u597691811 | cpp |
p03070 | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i, s, e) for (i64(i) = (s); (i) < (e); (i)++)
#define all(x) x.begin(), x.end()
template <class T> static inline std::vector<T> ndvec(size_t &&n, T val) {
return std::vector<T>(n, std::forward<T>(val));
}
template <class... Tail> static inline auto ndvec(size_t &&n, Tail &&...tail) {
return std::vector<decltype(ndvec(std::forward<Tail>(tail)...))>(
n, ndvec(std::forward<Tail>(tail)...));
}
template <class Cond> struct chain {
Cond cond;
chain(Cond cond) : cond(cond) {}
template <class T> bool operator()(T &a, const T &b) const {
if (cond(a, b)) {
a = b;
return true;
}
return false;
}
};
template <class Cond> chain<Cond> make_chain(Cond cond) {
return chain<Cond>(cond);
}
#include <iostream>
using i64 = long long;
template <i64 M> struct modint {
i64 a;
constexpr modint(const i64 x = 0) : a((x % M + M) % M) {}
constexpr i64 value() const { return a; }
constexpr modint inv() const { return this->pow(M - 2); }
constexpr modint pow(i64 r) const {
modint ans(1);
modint aa = *this;
while (r) {
if (r & 1)
ans *= aa;
aa *= aa;
r >>= 1;
}
return ans;
}
constexpr modint &operator=(const i64 r) {
a = (r % M + M) % M;
return *this;
}
constexpr modint &operator+=(const modint r) {
a += r.a;
if (a >= M)
a -= M;
return *this;
}
constexpr modint &operator-=(const modint r) {
a -= r.a;
if (a < 0)
a += M;
return *this;
}
constexpr modint &operator*=(const modint r) {
a = a * r.a % M;
return *this;
}
constexpr modint &operator/=(const modint r) {
(*this) *= r.inv();
return *this;
}
constexpr modint operator+(const modint r) const {
return modint(*this) += r;
}
constexpr modint operator-(const modint r) const {
return modint(*this) -= r;
}
constexpr modint operator*(const modint r) const {
return modint(*this) *= r;
}
constexpr modint operator/(const modint r) const {
return modint(*this) /= r;
}
constexpr bool operator!=(const modint r) const {
return this->value() != r.value();
}
};
template <const i64 M>
std::ostream &operator<<(std::ostream &os, const modint<M> &m) {
os << m.value();
return os;
}
const i64 mod = 998244353;
using fp = modint<mod>;
int main() {
i64 N;
cin >> N;
vector<i64> A(N);
i64 Sigma = 0;
rep(i, 0, N) {
cin >> A[i];
Sigma += A[i];
}
fp res(0);
{
auto dp = ndvec(300 * 300 + 1, fp(0));
dp[0] = fp(1);
rep(i, 0, N) {
auto next = ndvec(300 * 300 + 1, fp(0));
rep(j, 0, next.size()) {
next[j] += dp[j] * fp(2);
if (j - A[i] >= 0) {
next[j] += dp[j - A[i]];
}
}
swap(dp, next);
}
rep(i, (Sigma + 1) / 2, dp.size()) { res += dp[i]; }
}
fp ans = fp(3).pow(N);
ans -= res * fp(3);
{
const int MAX = 300 * 300;
auto rdp = ndvec(MAX * 2 + 2, fp(0));
auto dp = begin(rdp) + MAX;
dp[0] = fp(1);
rep(i, 0, N) {
auto rnext = ndvec(MAX * 2 + 2, fp(0));
auto next = begin(rnext) + MAX;
for (int j = -MAX; j <= MAX; j++) {
if (j + A[i] <= MAX) {
next[j] += dp[j + A[i]];
}
if (-MAX <= j - A[i]) {
next[j] += dp[j - A[i]];
}
}
swap(rnext, rdp);
swap(next, dp);
}
ans += dp[0] * 3 * 2;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i, s, e) for (i64(i) = (s); (i) < (e); (i)++)
#define all(x) x.begin(), x.end()
template <class T> static inline std::vector<T> ndvec(size_t &&n, T val) {
return std::vector<T>(n, std::forward<T>(val));
}
template <class... Tail> static inline auto ndvec(size_t &&n, Tail &&...tail) {
return std::vector<decltype(ndvec(std::forward<Tail>(tail)...))>(
n, ndvec(std::forward<Tail>(tail)...));
}
template <class Cond> struct chain {
Cond cond;
chain(Cond cond) : cond(cond) {}
template <class T> bool operator()(T &a, const T &b) const {
if (cond(a, b)) {
a = b;
return true;
}
return false;
}
};
template <class Cond> chain<Cond> make_chain(Cond cond) {
return chain<Cond>(cond);
}
#include <iostream>
using i64 = long long;
template <i64 M> struct modint {
i64 a;
constexpr modint(const i64 x = 0) : a((x % M + M) % M) {}
constexpr i64 value() const { return a; }
constexpr modint inv() const { return this->pow(M - 2); }
constexpr modint pow(i64 r) const {
modint ans(1);
modint aa = *this;
while (r) {
if (r & 1)
ans *= aa;
aa *= aa;
r >>= 1;
}
return ans;
}
constexpr modint &operator=(const i64 r) {
a = (r % M + M) % M;
return *this;
}
constexpr modint &operator+=(const modint r) {
a += r.a;
if (a >= M)
a -= M;
return *this;
}
constexpr modint &operator-=(const modint r) {
a -= r.a;
if (a < 0)
a += M;
return *this;
}
constexpr modint &operator*=(const modint r) {
a = a * r.a % M;
return *this;
}
constexpr modint &operator/=(const modint r) {
(*this) *= r.inv();
return *this;
}
constexpr modint operator+(const modint r) const {
return modint(*this) += r;
}
constexpr modint operator-(const modint r) const {
return modint(*this) -= r;
}
constexpr modint operator*(const modint r) const {
return modint(*this) *= r;
}
constexpr modint operator/(const modint r) const {
return modint(*this) /= r;
}
constexpr bool operator!=(const modint r) const {
return this->value() != r.value();
}
};
template <const i64 M>
std::ostream &operator<<(std::ostream &os, const modint<M> &m) {
os << m.value();
return os;
}
const i64 mod = 998244353;
using fp = modint<mod>;
int main() {
i64 N;
cin >> N;
vector<i64> A(N);
i64 Sigma = 0;
rep(i, 0, N) {
cin >> A[i];
Sigma += A[i];
}
fp res(0);
{
auto dp = ndvec(300 * 300 + 1, fp(0));
dp[0] = fp(1);
rep(i, 0, N) {
auto next = ndvec(300 * 300 + 1, fp(0));
rep(j, 0, next.size()) {
next[j] += dp[j] * fp(2);
if (j - A[i] >= 0) {
next[j] += dp[j - A[i]];
}
}
swap(dp, next);
}
rep(i, (Sigma + 1) / 2, dp.size()) { res += dp[i]; }
}
fp ans = fp(3).pow(N);
ans -= res * fp(3);
{
const int MAX = 300 * 300;
auto rdp = ndvec(MAX * 2 + 2, fp(0));
auto dp = begin(rdp) + MAX;
dp[0] = fp(1);
rep(i, 0, N) {
auto rnext = ndvec(MAX * 2 + 2, fp(0));
auto next = begin(rnext) + MAX;
for (int j = -MAX; j <= MAX; j++) {
if (j + A[i] <= MAX) {
next[j] += dp[j + A[i]];
}
if (-MAX <= j - A[i]) {
next[j] += dp[j - A[i]];
}
}
swap(rnext, rdp);
swap(next, dp);
}
ans += dp[0] * 3;
}
cout << ans << endl;
}
| [
"expression.operation.binary.remove"
] | 885,682 | 885,683 | u852585808 | cpp |
p03070 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n) for (int i = 1; i <= (n); i++)
#define all(x) (x).begin(), (x).end()
#define uniq(x) (x).erase(unique(all(x)), (x).end())
#define bit(n) (1LL << (n))
#define dump(x) cerr << #x " = " << (x) << endl
using vint = vector<int>;
using vvint = vector<vint>;
using pint = pair<int, int>;
using vpint = vector<pint>;
template <typename T>
using priority_queue_rev = priority_queue<T, vector<T>, greater<T>>;
constexpr double pi = 3.1415926535897932384626433832795028;
constexpr int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int gcd(int a, int b) {
while (b) {
swap(a %= b, b);
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
template <typename T1, typename T2> bool chmax(T1 &a, const T2 &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2> bool chmin(T1 &a, const T2 &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &rhs) {
os << "(" << rhs.first << ", " << rhs.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &rhs) {
os << "{";
for (auto itr = rhs.begin(); itr != rhs.end(); itr++) {
os << *itr << (next(itr) != rhs.end() ? ", " : "");
}
os << "}";
return os;
}
struct setup {
static constexpr int PREC = 20;
setup() {
cout << fixed << setprecision(PREC);
cerr << fixed << setprecision(PREC);
};
} setup;
template <int MOD = 1000000007> struct mod_int {
int val;
mod_int(long long val_ = 0)
: val(val_ >= 0 ? val_ % MOD : (MOD - (-val_) % MOD) % MOD) {}
bool operator==(const mod_int &rhs) const { return val == rhs.val; }
bool operator!=(const mod_int &rhs) const {
return std::rel_ops::operator!=(*this, rhs);
}
mod_int &operator+=(const mod_int &rhs) {
if ((val += rhs.val) >= MOD) {
val -= MOD;
}
return *this;
}
mod_int &operator-=(const mod_int &rhs) {
if ((val += MOD - rhs.val) >= MOD) {
val -= MOD;
}
return *this;
}
mod_int &operator*=(const mod_int &rhs) {
val = (int)((long long)val * rhs.val % MOD);
return *this;
}
mod_int &operator/=(const mod_int &rhs) { return *this *= rhs.inv(); }
mod_int operator+() const { return *this; }
mod_int operator-() const { return mod_int(-val); }
mod_int operator++() { return *this += 1; }
mod_int operator--() { return *this -= 1; }
mod_int operator++(signed) {
const mod_int ret(*this);
++*this;
return ret;
}
mod_int operator--(signed) {
const mod_int ret(*this);
--*this;
return ret;
}
mod_int operator+(const mod_int &rhs) const { return mod_int(*this) += rhs; }
mod_int operator-(const mod_int &rhs) const { return mod_int(*this) -= rhs; }
mod_int operator*(const mod_int &rhs) const { return mod_int(*this) *= rhs; }
mod_int operator/(const mod_int &rhs) const { return mod_int(*this) /= rhs; }
mod_int inv() const {
int a = MOD, b = val, u = 0, v = 1;
while (b > 0) {
int t = a / b;
std::swap(a -= t * b, b);
std::swap(u -= t * v, v);
}
return mod_int(u);
}
mod_int pow(long long n) const {
if (n < 0) {
return pow(-n).inv();
}
mod_int ret = 1, mul = *this;
while (n > 0) {
if (n & 1) {
ret *= mul;
}
mul *= mul;
n >>= 1;
}
return ret;
}
friend std::istream &operator>>(std::istream &is, mod_int &rhs) {
long long v;
is >> v;
rhs = v;
return is;
}
friend std::ostream &operator<<(std::ostream &os, const mod_int &rhs) {
return os << rhs.val;
}
struct combination {
std::vector<mod_int> fact{1, 1}, f_inv{1, 1}, inv{0, 1};
void calc(int n) {
while (fact.size() <= n) {
int i = fact.size();
fact.push_back(fact[i - 1] * i);
inv.push_back(-inv[MOD % i] * (MOD / i));
f_inv.push_back(f_inv[i - 1] * inv[i]);
}
}
mod_int P(int n, int r) {
return r < 0 || n < r ? 0 : (calc(n), fact[n] * f_inv[n - r]);
}
mod_int C(int n, int r) {
return r < 0 || n < r ? 0 : (calc(n), fact[n] * f_inv[r] * f_inv[n - r]);
}
mod_int H(int n, int r) { return C(n + r - 1, r); }
};
};
using mint = mod_int<998244353>;
int N;
int a[330];
mint dp0[330][99000], dp1[330][99000];
signed main() {
cin >> N;
rep(i, N) { cin >> a[i]; }
dp0[0][0] = 1;
dp1[0][0] = 1;
rep(i, N) {
rep(j, 90000) {
dp0[i + 1][j] += dp0[i][j] * 2;
dp0[i + 1][j + a[i]] += dp0[i][j];
dp1[i + 1][j] += dp1[i][j];
dp1[i + 1][j + a[i]] += dp1[i][j];
}
}
int sum = 0;
rep(i, N) { sum += a[i]; }
mint k = 0;
for (int i = sum / 2; i <= sum; i++) {
k += dp0[N][i] * 3;
}
if (sum % 2 == 0) {
k -= dp1[N][sum / 2] * 3;
}
cout << mint(3).pow(N) - k << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n) for (int i = 1; i <= (n); i++)
#define all(x) (x).begin(), (x).end()
#define uniq(x) (x).erase(unique(all(x)), (x).end())
#define bit(n) (1LL << (n))
#define dump(x) cerr << #x " = " << (x) << endl
using vint = vector<int>;
using vvint = vector<vint>;
using pint = pair<int, int>;
using vpint = vector<pint>;
template <typename T>
using priority_queue_rev = priority_queue<T, vector<T>, greater<T>>;
constexpr double pi = 3.1415926535897932384626433832795028;
constexpr int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int gcd(int a, int b) {
while (b) {
swap(a %= b, b);
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
template <typename T1, typename T2> bool chmax(T1 &a, const T2 &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2> bool chmin(T1 &a, const T2 &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &rhs) {
os << "(" << rhs.first << ", " << rhs.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &rhs) {
os << "{";
for (auto itr = rhs.begin(); itr != rhs.end(); itr++) {
os << *itr << (next(itr) != rhs.end() ? ", " : "");
}
os << "}";
return os;
}
struct setup {
static constexpr int PREC = 20;
setup() {
cout << fixed << setprecision(PREC);
cerr << fixed << setprecision(PREC);
};
} setup;
template <int MOD = 1000000007> struct mod_int {
int val;
mod_int(long long val_ = 0)
: val(val_ >= 0 ? val_ % MOD : (MOD - (-val_) % MOD) % MOD) {}
bool operator==(const mod_int &rhs) const { return val == rhs.val; }
bool operator!=(const mod_int &rhs) const {
return std::rel_ops::operator!=(*this, rhs);
}
mod_int &operator+=(const mod_int &rhs) {
if ((val += rhs.val) >= MOD) {
val -= MOD;
}
return *this;
}
mod_int &operator-=(const mod_int &rhs) {
if ((val += MOD - rhs.val) >= MOD) {
val -= MOD;
}
return *this;
}
mod_int &operator*=(const mod_int &rhs) {
val = (int)((long long)val * rhs.val % MOD);
return *this;
}
mod_int &operator/=(const mod_int &rhs) { return *this *= rhs.inv(); }
mod_int operator+() const { return *this; }
mod_int operator-() const { return mod_int(-val); }
mod_int operator++() { return *this += 1; }
mod_int operator--() { return *this -= 1; }
mod_int operator++(signed) {
const mod_int ret(*this);
++*this;
return ret;
}
mod_int operator--(signed) {
const mod_int ret(*this);
--*this;
return ret;
}
mod_int operator+(const mod_int &rhs) const { return mod_int(*this) += rhs; }
mod_int operator-(const mod_int &rhs) const { return mod_int(*this) -= rhs; }
mod_int operator*(const mod_int &rhs) const { return mod_int(*this) *= rhs; }
mod_int operator/(const mod_int &rhs) const { return mod_int(*this) /= rhs; }
mod_int inv() const {
int a = MOD, b = val, u = 0, v = 1;
while (b > 0) {
int t = a / b;
std::swap(a -= t * b, b);
std::swap(u -= t * v, v);
}
return mod_int(u);
}
mod_int pow(long long n) const {
if (n < 0) {
return pow(-n).inv();
}
mod_int ret = 1, mul = *this;
while (n > 0) {
if (n & 1) {
ret *= mul;
}
mul *= mul;
n >>= 1;
}
return ret;
}
friend std::istream &operator>>(std::istream &is, mod_int &rhs) {
long long v;
is >> v;
rhs = v;
return is;
}
friend std::ostream &operator<<(std::ostream &os, const mod_int &rhs) {
return os << rhs.val;
}
struct combination {
std::vector<mod_int> fact{1, 1}, f_inv{1, 1}, inv{0, 1};
void calc(int n) {
while (fact.size() <= n) {
int i = fact.size();
fact.push_back(fact[i - 1] * i);
inv.push_back(-inv[MOD % i] * (MOD / i));
f_inv.push_back(f_inv[i - 1] * inv[i]);
}
}
mod_int P(int n, int r) {
return r < 0 || n < r ? 0 : (calc(n), fact[n] * f_inv[n - r]);
}
mod_int C(int n, int r) {
return r < 0 || n < r ? 0 : (calc(n), fact[n] * f_inv[r] * f_inv[n - r]);
}
mod_int H(int n, int r) { return C(n + r - 1, r); }
};
};
using mint = mod_int<998244353>;
int N;
int a[330];
mint dp0[330][99000], dp1[330][99000];
signed main() {
cin >> N;
rep(i, N) { cin >> a[i]; }
dp0[0][0] = 1;
dp1[0][0] = 1;
rep(i, N) {
rep(j, 90000) {
dp0[i + 1][j] += dp0[i][j] * 2;
dp0[i + 1][j + a[i]] += dp0[i][j];
dp1[i + 1][j] += dp1[i][j];
dp1[i + 1][j + a[i]] += dp1[i][j];
}
}
int sum = 0;
rep(i, N) { sum += a[i]; }
mint k = 0;
for (int i = sum / 2 + sum % 2; i <= sum; i++) {
k += dp0[N][i] * 3;
}
if (sum % 2 == 0) {
k -= dp1[N][sum / 2] * 3;
}
cout << mint(3).pow(N) - k << endl;
} | [
"control_flow.loop.for.initializer.change"
] | 885,702 | 885,703 | u450832845 | cpp |
p03070 | #include <algorithm>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define ll long long
#define rep2(i, a, b) for (ll i = a; i <= b; i++)
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep3(i, a, b) for (int i = a; i >= b; i--)
#define REP(e, v) for (auto e : v)
#define queint queue<int>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pq priority_queue<int> //大きい順
#define pqg priority_queue<int, vec, greater<int>> //小さい順
#define pb push_back
#define vec vector<int>
#define vecvec vector<vector<int>>
#define vecll vector<ll>
#define vecvecll vector<vector<ll>>
#define bs binary_search
#define All(c) (c).begin(), (c).end()
#define mp make_pair
using namespace std;
int in() {
int x;
scanf("%d", &x);
return x;
}
string stin() {
string s;
cin >> s;
return s;
}
ll lin() {
ll x;
scanf("%lld", &x);
return x;
}
ll mod = 998244353;
ll modpow(ll a, ll b) {
if (b == 0)
return 1;
if (b % 2 == 0) {
ll d = modpow(a, b / 2);
return d * d % mod;
}
return modpow(a, b - 1) * a % mod;
}
int main() {
int n = in();
ll sum = 0;
vec a(n);
rep(i, n) a[i + 1] = in();
vector<vecll> dp(n + 1, vecll(90001, 0));
dp[0][0] = 1;
rep(i, n) {
sum += a[i + 1];
rep2(j, 0, sum) {
dp[i + 1][j] = 2 * dp[i][j];
if (j >= a[i + 1])
dp[i + 1][j] += dp[i][j - a[i + 1]];
dp[i + 1][j] %= mod;
}
}
ll ans = modpow(3, n);
rep2(i, (sum + 1) / 2, sum) ans = (ans - 3 * dp[n][i]) % mod;
if (sum % 2 == 0) {
vector<vecll> c(n + 1, vecll(90001, 0));
c[0][0] = 1;
rep(i, n) {
rep2(j, 0, sum) {
c[i + 1][j] = c[i][j];
if (j >= a[i + 1])
c[i + 1][j] += c[i][j - a[i + 1]];
c[i + 1][j] %= mod;
}
}
ans += 3 * c[n][sum / 2];
}
cout << (ans + mod) % mod << endl;
}
| #include <algorithm>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define ll long long
#define rep2(i, a, b) for (ll i = a; i <= b; i++)
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep3(i, a, b) for (int i = a; i >= b; i--)
#define REP(e, v) for (auto e : v)
#define queint queue<int>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pq priority_queue<int> //大きい順
#define pqg priority_queue<int, vec, greater<int>> //小さい順
#define pb push_back
#define vec vector<int>
#define vecvec vector<vector<int>>
#define vecll vector<ll>
#define vecvecll vector<vector<ll>>
#define bs binary_search
#define All(c) (c).begin(), (c).end()
#define mp make_pair
using namespace std;
int in() {
int x;
scanf("%d", &x);
return x;
}
string stin() {
string s;
cin >> s;
return s;
}
ll lin() {
ll x;
scanf("%lld", &x);
return x;
}
ll mod = 998244353;
ll modpow(ll a, ll b) {
if (b == 0)
return 1;
if (b % 2 == 0) {
ll d = modpow(a, b / 2);
return d * d % mod;
}
return modpow(a, b - 1) * a % mod;
}
int main() {
int n = in();
ll sum = 0;
vec a(n + 1);
rep(i, n) a[i + 1] = in();
vector<vecll> dp(n + 1, vecll(90001, 0));
dp[0][0] = 1;
rep(i, n) {
sum += a[i + 1];
rep2(j, 0, sum) {
dp[i + 1][j] = 2 * dp[i][j];
if (j >= a[i + 1])
dp[i + 1][j] += dp[i][j - a[i + 1]];
dp[i + 1][j] %= mod;
}
}
ll ans = modpow(3, n);
rep2(i, (sum + 1) / 2, sum) ans = (ans - 3 * dp[n][i]) % mod;
if (sum % 2 == 0) {
vector<vecll> c(n + 1, vecll(90001, 0));
c[0][0] = 1;
rep(i, n) {
rep2(j, 0, sum) {
c[i + 1][j] = c[i][j];
if (j >= a[i + 1])
c[i + 1][j] += c[i][j - a[i + 1]];
c[i + 1][j] %= mod;
}
}
ans += 3 * c[n][sum / 2];
}
cout << (ans + mod) % mod << endl;
}
| [
"assignment.change"
] | 885,718 | 885,719 | u434662823 | cpp |
p03070 | #include <algorithm>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define ll long long
#define rep2(i, a, b) for (ll i = a; i <= b; i++)
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep3(i, a, b) for (int i = a; i >= b; i--)
#define REP(e, v) for (auto e : v)
#define queint queue<int>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pq priority_queue<int> //大きい順
#define pqg priority_queue<int, vec, greater<int>> //小さい順
#define pb push_back
#define vec vector<int>
#define vecvec vector<vector<int>>
#define vecll vector<ll>
#define vecvecll vector<vector<ll>>
#define bs binary_search
#define All(c) (c).begin(), (c).end()
#define mp make_pair
using namespace std;
int in() {
int x;
scanf("%d", &x);
return x;
}
string stin() {
string s;
cin >> s;
return s;
}
ll lin() {
ll x;
scanf("%lld", &x);
return x;
}
ll mod = 998244353;
ll modpow(ll a, ll b) {
if (b == 0)
return 1;
if (b % 2 == 0) {
ll d = modpow(a, b / 2);
return d * d % mod;
}
return modpow(a, b - 1) * a % mod;
}
int main() {
int n = in();
ll sum = 0;
vec a(n);
rep(i, n) a[i + 1] = in();
vector<vecll> dp(n + 1, vecll(90001, 0));
dp[0][0] = 1;
rep(i, n) {
sum += a[i + 1];
rep2(j, 0, sum) {
dp[i + 1][j] = 2 * dp[i][j];
if (j >= a[i + 1])
dp[i + 1][j] += dp[i][j - a[i + 1]];
dp[i + 1][j] %= mod;
}
}
ll ans = modpow(3, n);
rep2(i, (sum + 1) / 2, sum) ans = (ans - 3 * dp[n][i]) % mod;
if (sum % 2 == 0) {
vector<vecll> c(n + 1, vecll(900001, 0));
c[0][0] = 1;
rep(i, n) {
rep2(j, 0, sum) {
c[i + 1][j] = c[i][j];
if (j >= a[i + 1])
c[i + 1][j] += c[i][j - a[i + 1]];
c[i + 1][j] %= mod;
}
}
ans += 3 * c[n][sum / 2];
}
cout << (ans + mod) % mod << endl;
}
| #include <algorithm>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <math.h>
#include <queue>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <vector>
#define ll long long
#define rep2(i, a, b) for (ll i = a; i <= b; i++)
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep3(i, a, b) for (int i = a; i >= b; i--)
#define REP(e, v) for (auto e : v)
#define queint queue<int>
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pq priority_queue<int> //大きい順
#define pqg priority_queue<int, vec, greater<int>> //小さい順
#define pb push_back
#define vec vector<int>
#define vecvec vector<vector<int>>
#define vecll vector<ll>
#define vecvecll vector<vector<ll>>
#define bs binary_search
#define All(c) (c).begin(), (c).end()
#define mp make_pair
using namespace std;
int in() {
int x;
scanf("%d", &x);
return x;
}
string stin() {
string s;
cin >> s;
return s;
}
ll lin() {
ll x;
scanf("%lld", &x);
return x;
}
ll mod = 998244353;
ll modpow(ll a, ll b) {
if (b == 0)
return 1;
if (b % 2 == 0) {
ll d = modpow(a, b / 2);
return d * d % mod;
}
return modpow(a, b - 1) * a % mod;
}
int main() {
int n = in();
ll sum = 0;
vec a(n + 1);
rep(i, n) a[i + 1] = in();
vector<vecll> dp(n + 1, vecll(90001, 0));
dp[0][0] = 1;
rep(i, n) {
sum += a[i + 1];
rep2(j, 0, sum) {
dp[i + 1][j] = 2 * dp[i][j];
if (j >= a[i + 1])
dp[i + 1][j] += dp[i][j - a[i + 1]];
dp[i + 1][j] %= mod;
}
}
ll ans = modpow(3, n);
rep2(i, (sum + 1) / 2, sum) ans = (ans - 3 * dp[n][i]) % mod;
if (sum % 2 == 0) {
vector<vecll> c(n + 1, vecll(90001, 0));
c[0][0] = 1;
rep(i, n) {
rep2(j, 0, sum) {
c[i + 1][j] = c[i][j];
if (j >= a[i + 1])
c[i + 1][j] += c[i][j - a[i + 1]];
c[i + 1][j] %= mod;
}
}
ans += 3 * c[n][sum / 2];
}
cout << (ans + mod) % mod << endl;
}
| [
"literal.number.change",
"call.arguments.change"
] | 885,720 | 885,719 | u434662823 | cpp |
p03070 | #include <algorithm>
#include <iostream>
using namespace std;
using lli = long long int;
lli a[301] = {};
lli A[301][300 * 302] = {};
lli B[301][300 * 302] = {};
const lli mod = 998244353;
int main(void) {
lli N;
cin >> N;
lli total = 1, sum = 0;
for (lli i = 0; i < N; i++) {
cin >> a[i];
total *= 3;
total %= mod;
sum += a[i];
}
A[0][0] = 1;
B[0][0] = 1;
for (lli i = 0; i < N; i++) {
for (lli j = 0; j < 300 * 300; j++) {
A[i + 1][j] += 2 * A[i][j];
A[i + 1][j] %= mod;
A[i + 1][j + a[i]] += A[i][j];
A[i + 1][j + a[i]] %= mod;
B[i + 1][j] += B[i][j];
B[i + 1][j] %= mod;
B[i + 1][j + a[i]] += B[i][j];
B[i + 1][j + a[i]] %= mod;
}
}
lli ans1 = 0, ans2 = 0;
for (lli i = 0; i < 10; i++) {
if (sum <= i * 2) {
ans1 += A[N][i];
ans1 %= mod;
}
}
if (sum % 2 == 0) {
ans2 = B[N][sum / 2];
}
cout << (((total - 3 * ans1) % mod + 3 * ans2) % mod + mod) % mod << endl;
}
| #include <algorithm>
#include <iostream>
using namespace std;
using lli = long long int;
lli a[301] = {};
lli A[301][300 * 303] = {};
lli B[301][300 * 303] = {};
const lli mod = 998244353;
int main(void) {
lli N;
cin >> N;
lli total = 1, sum = 0;
for (lli i = 0; i < N; i++) {
cin >> a[i];
total *= 3;
total %= mod;
sum += a[i];
}
A[0][0] = 1;
B[0][0] = 1;
for (lli i = 0; i < N; i++) {
for (lli j = 0; j < 300 * 301; j++) {
A[i + 1][j] += 2 * A[i][j];
A[i + 1][j] %= mod;
A[i + 1][j + a[i]] += A[i][j];
A[i + 1][j + a[i]] %= mod;
B[i + 1][j] += B[i][j];
B[i + 1][j] %= mod;
B[i + 1][j + a[i]] += B[i][j];
B[i + 1][j + a[i]] %= mod;
}
}
lli ans1 = 0, ans2 = 0;
for (lli i = 0; i < 300 * 301; i++) {
if (sum <= i * 2) {
ans1 += A[N][i];
ans1 %= mod;
}
}
if (sum % 2 == 0) {
ans2 = B[N][sum / 2];
}
cout << (((total - 3 * ans1) % mod + 3 * ans2) % mod + mod) % mod << endl;
}
| [
"literal.number.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one"
] | 885,730 | 885,731 | u155216115 | cpp |
p03070 | #include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long n, long long mod) {
if (n == 0)
return 1;
if (n == 1)
return a % mod;
if (n % 2 == 0) {
long long half = modpow(a, n / 2, mod) % mod;
return half * half % mod;
} else
return modpow(a, 1, mod) * modpow(a, n - 1, mod) % mod;
}
int main() {
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
int sum = 0;
for (int i = 0; i < n; i++) {
sum += a.at(i);
}
const long long mod = 998244353;
vector<vector<long long>> dp(n + 1, vector<long long>(sum + 1));
dp.at(0).at(0) = 1;
for (int t = 1; t <= n; t++) {
for (long long r = 0; r <= sum; r++) {
dp.at(t).at(r) += dp.at(t - 1).at(r) * 2;
dp.at(t).at(r) %= mod;
if (r - a.at(t - 1) >= 0)
dp.at(t).at(r) += dp.at(t - 1).at(r - a.at(t - 1));
dp.at(t).at(r) %= mod;
}
}
long long ans = modpow(3, n, mod);
for (int r = ceil((double)sum / 2); r <= sum; r++) {
ans -= dp.at(n).at(r) * 3 % mod;
if (ans < 0)
ans += mod;
}
if (sum % 2 == 0) {
vector<vector<long long>> dp2(n + 1, vector<long long>(sum / 2 + 1, 0));
dp2.at(0).at(0) = 1;
for (int t = 1; t <= n; t++) {
for (long long r = 0; r <= sum / 2; r++) {
dp2.at(t).at(r) += dp2.at(t - 1).at(r);
dp2.at(t).at(r) %= mod;
if (r - a.at(t - 1) >= 0)
dp2.at(t).at(r) += dp2.at(t - 1).at(r - a.at(t - 1));
dp2.at(t).at(r) %= mod;
}
}
ans += dp2.at(n).at(sum / 2) * 2 * 3 % mod;
}
ans %= mod;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long n, long long mod) {
if (n == 0)
return 1;
if (n == 1)
return a % mod;
if (n % 2 == 0) {
long long half = modpow(a, n / 2, mod) % mod;
return half * half % mod;
} else
return modpow(a, 1, mod) * modpow(a, n - 1, mod) % mod;
}
int main() {
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
int sum = 0;
for (int i = 0; i < n; i++) {
sum += a.at(i);
}
const long long mod = 998244353;
vector<vector<long long>> dp(n + 1, vector<long long>(sum + 1));
dp.at(0).at(0) = 1;
for (int t = 1; t <= n; t++) {
for (long long r = 0; r <= sum; r++) {
dp.at(t).at(r) += dp.at(t - 1).at(r) * 2;
dp.at(t).at(r) %= mod;
if (r - a.at(t - 1) >= 0)
dp.at(t).at(r) += dp.at(t - 1).at(r - a.at(t - 1));
dp.at(t).at(r) %= mod;
}
}
long long ans = modpow(3, n, mod);
for (int r = ceil((double)sum / 2); r <= sum; r++) {
ans -= dp.at(n).at(r) * 3 % mod;
if (ans < 0)
ans += mod;
}
if (sum % 2 == 0) {
vector<vector<long long>> dp2(n + 1, vector<long long>(sum / 2 + 1, 0));
dp2.at(0).at(0) = 1;
for (int t = 1; t <= n; t++) {
for (long long r = 0; r <= sum / 2; r++) {
dp2.at(t).at(r) += dp2.at(t - 1).at(r);
dp2.at(t).at(r) %= mod;
if (r - a.at(t - 1) >= 0)
dp2.at(t).at(r) += dp2.at(t - 1).at(r - a.at(t - 1));
dp2.at(t).at(r) %= mod;
}
}
ans += dp2.at(n).at(sum / 2) * 3 % mod;
}
ans %= mod;
cout << ans << endl;
} | [
"expression.operation.binary.remove"
] | 885,749 | 885,750 | u465233477 | cpp |
p03070 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return
// true; } return false; } template<class T> inline bool chmin(T& a, T b) { if (a
// > b) { a = b; return true; } return false; }
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
*/
const int mod = 998244353;
int main() {
int N;
cin >> N;
vector<int> a(N);
int sum = 0;
for (int i = 0; i < N; i++) {
cin >> a[i];
sum += a[i];
}
vector<vector<ll>> dp(N, vector<ll>(sum + 1, 0));
vector<vector<ll>> dp2(N, vector<ll>(sum + 1, 0));
// 初期化
dp[0][a[0]] = 1;
dp[0][0] = 2;
// 配るdp：dp[i][A]がdp[i+1][?]に貢献する値を配っていく
for (int i = 0; i < N - 1; i++) {
for (int A = 0; A <= sum; A++) {
if (dp[i][A] == 0)
continue;
// i+1番目をAに入れないなら、BかCに入れるかの２通りがある
dp[i + 1][A] += 2 * dp[i][A];
dp[i + 1][A] %= mod;
// i+1番目をAに入れるなら、１通り
dp[i + 1][A + a[i + 1]] += dp[i][A];
dp[i + 1][A + a[i + 1]] %= mod;
}
}
ll sub1 = 0;
for (int A = ((sum - 1) / 2 + 1); A <= sum; A++) {
sub1 += dp[N - 1][A];
sub1 %= mod;
}
sub1 = sub1 * 3 % mod;
// cout << sub1 << endl;
// 初期化
dp2[0][a[1]] = 1;
dp2[0][0] = 1;
for (int i = 0; i < N - 1; i++) {
for (int A = 0; A <= sum; A++) {
dp2[i + 1][A] += dp2[i][A];
dp2[i + 1][A] %= mod;
dp2[i + 1][A + a[i + 1]] += dp2[i][A];
dp2[i + 1][A + a[i + 1]] %= mod;
}
}
ll sub2;
if (sum % 2 == 1)
sub2 = 0;
else
sub2 = dp2[N - 1][sum / 2];
sub2 = 3 * sub2 % mod;
// cout << sub2 << endl;
ll ans = 1LL;
for (int i = 0; i < N; i++)
ans = ans * 3 % mod;
// cout << ans << endl;
ans -= sub1;
if (ans < 0) {
ans += mod;
ans %= mod;
}
ans += sub2;
ans %= mod;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return
// true; } return false; } template<class T> inline bool chmin(T& a, T b) { if (a
// > b) { a = b; return true; } return false; }
/* attention
long longのシフト演算には気をつけよう
タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
*/
const int mod = 998244353;
int main() {
int N;
cin >> N;
vector<int> a(N);
int sum = 0;
for (int i = 0; i < N; i++) {
cin >> a[i];
sum += a[i];
}
vector<vector<ll>> dp(N, vector<ll>(sum + 1, 0));
vector<vector<ll>> dp2(N, vector<ll>(sum + 1, 0));
// 初期化
dp[0][a[0]] = 1;
dp[0][0] = 2;
// 配るdp：dp[i][A]がdp[i+1][?]に貢献する値を配っていく
for (int i = 0; i < N - 1; i++) {
for (int A = 0; A <= sum; A++) {
if (dp[i][A] == 0)
continue;
// i+1番目をAに入れないなら、BかCに入れるかの２通りがある
dp[i + 1][A] += 2 * dp[i][A];
dp[i + 1][A] %= mod;
// i+1番目をAに入れるなら、１通り
dp[i + 1][A + a[i + 1]] += dp[i][A];
dp[i + 1][A + a[i + 1]] %= mod;
}
}
// printf(" |");
// for(int i=0; i<N; i++) printf("%4d|", i);
// cout << endl;
// for(int A=0; A<=sum; A++){
// printf("---");
// for(int i=0; i<N; i++) printf("-----");
// printf("\n");
// printf("%2d|", A);
// for(int i=0; i<N; i++) printf("%4lld|", dp[i][A]);
// cout << endl;
// }
ll sub1 = 0;
for (int A = ((sum - 1) / 2 + 1); A <= sum; A++) {
sub1 += dp[N - 1][A];
sub1 %= mod;
}
sub1 = sub1 * 3 % mod;
// cout << sub1 << endl;
// 初期化
dp2[0][a[0]] = 1;
dp2[0][0] = 1;
for (int i = 0; i < N - 1; i++) {
for (int A = 0; A <= sum; A++) {
dp2[i + 1][A] += dp2[i][A];
dp2[i + 1][A] %= mod;
dp2[i + 1][A + a[i + 1]] += dp2[i][A];
dp2[i + 1][A + a[i + 1]] %= mod;
}
}
// printf(" |");
// for(int i=0; i<N; i++) printf("%4d|", i);
// cout << endl;
// for(int A=0; A<=sum; A++){
// printf("---");
// for(int i=0; i<N; i++) printf("-----");
// printf("\n");
// printf("%2d|", A);
// for(int i=0; i<N; i++) printf("%4lld|", dp2[i][A]);
// cout << endl;
// }
ll sub2;
if (sum % 2 == 1)
sub2 = 0;
else
sub2 = dp2[N - 1][sum / 2];
sub2 = 3 * sub2 % mod;
// cout << sub2 << endl;
ll ans = 1LL;
for (int i = 0; i < N; i++)
ans = ans * 3 % mod;
// cout << ans << endl;
ans -= sub1;
if (ans < 0) {
ans += mod;
ans %= mod;
}
ans += sub2;
ans %= mod;
cout << ans << endl;
} | [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 885,755 | 885,756 | u052332717 | cpp |
p03074 | #include <iostream>
#include <string>
#include <vector>
#define ll long long
#define MOD 1000000007
#define MAX 10000000
using namespace std;
vector<int> white(MAX);
vector<int> black(MAX);
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int w = 0, b = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
white[w]++;
if (black[b] != 0)
b++;
} else {
black[b]++;
if (white[w] != 0)
w++;
}
}
int res = 0;
for (int i = 0; i < k; i++) {
res += white[i];
res += black[i];
}
if (s[0] != '0') {
res += black[k];
int ans = res;
for (int i = 0; i < n; i++) {
res += black[i + k + 1] + white[i + k] - black[i] - white[i];
ans = max(ans, res);
}
cout << ans;
} else {
int ans = res;
res = res + white[k] - white[0];
ans = max(ans, res);
for (int i = 0; i < n; i++) {
res += black[i + k + 1] + white[i + k + 1] - white[i + 1] - black[i];
ans = max(ans, res);
}
cout << ans;
}
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#define ll long long
#define MOD 1000000007
#define MAX 10000000
using namespace std;
vector<int> white(MAX);
vector<int> black(MAX);
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int w = 0, b = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
white[w]++;
if (black[b] != 0)
b++;
} else {
black[b]++;
if (white[w] != 0)
w++;
}
}
int res = 0;
for (int i = 0; i < k; i++) {
res += white[i];
res += black[i];
}
if (s[0] != '0') {
res += black[k];
int ans = res;
for (int i = 0; i < n; i++) {
res += black[i + k + 1] + white[i + k] - black[i] - white[i];
ans = max(ans, res);
}
cout << ans;
} else {
int ans = res;
res = res + white[k] + black[k] - white[0];
ans = max(ans, res);
for (int i = 0; i < n; i++) {
res += black[i + k + 1] + white[i + k + 1] - white[i + 1] - black[i];
ans = max(ans, res);
}
cout << ans;
}
return 0;
} | [
"assignment.change"
] | 885,769 | 885,770 | u139300044 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> Nums;
int now = 1;
int cnt = 0;
for (int i = 0; i < N; i++) {
if (S[i] == (char)('0' + now))
cnt++;
else {
Nums.push_back(cnt);
now = 1 - now;
cnt = 1;
}
}
if (cnt != 1)
Nums.push_back(cnt);
// 1-0-1-0-1って感じの配列が欲しい
if (Nums.size() % 2 == 0)
Nums.push_back(0);
int Add = 2 * K + 1;
int ans = 0;
int left = 0;
int right = 0;
int tmp = 0; //[left, right)のsum
for (int i = 0; i < Nums.size(); i += 2) {
int Nextleft = i;
int Nextright = min(i + Add, (int)Nums.size());
//サタンを移動する
while (Nextleft > left) {
tmp -= Nums[left];
left++;
}
while (Nextright > right) {
tmp += Nums[right];
right++;
}
ans = max(tmp, ans);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> Nums;
int now = 1;
int cnt = 0;
for (int i = 0; i < N; i++) {
if (S[i] == (char)('0' + now))
cnt++;
else {
Nums.push_back(cnt);
now = 1 - now;
cnt = 1;
}
}
if (cnt != 0)
Nums.push_back(cnt);
// 1-0-1-0-1って感じの配列が欲しい
if (Nums.size() % 2 == 0)
Nums.push_back(0);
int Add = 2 * K + 1;
int ans = 0;
int left = 0;
int right = 0;
int tmp = 0; //[left, right)のsum
for (int i = 0; i < Nums.size(); i += 2) {
int Nextleft = i;
int Nextright = min(i + Add, (int)Nums.size());
//サタンを移動する
while (Nextleft > left) {
tmp -= Nums[left];
left++;
}
while (Nextright > right) {
tmp += Nums[right];
right++;
}
ans = max(tmp, ans);
}
cout << ans << endl;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change"
] | 885,785 | 885,786 | u839397805 | cpp |
p03074 | #include <bits/stdc++.h>
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>;
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define inf (int)1e9 + 7
#define eb emplace_back
template <typename T> void out(vector<T> v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
string s;
cin >> n >> k >> s;
vector<int> Nums;
int now = 1; //今見ているかず
int cnt = 0; // nowがいくつ並んでいるか
for (int i = 0; i < n; ++i) {
if (s[i] == (char)('0' + now))
cnt++;
else {
Nums.eb(cnt);
now = 1 - now; // 0, 1 切り替え
cnt = 1; //新しいのをカウントし始める
}
}
if (cnt != 0)
Nums.push_back(cnt);
// 1 - 0 - 1 - 0 - 1
// 0で終わってたら
if (Nums.size() % 2 == 0)
Nums.eb(0);
int Add = 2 * k + 1;
int ans = 0;
int left = 0;
int right = 0;
int tmp = 0; //[left, right)のsum
// 1 - 0 - 1...の1から始めるので偶数番目だけ見る
for (int i = 0; i < Nums.size(); i += 2) {
int Nextleft = i;
int Nextright = min(i + Add, (int)Nums.size());
//左端を移動する
while (Nextleft > left) {
tmp -= Nums[i];
left++;
}
while (Nextright > right) {
tmp += Nums[right];
right++;
}
chmax(ans, tmp);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
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>;
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define inf (int)1e9 + 7
#define eb emplace_back
template <typename T> void out(vector<T> v) {
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
string s;
cin >> n >> k >> s;
vector<int> Nums;
int now = 1; //今見ているかず
int cnt = 0; // nowがいくつ並んでいるか
for (int i = 0; i < n; ++i) {
if (s[i] == (char)('0' + now))
cnt++;
else {
Nums.eb(cnt);
now = 1 - now; // 0, 1 切り替え
cnt = 1; //新しいのをカウントし始める
}
}
if (cnt != 0)
Nums.push_back(cnt);
// 1 - 0 - 1 - 0 - 1
// 0で終わってたら
if (Nums.size() % 2 == 0)
Nums.eb(0);
int Add = 2 * k + 1;
int ans = 0;
int left = 0;
int right = 0;
int tmp = 0; //[left, right)のsum
// 1 - 0 - 1...の1から始めるので偶数番目だけ見る
for (int i = 0; i < Nums.size(); i += 2) {
int Nextleft = i;
int Nextright = min(i + Add, (int)Nums.size());
//左端を移動する
while (Nextleft > left) {
tmp -= Nums[left];
left++;
}
while (Nextright > right) {
tmp += Nums[right];
right++;
}
chmax(ans, tmp);
}
cout << ans << endl;
}
| [
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 885,802 | 885,803 | u277556971 | cpp |
p03074 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <thread>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n + 1; i++)
#define repr(i, n) for (int i = n - 1; i >= 0; i--)
#define repr1(i, n) for (int i = n; i > 0; i--)
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
template <class... A> void prints() { cout << endl; }
template <class... A> void prints_rest() { cout << endl; }
template <class T, class... A>
void prints_rest(const T &first, const A &...rest) {
cout << " " << first;
prints_rest(rest...);
}
template <class T, class... A> void prints(const T &first, const A &...rest) {
cout << first;
prints_rest(rest...);
}
template <unsigned P> struct ModInt {
using M = ModInt;
unsigned v;
ModInt() : v(0) {}
ModInt(auto x) : v(x >= 0 ? x % P : (P - -x % P) % P) {}
constexpr ModInt(unsigned v, int) : v(v) {}
static constexpr unsigned p() { return P; }
M operator+() const { return *this; }
M operator-() const { return {v ? P - v : 0, 0}; }
explicit operator bool() const noexcept { return v; }
bool operator!() const noexcept { return !(bool)*this; }
M operator*(M r) const { return M(*this) *= r; }
M operator/(M r) const { return M(*this) /= r; }
M operator+(M r) const { return M(*this) += r; }
M operator-(M r) const { return M(*this) -= r; }
bool operator==(M r) const { return v == r.v; }
bool operator!=(M r) const { return !(*this == r); }
M &operator*=(M r) {
v = (uint64_t)v * r.v % P;
return *this;
}
M &operator/=(M r) { return *this *= r.inv(); }
M &operator+=(M r) {
if ((v += r.v) >= P)
v -= P;
return *this;
}
M &operator-=(M r) {
if ((v += P - r.v) >= P)
v -= P;
return *this;
}
M inv() const {
int a = v, b = P, x = 1, u = 0;
while (b) {
int q = a / b;
swap(a -= q * b, b);
swap(x -= q * u, u);
}
assert(a == 1);
return x;
}
M pow(auto n) const {
if (n < 0)
return pow(-n).inv();
M res = 1;
for (M a = *this; n; a *= a, n >>= 1)
if (n & 1)
res *= a;
return res;
}
friend M operator*(auto l, M r) { return M(l) *= r; }
friend M operator/(auto l, M r) { return M(l) /= r; }
friend M operator+(auto l, M r) { return M(l) += r; }
friend M operator-(auto l, M r) { return M(l) -= r; }
friend ostream &operator<<(ostream &os, M r) { return os << r.v; }
friend istream &operator>>(istream &is, M &r) {
ll x;
is >> x;
r = x;
return is;
}
friend bool operator==(auto l, M r) { return M(l) == r; }
friend bool operator!=(auto l, M r) { return !(l == r); }
};
vector<int> a;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int cnt = 0;
char nowl = s[0];
rep(i, s.size()) {
if (nowl != s[i]) {
a.push_back(cnt);
cnt = 0;
}
nowl = s[i];
cnt++;
}
a.push_back(cnt);
int ansl[a.size() + 1];
ansl[0] = 0;
rep1(i, a.size()) ansl[i] = ansl[i - 1] + a[i - 1];
int alen = a.size();
int ans = 0;
for (int i = 0; i < alen; i += 2) {
if (s[0] == '0' && i == 0) {
ans = ansl[2 * k] - ansl[0];
i++;
}
int l = i;
int r = min(i + 2 * k + 1, alen);
ans = max(ans, ansl[r] - ansl[l]);
}
cout << ans << endl;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <thread>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n + 1; i++)
#define repr(i, n) for (int i = n - 1; i >= 0; i--)
#define repr1(i, n) for (int i = n; i > 0; i--)
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
template <class... A> void prints() { cout << endl; }
template <class... A> void prints_rest() { cout << endl; }
template <class T, class... A>
void prints_rest(const T &first, const A &...rest) {
cout << " " << first;
prints_rest(rest...);
}
template <class T, class... A> void prints(const T &first, const A &...rest) {
cout << first;
prints_rest(rest...);
}
template <unsigned P> struct ModInt {
using M = ModInt;
unsigned v;
ModInt() : v(0) {}
ModInt(auto x) : v(x >= 0 ? x % P : (P - -x % P) % P) {}
constexpr ModInt(unsigned v, int) : v(v) {}
static constexpr unsigned p() { return P; }
M operator+() const { return *this; }
M operator-() const { return {v ? P - v : 0, 0}; }
explicit operator bool() const noexcept { return v; }
bool operator!() const noexcept { return !(bool)*this; }
M operator*(M r) const { return M(*this) *= r; }
M operator/(M r) const { return M(*this) /= r; }
M operator+(M r) const { return M(*this) += r; }
M operator-(M r) const { return M(*this) -= r; }
bool operator==(M r) const { return v == r.v; }
bool operator!=(M r) const { return !(*this == r); }
M &operator*=(M r) {
v = (uint64_t)v * r.v % P;
return *this;
}
M &operator/=(M r) { return *this *= r.inv(); }
M &operator+=(M r) {
if ((v += r.v) >= P)
v -= P;
return *this;
}
M &operator-=(M r) {
if ((v += P - r.v) >= P)
v -= P;
return *this;
}
M inv() const {
int a = v, b = P, x = 1, u = 0;
while (b) {
int q = a / b;
swap(a -= q * b, b);
swap(x -= q * u, u);
}
assert(a == 1);
return x;
}
M pow(auto n) const {
if (n < 0)
return pow(-n).inv();
M res = 1;
for (M a = *this; n; a *= a, n >>= 1)
if (n & 1)
res *= a;
return res;
}
friend M operator*(auto l, M r) { return M(l) *= r; }
friend M operator/(auto l, M r) { return M(l) /= r; }
friend M operator+(auto l, M r) { return M(l) += r; }
friend M operator-(auto l, M r) { return M(l) -= r; }
friend ostream &operator<<(ostream &os, M r) { return os << r.v; }
friend istream &operator>>(istream &is, M &r) {
ll x;
is >> x;
r = x;
return is;
}
friend bool operator==(auto l, M r) { return M(l) == r; }
friend bool operator!=(auto l, M r) { return !(l == r); }
};
vector<int> a;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int cnt = 0;
char nowl = s[0];
rep(i, s.size()) {
if (nowl != s[i]) {
a.push_back(cnt);
cnt = 0;
}
nowl = s[i];
cnt++;
}
a.push_back(cnt);
int ansl[a.size() + 1];
ansl[0] = 0;
rep1(i, a.size()) ansl[i] = ansl[i - 1] + a[i - 1];
int alen = a.size();
int ans = 0;
for (int i = 0; i < alen; i += 2) {
if (s[0] == '0' && i == 0) {
ans = ansl[min(2 * k, alen)] - ansl[0];
i++;
}
int l = i;
int r = min(i + 2 * k + 1, alen);
ans = max(ans, ansl[r] - ansl[l]);
}
cout << ans << endl;
}
| [
"call.add",
"call.arguments.add"
] | 885,822 | 885,823 | u092650292 | cpp |
p03074 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define PI acos(-1)
#define mp make_pair
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define srt(a) sort(all(a))
#define mem(a, h) memset(a, (h), sizeof(a))
#define f first
#define s second
#define MOD 1000000007
#define MOD1 998244353
#define EPS 1e-9
#define fore(i, b, e) for (ll i = b; i < e; i++)
#define forg(i, b, e, m) for (ll i = b; i < e; i += m)
// ll in(){ll r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return
// -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef vector<ll> vll;
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// freopen("asd1.txt", "r", stdin);
// freopen("asd.txt", "w", stdout);
int n, k;
cin >> n >> k;
int ar[n];
string s;
cin >> s;
vector<int> con;
con.pb(0);
char ig;
int can = 0;
fore(i, 0, n) {
if (i == 0)
ig = s[i];
if (ig != s[i]) {
con.pb(can);
ig = s[i];
can = 1;
} else
can++;
}
con.pb(can);
con.pb(0);
int l, r;
if (s[0] == '0')
l = 0;
else
l = 1;
int su = 0;
fore(i, l, min((int)con.size(), 2 * k + l + 1)) su += con[i];
r = 2 * k - ((l - 1)) + 1;
int res = su;
r += 2, l += 2;
while (r < con.size()) {
su -= con[l - 1] + con[l - 2];
su += con[r - 1] + con[r];
res = max(res, su);
l += 2;
r += 2;
}
cout << res << '\n';
return 0;
}
// read the question correctly (is y a vowel? what are the exact constralls?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs ll?) ARRAY OUT OF
// BOUNDSS2 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define PI acos(-1)
#define mp make_pair
#define pb push_back
#define all(a) (a).begin(), (a).end()
#define srt(a) sort(all(a))
#define mem(a, h) memset(a, (h), sizeof(a))
#define f first
#define s second
#define MOD 1000000007
#define MOD1 998244353
#define EPS 1e-9
#define fore(i, b, e) for (ll i = b; i < e; i++)
#define forg(i, b, e, m) for (ll i = b; i < e; i += m)
// ll in(){ll r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return
// -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef vector<ll> vll;
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// freopen("asd1.txt", "r", stdin);
// freopen("asd.txt", "w", stdout);
int n, k;
cin >> n >> k;
int ar[n];
string s;
cin >> s;
vector<int> con;
con.pb(0);
char ig;
int can = 0;
fore(i, 0, n) {
if (i == 0)
ig = s[i];
if (ig != s[i]) {
con.pb(can);
ig = s[i];
can = 1;
} else
can++;
}
con.pb(can);
con.pb(0);
int l, r;
if (s[0] == '0')
l = 0;
else
l = 1;
int su = 0;
fore(i, l, min((int)con.size(), 2 * k + l + 1)) su += con[i];
r = 2 * k + ((l - 1)) + 1;
int res = su;
r += 2, l += 2;
while (r < con.size()) {
su -= con[l - 1] + con[l - 2];
su += con[r - 1] + con[r];
res = max(res, su);
l += 2;
r += 2;
}
cout << res << '\n';
return 0;
}
// read the question correctly (is y a vowel? what are the exact constralls?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs ll?) ARRAY OUT OF
// BOUNDSS2 | [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 885,824 | 885,825 | u736250852 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#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 repr(i, a, b) for (int i = a; i >= (b); --i)
typedef long long ll;
const int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> A(0);
char now = '1';
int cnt = 0;
rep(i, S.size()) {
if (now == S[i])
cnt++;
else {
A.pb(cnt);
now = S[i];
cnt = 1;
}
}
if (cnt != 0)
A.pb(cnt);
if (S[S.size() - 1] == '0')
A.pb(0);
// rep(i, A.size()) { cout << A[i] << endl; }
vector<int> sum(N + 1);
rep(i, N + 1) { sum[i + 1] = sum[i] + A[i]; }
int w = 2 * K + 1;
int temp = 0;
int ans = 0;
for (int i = 0; i < A.size(); i += 2) {
int l = i;
int r = min(i + w, (int)A.size());
temp = sum[r] - sum[l];
chmax(ans, temp);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#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 repr(i, a, b) for (int i = a; i >= (b); --i)
typedef long long ll;
const int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> A(0);
char now = '1';
int cnt = 0;
rep(i, S.size()) {
if (now == S[i])
cnt++;
else {
A.pb(cnt);
now = S[i];
cnt = 1;
}
}
if (cnt != 0)
A.pb(cnt);
if (S[S.size() - 1] == '0')
A.pb(0);
// rep(i, A.size()) { cout << A[i] << endl; }
vector<int> sum(N + 1);
rep(i, A.size()) { sum[i + 1] = sum[i] + A[i]; }
int w = 2 * K + 1;
int temp = 0;
int ans = 0;
for (int i = 0; i < A.size(); i += 2) {
int l = i;
int r = min(i + w, (int)A.size());
temp = sum[r] - sum[l];
chmax(ans, temp);
}
cout << ans << endl;
} | [
"call.add"
] | 885,826 | 885,827 | u995725911 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
const int MAX_N = (int)(1e5 + 5);
int n, k;
string s;
int acc[MAX_N];
int ans;
int main(void) {
// Here your code !
scanf("%d %d", &n, &k);
cin >> s;
if (s[0] == '0') {
acc[0] = 1;
}
for (int i = 1; i < n; ++i) {
if (s[i - 1] == '1' && s[i] == '0') {
acc[i] = 1;
}
}
for (int i = 1; i < n; ++i) {
acc[i] += acc[i - 1];
}
acc[n] = acc[n - 1] + 1;
if (acc[n - 1] <= k) {
printf("%d\n", n);
return 0;
}
ans = -1;
for (int i = 0; i < n; ++i) {
int buff = (s[i] == '0') ? k - 1 : k;
int end = upper_bound(acc + i, acc + n + 1, acc[i] + buff) - acc;
if (acc[end] - acc[i] != buff)
continue;
ans = max(ans, end - i);
}
printf("%d\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
const int MAX_N = (int)(1e5 + 5);
int n, k;
string s;
int acc[MAX_N];
int ans;
int main(void) {
// Here your code !
scanf("%d %d", &n, &k);
cin >> s;
if (s[0] == '0') {
acc[0] = 1;
}
for (int i = 1; i < n; ++i) {
if (s[i - 1] == '1' && s[i] == '0') {
acc[i] = 1;
}
}
for (int i = 1; i < n; ++i) {
acc[i] += acc[i - 1];
}
acc[n] = acc[n - 1] + 1;
if (acc[n - 1] <= k) {
printf("%d\n", n);
return 0;
}
ans = -1;
for (int i = 0; i < n; ++i) {
int buff = (s[i] == '0') ? k - 1 : k;
int end = upper_bound(acc + i, acc + n + 1, acc[i] + buff) - acc;
if ((acc[end] - acc[i]) != buff + 1)
continue;
ans = max(ans, end - i);
}
printf("%d\n", ans);
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 885,837 | 885,838 | u497422208 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> vec;
// 0,2,4,,番目に連続する1の個数を、1,3,5,,,番目に連続する0の個数をpush_backする
if (S[0] == '0') {
vec.push_back(0);
} //最初の連続する1の個数は０
int head = 0;
while (head < N) {
// headは0(または１）の連続する個数を数えるためのスタート位置
int tail = head;
int cnt = 0;
while ((head + tail) < N && S[tail] == S[head]) {
tail++;
cnt++;
}
head = tail;
vec.push_back(cnt);
}
if (S.back() == '0') {
vec.push_back(0);
} //最初と最後は1の個数で終わりたい
//このときのvecの長さは必ず奇数
vector<long long> sum((int)vec.size() + 1, 0);
for (int i = 0; i < vec.size(); i++) {
sum[i + 1] = sum[i] + vec[i];
}
long long ans = 0;
for (int start = 0; start < (int)vec.size(); start++) {
long long res = 0;
int j = start;
if (j % 2 == 0) { // vec[start]は１の個数
int goal = min((int)vec.size() - 1, j + 2 * K);
res = sum[goal + 1] - sum[j];
}
else {
// vec[start]は0の個数
int goal = min((int)vec.size() - 1, j + 2 * K - 1);
res = sum[goal + 1] - sum[j - 1];
}
ans = max(ans, res);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> vec;
// 0,2,4,,番目に連続する1の個数を、1,3,5,,,番目に連続する0の個数をpush_backする
if (S[0] == '0') {
vec.push_back(0);
} //最初の連続する1の個数は０
int head = 0;
while (head < N) {
// headは0(または１）の連続する個数を数えるためのスタート位置
int tail = head;
int cnt = 0;
while (tail < N && S[tail] == S[head]) {
tail++;
cnt++;
}
head = tail;
vec.push_back(cnt);
}
if (S.back() == '0') {
vec.push_back(0);
} //最初と最後は1の個数で終わりたい
//このときのvecの長さは必ず奇数
vector<long long> sum((int)vec.size() + 1, 0);
for (int i = 0; i < vec.size(); i++) {
sum[i + 1] = sum[i] + vec[i];
}
long long ans = 0;
for (int start = 0; start < (int)vec.size(); start++) {
long long res = 0;
int j = start;
if (j % 2 == 0) { // vec[start]は１の個数
int goal = min((int)vec.size() - 1, j + 2 * K);
res = sum[goal + 1] - sum[j];
}
else {
// vec[start]は0の個数
int goal = min((int)vec.size() - 1, j + 2 * K - 1);
res = sum[goal + 1] - sum[j - 1];
}
ans = max(ans, res);
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.condition.change"
] | 885,841 | 885,842 | u904123392 | cpp |
p03074 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
#define N 1000010
int a[N], b[N], ca = 0, cb = 0;
char s[100010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
int flag1 = 0, flag0 = 0, ok = 0;
if (s[1] == '1')
ok = 1;
int ans = 0;
for (int i = 1; i <= n; i++)
if (s[i] == '1') {
flag0 = 0;
if (!flag1)
ca++, flag1 = 1;
a[ca]++;
ans = max(ans, a[ca]);
} else {
ans = max(ans, a[ca]);
flag1 = 0;
if (!flag0)
cb++, flag0 = 1;
b[cb]++;
}
for (int i = 2; i <= ca; i++)
a[i] += a[i - 1];
for (int i = 2; i <= cb; i++)
b[i] += b[i - 1];
if (k >= cb)
ans = n;
for (int i = 1; i + k - 1 <= cb; i++) {
int r = i + k - 1;
int lb = b[r] - b[i - 1];
int x, y;
if (ok)
x = max(1, i), y = min(ca, i + k);
else
x = max(1, i - 1), y = min(ca, i + k);
int la = a[y] - a[x - 1];
ans = max(ans, la + lb);
}
printf("%d\n", ans);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
#define ll long long
#define N 1000010
int a[N], b[N], ca = 0, cb = 0;
char s[100010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
int flag1 = 0, flag0 = 0, ok = 0;
if (s[1] == '1')
ok = 1;
int ans = 0;
for (int i = 1; i <= n; i++)
if (s[i] == '1') {
flag0 = 0;
if (!flag1)
ca++, flag1 = 1;
a[ca]++;
ans = max(ans, a[ca]);
} else {
ans = max(ans, a[ca]);
flag1 = 0;
if (!flag0)
cb++, flag0 = 1;
b[cb]++;
}
for (int i = 2; i <= ca; i++)
a[i] += a[i - 1];
for (int i = 2; i <= cb; i++)
b[i] += b[i - 1];
if (k >= cb)
ans = n;
for (int i = 1; i + k - 1 <= cb; i++) {
int r = i + k - 1;
int lb = b[r] - b[i - 1];
int x, y;
if (ok)
x = max(1, i), y = min(ca, i + k);
else
x = max(1, i - 1), y = min(ca, i + k - 1);
int la = a[y] - a[x - 1];
ans = max(ans, la + lb);
}
printf("%d\n", ans);
return 0;
}
| [
"assignment.change"
] | 885,845 | 885,846 | u820628270 | cpp |
p03074 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define SORT(a) sort(a.begin(), a.end())
#define RSORT(a) sort(a.rbegin(), a.rend())
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = n; 0 <= i; i--)
#define FOR(i, start, end) for (int i = start; i < end; i++)
#define FORSTEP(i, start, end, step) for (int i = start; i < end; i += step)
#define RFOR(i, start, end) for (int i = start; end <= i; i--)
#define ALL(a) a.begin(), a.end()
#define MOD(a) a %= 1000000007
typedef long long ll;
const int INF32 = 2147483647;
const ll INF64 = 9223372036854775807;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
string s;
cin >> s;
vector<int> num;
int now = 1;
int cnt = 0;
REP(i, N) {
if (s[i] == (char)('0' + now))
cnt++;
else {
num.push_back(cnt);
now = 1 - now;
cnt = 1;
}
}
if (cnt != 0)
num.push_back(cnt);
if (num.size() % 2 == 0)
num.push_back(0);
int add = 2 * K + 1;
int ans = 0;
int tmp = 0;
int left = 0;
int right = 0;
REP(i, num.size()) {
int nextLeft = i;
int nextRight = min(i + add, (int)num.size());
while (nextLeft > left) {
tmp -= num[left];
left++;
}
while (nextRight > right) {
tmp += num[right];
right++;
}
ans = max(tmp, ans);
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define SORT(a) sort(a.begin(), a.end())
#define RSORT(a) sort(a.rbegin(), a.rend())
#define REP(i, n) for (int i = 0; i < n; i++)
#define RREP(i, n) for (int i = n; 0 <= i; i--)
#define FOR(i, start, end) for (int i = start; i < end; i++)
#define FORSTEP(i, start, end, step) for (int i = start; i < end; i += step)
#define RFOR(i, start, end) for (int i = start; end <= i; i--)
#define ALL(a) a.begin(), a.end()
#define MOD(a) a %= 1000000007
typedef long long ll;
const int INF32 = 2147483647;
const ll INF64 = 9223372036854775807;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
string s;
cin >> s;
vector<int> num;
int now = 1;
int cnt = 0;
REP(i, N) {
if (s[i] == (char)('0' + now))
cnt++;
else {
num.push_back(cnt);
now = 1 - now;
cnt = 1;
}
}
if (cnt != 0)
num.push_back(cnt);
if (num.size() % 2 == 0)
num.push_back(0);
int add = 2 * K + 1;
int ans = 0;
int tmp = 0;
int left = 0;
int right = 0;
FORSTEP(i, 0, num.size(), 2) {
int nextLeft = i;
int nextRight = min(i + add, (int)num.size());
while (nextLeft > left) {
tmp -= num[left];
left++;
}
while (nextRight > right) {
tmp += num[right];
right++;
}
ans = max(tmp, ans);
}
cout << ans << endl;
return 0;
} | [
"identifier.change",
"call.function.change",
"call.arguments.add"
] | 885,852 | 885,853 | u324303263 | cpp |
p03074 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
vector<int> v;
char c = s[0];
v.push_back(0);
for (int i = 1; i < s.length(); i++) {
if (s[i] != c) {
v.push_back(i);
c = s[i];
}
}
for (int i = 0; i <= 4 * k; i++)
v.push_back(n);
int ans = 0;
if (s[0] == '1') {
for (int i = 0; 2 * (k + i) < v.size(); i++) {
ans = max(ans, v[2 * (k + i)] - v[2 * i]);
}
for (int i = 0; 2 * (k + i) + 1 < v.size(); i++) {
ans = max(ans, v[2 * (k + i) + 1] - v[2 * i]);
}
} else {
for (int i = 0; 2 * (k + i) < v.size(); i++) {
ans = max(ans, v[2 * (k + i)] - v[2 * i]);
}
for (int i = 0; 2 * (k + i) + 3 < v.size(); i++) {
ans = max(ans, v[2 * (k + i) + 3] - v[2 * i + 1]);
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
int main() {
int n, k;
string s;
cin >> n >> k >> s;
vector<int> v;
char c = s[0];
v.push_back(0);
for (int i = 1; i < s.length(); i++) {
if (s[i] != c) {
v.push_back(i);
c = s[i];
}
}
for (int i = 0; i <= 4 * k; i++)
v.push_back(n);
int ans = 0;
if (s[0] == '1') {
for (int i = 0; 2 * (k + i) < v.size(); i++) {
ans = max(ans, v[2 * (k + i)] - v[2 * i]);
}
for (int i = 0; 2 * (k + i) + 1 < v.size(); i++) {
ans = max(ans, v[2 * (k + i) + 1] - v[2 * i]);
}
} else {
for (int i = 0; 2 * (k + i) < v.size(); i++) {
ans = max(ans, v[2 * (k + i)] - v[2 * i]);
}
for (int i = 0; 2 * (k + i) + 2 < v.size(); i++) {
ans = max(ans, v[2 * (k + i) + 2] - v[2 * i + 1]);
}
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 885,856 | 885,857 | u348670055 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
const ll INF = 1LL << 60;
#define rep(i, a, n) for (ll i = (a); i < (n); i++)
#define debug(x) cerr << #x << ": " << x << endl;
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;
}
int main() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
vector<ll> vec;
vec.push_back(0);
rep(i, 1, n) {
if (s[i - 1] != s[i])
vec.push_back(i);
}
ll m = vec.size();
rep(i, 0, n + 4 * k) vec.push_back(n);
ll ans = 0;
rep(i, 0, m) {
ll idx = vec[i];
if (s[idx] == '0')
chmax(ans, vec[idx + 2 * k] - vec[idx]);
if (s[idx] == '1')
chmax(ans, vec[idx + 2 * k + 1] - vec[idx]);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
const ll INF = 1LL << 60;
#define rep(i, a, n) for (ll i = (a); i < (n); i++)
#define debug(x) cerr << #x << ": " << x << endl;
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;
}
int main() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
vector<ll> vec;
vec.push_back(0);
rep(i, 1, n) {
if (s[i - 1] != s[i])
vec.push_back(i);
}
ll m = vec.size();
rep(i, 0, n + 4 * k) vec.push_back(n);
ll ans = 0;
rep(i, 0, m) {
ll idx = vec[i];
if (s[idx] == '0')
chmax(ans, vec[i + 2 * k] - vec[i]);
if (s[idx] == '1')
chmax(ans, vec[i + 2 * k + 1] - vec[i]);
}
cout << ans << endl;
}
| [
"identifier.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 885,865 | 885,866 | u318785595 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define inf 1000000000
#define pb push_back
#define mp make_pair
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define yoi cout << "yo" << endl;
#define debug(i) cout << i << endl;
const int mod = 1e9 + 7;
int main() {
IOS;
int n, k, i;
cin >> n >> k;
string s;
cin >> s;
int a[n];
memset(a, 0, sizeof(a));
for (i = 0; i < n; i++) {
if (s[i] - 48)
a[i] = 1;
}
int start = 0;
vector<pair<int, int>> v;
for (i = 0; i < n; i++) {
if (a[i] && start < i) {
v.pb({start, i - 1});
start = i + 1;
} else if (a[i])
start++;
}
if (start != n)
v.pb({start, n - 1});
if (v.size() <= k) {
cout << n << endl;
return 0;
}
int maxi = v[k].first;
for (i = k; i < v.size(); i++) {
if (i != v.size() - 1)
maxi = max(maxi, v[i + 1].first - v[i - k].second);
else
maxi = max(maxi, n - v[i - k].second);
}
cout << maxi << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define inf 1000000000
#define pb push_back
#define mp make_pair
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define yoi cout << "yo" << endl;
#define debug(i) cout << i << endl;
const int mod = 1e9 + 7;
int main() {
IOS;
int n, k, i;
cin >> n >> k;
string s;
cin >> s;
int a[n];
memset(a, 0, sizeof(a));
for (i = 0; i < n; i++) {
if (s[i] - 48)
a[i] = 1;
}
int start = 0;
vector<pair<int, int>> v;
for (i = 0; i < n; i++) {
if (a[i] && start < i) {
v.pb({start, i - 1});
start = i + 1;
} else if (a[i])
start++;
}
if (start != n)
v.pb({start, n - 1});
if (v.size() <= k) {
cout << n << endl;
return 0;
}
int maxi = v[k].first;
for (i = k; i < v.size(); i++) {
if (i != v.size() - 1)
maxi = max(maxi, v[i + 1].first - v[i - k].second - 1);
else
maxi = max(maxi, n - 1 - v[i - k].second);
}
cout << maxi << endl;
}
| [
"assignment.change"
] | 885,867 | 885,868 | u653046450 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define inf 1000000000
#define pb push_back
#define mp make_pair
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define yoi cout << "yo" << endl;
#define debug(i) cout << i << endl;
const int mod = 1e9 + 7;
int main() {
IOS;
int n, k, i;
cin >> n >> k;
string s;
cin >> s;
int a[n];
memset(a, 0, sizeof(a));
for (i = 0; i < n; i++) {
if (s[i] - 48)
a[i] = 1;
}
int start = 0;
vector<pair<int, int>> v;
for (i = 0; i < n; i++) {
if (a[i] && start < i) {
v.pb({start, i - 1});
start = i + 1;
} else if (a[i])
start++;
}
if (start != n)
v.pb({start, n - 1});
if (v.size() <= k) {
cout << n << endl;
return 0;
}
int maxi = v[k].first;
for (i = k; i < v.size(); i++) {
if (i != v.size() - 1)
maxi = max(maxi, v[i + 1].first - v[i - k].second);
else
maxi = max(maxi, n - 1 - v[i - k].second);
}
cout << maxi << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define inf 1000000000
#define pb push_back
#define mp make_pair
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define endl "\n"
#define yoi cout << "yo" << endl;
#define debug(i) cout << i << endl;
const int mod = 1e9 + 7;
int main() {
IOS;
int n, k, i;
cin >> n >> k;
string s;
cin >> s;
int a[n];
memset(a, 0, sizeof(a));
for (i = 0; i < n; i++) {
if (s[i] - 48)
a[i] = 1;
}
int start = 0;
vector<pair<int, int>> v;
for (i = 0; i < n; i++) {
if (a[i] && start < i) {
v.pb({start, i - 1});
start = i + 1;
} else if (a[i])
start++;
}
if (start != n)
v.pb({start, n - 1});
if (v.size() <= k) {
cout << n << endl;
return 0;
}
int maxi = v[k].first;
for (i = k; i < v.size(); i++) {
if (i != v.size() - 1)
maxi = max(maxi, v[i + 1].first - v[i - k].second - 1);
else
maxi = max(maxi, n - 1 - v[i - k].second);
}
cout << maxi << endl;
}
| [
"assignment.change"
] | 885,869 | 885,868 | u653046450 | cpp |
p03074 | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<long long> a;
int cnt = 0;
char bef = '1';
for (int i = 0; i < n; i++) {
if (bef == s[i]) {
cnt++;
} else {
a.push_back(cnt);
cnt = 1;
bef = s[i];
}
}
a.push_back(cnt);
long long ans = 0;
long long tmp = 0;
if (a.size() <= k * 2 + 1) {
for (int i = 0; i < a.size(); i++)
ans += a[i];
cout << ans << endl;
return 0;
}
for (int i = 0; i < k * 2 + 1; i++)
ans += a[i];
tmp = ans;
for (int i = k * 2 + 2; i < a.size(); i += 2) {
tmp -= a[i - (k * 2 + 1)];
tmp -= a[i - (k * 2 + 1) - 1];
tmp += a[i];
tmp += a[i - 1];
if (tmp > ans)
ans = tmp;
}
// for(int i=0;i<a.size();i++)
// cout << a[i] << endl;
cout << ans << endl;
}
| #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<long long> a;
int cnt = 0;
char bef = '1';
for (int i = 0; i < n; i++) {
if (bef == s[i]) {
cnt++;
} else {
a.push_back(cnt);
cnt = 1;
bef = s[i];
}
}
a.push_back(cnt);
long long ans = 0;
long long tmp = 0;
if (a.size() < k * 2 + 1) {
for (int i = 0; i < a.size(); i++)
ans += a[i];
cout << ans << endl;
return 0;
}
for (int i = 0; i < k * 2 + 1; i++)
ans += a[i];
tmp = ans;
for (int i = k * 2 + 1; i < a.size(); i += 2) {
tmp -= a[i - (k * 2 + 1)];
tmp -= a[i - (k * 2 + 1) + 1];
tmp += a[i];
tmp += a[i + 1];
if (tmp > ans)
ans = tmp;
}
// for(int i=0;i<a.size();i++)
// cout << a[i] << endl;
cout << ans << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
... | 885,876 | 885,877 | u990764614 | cpp |
p03074 | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<long long> a;
int cnt = 0;
char bef = '1';
for (int i = 0; i < n; i++) {
if (bef == s[i]) {
cnt++;
} else {
a.push_back(cnt);
cnt = 1;
bef = s[i];
}
}
a.push_back(cnt);
long long ans = 0;
long long tmp = 0;
if (a.size() < k * 2 + 1) {
for (int i = 0; i < s.size(); i++)
ans += a[i];
cout << ans << endl;
return 0;
}
for (int i = 0; i < k * 2 + 1; i++)
ans += a[i];
tmp = ans;
for (int i = k * 2 + 2; i < a.size(); i += 2) {
tmp -= a[i - (k * 2 + 1)];
tmp -= a[i - (k * 2 + 1) - 1];
tmp += a[i];
tmp += a[i - 1];
if (tmp > ans)
ans = tmp;
}
// for(int i=0;i<a.size();i++)
// cout << a[i] << endl;
cout << ans << endl;
}
| #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<long long> a;
int cnt = 0;
char bef = '1';
for (int i = 0; i < n; i++) {
if (bef == s[i]) {
cnt++;
} else {
a.push_back(cnt);
cnt = 1;
bef = s[i];
}
}
a.push_back(cnt);
long long ans = 0;
long long tmp = 0;
if (a.size() < k * 2 + 1) {
for (int i = 0; i < a.size(); i++)
ans += a[i];
cout << ans << endl;
return 0;
}
for (int i = 0; i < k * 2 + 1; i++)
ans += a[i];
tmp = ans;
for (int i = k * 2 + 1; i < a.size(); i += 2) {
tmp -= a[i - (k * 2 + 1)];
tmp -= a[i - (k * 2 + 1) + 1];
tmp += a[i];
tmp += a[i + 1];
if (tmp > ans)
ans = tmp;
}
// for(int i=0;i<a.size();i++)
// cout << a[i] << endl;
cout << ans << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change",
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access... | 885,878 | 885,877 | u990764614 | cpp |
p03074 | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<long long> a;
int cnt = 0;
char bef = '1';
for (int i = 0; i < n; i++) {
if (bef == s[i]) {
cnt++;
} else {
a.push_back(cnt);
cnt = 1;
bef = s[i];
}
}
a.push_back(cnt);
long long ans = 0;
long long tmp = 0;
if (a.size() < k * 2 + 1) {
for (int i = 0; i < s.size(); i++)
ans += a[i];
cout << ans << endl;
return 0;
}
for (int i = 0; i < k * 2 + 1; i++)
ans += a[i];
tmp = ans;
for (int i = k * 2 + 1; i + 1 < a.size(); i += 2) {
tmp -= a[i - (k * 2 + 1)];
tmp -= a[i - (k * 2 + 1) + 1];
tmp += a[i];
tmp += a[i + 1];
if (tmp > ans)
ans = tmp;
}
// for(int i=0;i<a.size();i++)
// cout << a[i] << endl;
cout << ans << endl;
}
| #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<long long> a;
int cnt = 0;
char bef = '1';
for (int i = 0; i < n; i++) {
if (bef == s[i]) {
cnt++;
} else {
a.push_back(cnt);
cnt = 1;
bef = s[i];
}
}
a.push_back(cnt);
long long ans = 0;
long long tmp = 0;
if (a.size() < k * 2 + 1) {
for (int i = 0; i < a.size(); i++)
ans += a[i];
cout << ans << endl;
return 0;
}
for (int i = 0; i < k * 2 + 1; i++)
ans += a[i];
tmp = ans;
for (int i = k * 2 + 1; i < a.size(); i += 2) {
tmp -= a[i - (k * 2 + 1)];
tmp -= a[i - (k * 2 + 1) + 1];
tmp += a[i];
tmp += a[i + 1];
if (tmp > ans)
ans = tmp;
}
// for(int i=0;i<a.size();i++)
// cout << a[i] << endl;
cout << ans << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 885,879 | 885,877 | u990764614 | cpp |
p03074 | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<long long> a;
int cnt = 0;
char bef = '1';
for (int i = 0; i < n; i++) {
if (bef == s[i]) {
cnt++;
} else {
a.push_back(cnt);
cnt = 1;
bef = s[i];
}
}
a.push_back(cnt);
long long ans = 0;
long long tmp = 0;
if (a.size() < k * 2 + 1) {
for (int i = 0; i < s.size(); i++)
ans += a[i];
cout << ans << endl;
return 0;
}
for (int i = 0; i < k * 2 + 1; i++)
ans += a[i];
tmp = ans;
for (int i = k * 2 + 1; i < a.size(); i += 2) {
tmp -= a[i - (k * 2 + 1)];
tmp -= a[i - (k * 2 + 1) + 1];
tmp += a[i];
tmp += a[i + 1];
if (tmp > ans)
ans = tmp;
}
// for(int i=0;i<a.size();i++)
// cout << a[i] << endl;
cout << ans << endl;
}
| #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<long long> a;
int cnt = 0;
char bef = '1';
for (int i = 0; i < n; i++) {
if (bef == s[i]) {
cnt++;
} else {
a.push_back(cnt);
cnt = 1;
bef = s[i];
}
}
a.push_back(cnt);
long long ans = 0;
long long tmp = 0;
if (a.size() < k * 2 + 1) {
for (int i = 0; i < a.size(); i++)
ans += a[i];
cout << ans << endl;
return 0;
}
for (int i = 0; i < k * 2 + 1; i++)
ans += a[i];
tmp = ans;
for (int i = k * 2 + 1; i < a.size(); i += 2) {
tmp -= a[i - (k * 2 + 1)];
tmp -= a[i - (k * 2 + 1) + 1];
tmp += a[i];
tmp += a[i + 1];
if (tmp > ans)
ans = tmp;
}
// for(int i=0;i<a.size();i++)
// cout << a[i] << endl;
cout << ans << endl;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 885,880 | 885,877 | u990764614 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> b(N);
for (int i = 0; i < N; ++i) {
if (S.at(i) == '0') {
b.at(i) = 0;
} else {
b.at(i) = 1;
}
}
vector<int> change;
change.push_back(0);
for (int i = 1; i < N; ++i) {
if (b.at(i) != b.at(i - 1))
change.push_back(i);
}
int maxi = 0;
for (int i = 0; i < change.size(); ++i) {
if (b.at(i) == 0) {
if (i + 2 * K < change.size()) {
maxi = max(maxi, change.at(i + 2 * K) - change.at(i));
} else {
maxi = max(maxi, N - change.at(i));
}
} else {
if (i + 2 * K + 1 < change.size()) {
maxi = max(maxi, change.at(i + 2 * K + 1) - change.at(i));
} else {
maxi = max(maxi, N - change.at(i));
}
}
}
cout << maxi << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> b(N);
for (int i = 0; i < N; ++i) {
if (S.at(i) == '0') {
b.at(i) = 0;
} else {
b.at(i) = 1;
}
}
vector<int> change;
change.push_back(0);
for (int i = 1; i < N; ++i) {
if (b.at(i) != b.at(i - 1))
change.push_back(i);
}
int maxi = 0;
for (int i = 0; i < change.size(); ++i) {
if (b.at(change.at(i)) == 0) {
if (i + 2 * K < change.size()) {
maxi = max(maxi, change.at(i + 2 * K) - change.at(i));
} else {
maxi = max(maxi, N - change.at(i));
}
} else {
if (i + 2 * K + 1 < change.size()) {
maxi = max(maxi, change.at(i + 2 * K + 1) - change.at(i));
} else {
maxi = max(maxi, N - change.at(i));
}
}
}
cout << maxi << endl;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"call.add"
] | 885,889 | 885,890 | u036192637 | cpp |
p03074 | #include <algorithm>
#include <algorithm> // sort
#include <cmath>
#include <iostream>
#include <map> // pair
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
int main() {
ll n, k, count0 = 0, count1 = 0, sum = 0, size = 0;
string s;
cin >> n >> k;
cin >> s;
vector<ll> vec(n + 1, 0);
vec[size] = 0;
size++;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
if (count1 != 0) {
vec[size] = i;
count1 = 0;
count0++;
size++;
} else {
count0++;
}
} else {
if (count0 != 0) {
vec[size] = i;
count0 = 0;
count1++;
size++;
} else {
count1++;
}
}
}
vec[size] = n;
// size++;
// for(int i=0;i<size;i++){
// cout << vec[i] << endl;
// }
// cout << endl;
// cout << "size" << size << endl;
if (s[0] == '0') {
if ((size + 1) / 2 <= k) {
sum = n;
} else {
sum = vec[2 * k];
// cout << sum << endl;
for (int i = 0; i + 2 * k + 2 < size; i += 2) {
sum = max(sum, vec[2 * k + i + 2] - vec[i + 1]);
// cout << vec[2*k+i+2]-vec[i+1] << endl;
}
if (size % 2 == 0) {
sum = max(sum, n - vec[size - 2 * k + 1]);
// cout << n-vec[size-2*k-1] << endl;
} else {
sum = max(sum, n - vec[size - 2 * k + 1]);
// cout << n-vec[size-2*k] << endl;
}
}
} else {
if (size / 2 <= k) {
sum = n;
} else {
sum = vec[2 * k + 1];
// cout << sum << endl;
for (int i = 1; i + 2 * k + 2 < size; i += 2) {
sum = max(sum, vec[2 * k + i + 2] - vec[i + 1]);
// cout << vec[2*k+i+2]-vec[i+1] << endl;
}
if (size % 2 == 0) {
sum = max(sum, n - vec[size - 2 * k]);
// cout << n-vec[size-2*k-1] << endl;
} else {
sum = max(sum, n - vec[size - 2 * k - 1]);
// cout << n-vec[size-2*k-1] << endl;
}
}
}
cout << sum;
}
| #include <algorithm>
#include <algorithm> // sort
#include <cmath>
#include <iostream>
#include <map> // pair
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
int main() {
ll n, k, count0 = 0, count1 = 0, sum = 0, size = 0;
string s;
cin >> n >> k;
cin >> s;
vector<ll> vec(n + 1, 0);
vec[size] = 0;
size++;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
if (count1 != 0) {
vec[size] = i;
count1 = 0;
count0++;
size++;
} else {
count0++;
}
} else {
if (count0 != 0) {
vec[size] = i;
count0 = 0;
count1++;
size++;
} else {
count1++;
}
}
}
vec[size] = n;
// size++;
// for(int i=0;i<size;i++){
// cout << vec[i] << endl;
// }
// cout << endl;
// cout << "size" << size << endl;
if (s[0] == '0') {
if ((size + 1) / 2 <= k) {
sum = n;
} else {
sum = vec[2 * k];
// cout << sum << endl;
for (int i = 0; i + 2 * k + 2 < size; i += 2) {
sum = max(sum, vec[2 * k + i + 2] - vec[i + 1]);
// cout << vec[2*k+i+2]-vec[i+1] << endl;
}
if (size % 2 == 0) {
sum = max(sum, n - vec[size - 2 * k - 1]);
// cout << n-vec[size-2*k-1] << endl;
} else {
sum = max(sum, n - vec[size - 2 * k]);
// cout << n-vec[size-2*k] << endl;
}
}
} else {
if (size / 2 <= k) {
sum = n;
} else {
sum = vec[2 * k + 1];
// cout << sum << endl;
for (int i = 1; i + 2 * k + 2 < size; i += 2) {
sum = max(sum, vec[2 * k + i + 2] - vec[i + 1]);
// cout << vec[2*k+i+2]-vec[i+1] << endl;
}
if (size % 2 == 0) {
sum = max(sum, n - vec[size - 2 * k]);
// cout << n-vec[size-2*k-1] << endl;
} else {
sum = max(sum, n - vec[size - 2 * k - 1]);
// cout << n-vec[size-2*k-1] << endl;
}
}
}
cout << sum;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 885,891 | 885,892 | u276796245 | cpp |
p03074 | // besmellah
#include <bits/stdc++.h>
using namespace std;
// __builtin_popcount
vector<long long> dp;
vector<long long> PS;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
dp.push_back(1);
string s;
cin >> s;
for (long long i = 1; i < n; i++) {
if (s[i] != s[i - 1]) {
dp.push_back(1);
} else {
dp[dp.size() - 1]++;
}
}
PS.resize(dp.size() + 1);
for (long long i = 1; i <= dp.size(); i++)
PS[i] = PS[i - 1] + dp[i - 1];
if (dp.size() <= 2 * k || (dp.size() == 2 * k + 1) && s[0] == '1') {
cout << n;
return 0;
}
long long ans = 0;
for (long long i = 0; i < dp.size(); i++) {
if (s[0] == i % 2 + '0') {
if (i + 2 * k > dp.size()) {
ans = max(ans, PS[dp.size()] - PS[i]);
// break;
}
ans = max(ans, PS[i + 2 * k] - PS[i]);
} else {
if (i + 2 * k + 1 > dp.size()) {
ans = max(ans, PS[dp.size()] - PS[i]);
// break;
}
ans = max(ans, PS[i + 2 * k + 1] - PS[i]);
}
}
cout << ans;
} | // besmellah
#include <bits/stdc++.h>
using namespace std;
// __builtin_popcount
vector<long long> dp;
vector<long long> PS;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
dp.push_back(1);
string s;
cin >> s;
for (long long i = 1; i < n; i++) {
if (s[i] != s[i - 1]) {
dp.push_back(1);
} else {
dp[dp.size() - 1]++;
}
}
PS.resize(dp.size() + 1);
for (long long i = 1; i <= dp.size(); i++)
PS[i] = PS[i - 1] + dp[i - 1];
if (dp.size() <= 2 * k || (dp.size() == 2 * k + 1) && s[0] == '1') {
cout << n;
return 0;
}
long long ans = 0;
for (long long i = 0; i < dp.size(); i++) {
if (s[0] == i % 2 + '0') {
if (i + 2 * k > dp.size()) {
ans = max(ans, PS[dp.size()] - PS[i]);
// break;
} else
ans = max(ans, PS[i + 2 * k] - PS[i]);
} else {
if (i + 2 * k + 1 > dp.size()) {
ans = max(ans, PS[dp.size()] - PS[i]);
// break;
} else
ans = max(ans, PS[i + 2 * k + 1] - PS[i]);
}
}
cout << ans;
} | [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 885,893 | 885,894 | u170407818 | cpp |
p03074 | #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
#define UL unsigned long long
int main(void) {
IOS int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> d;
// if (s[0]== '0') d.push_back(0);
d.push_back(1);
for (auto i = 1; i < n; i++) {
if (s[i - 1] != s[i]) {
d.emplace_back(i + 1);
}
// tail
if (i == n - 1) {
d.emplace_back(i + 2);
}
}
/*
cerr << "zeroone: ";
for(int i = 0; i < d.size() ; i++) {
cerr << d[i] << " ";
}
cerr << endl;
*/
int m = d.size();
if (m < k * 2 + 1) {
cout << n << endl;
return 0;
}
int ans = 0;
int tmp = 0;
for (int i = 0; i < m - k * 2; i++) {
if ((s[i] == '1') && (i + k * 2 + 1 < m)) {
tmp = d[i + k * 2 + 1] - d[i];
} else {
tmp = d[i + k * 2] - d[i];
}
// cerr << "i: " << i << " tmp: " << tmp << endl;
// cerr <<" tmp: " << tmp << endl;
ans = max(ans, tmp);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
#define UL unsigned long long
int main(void) {
IOS int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> d;
// if (s[0]== '0') d.push_back(0);
d.push_back(1);
for (auto i = 1; i < n; i++) {
if (s[i - 1] != s[i]) {
d.emplace_back(i + 1);
}
// tail
if (i == n - 1) {
d.emplace_back(i + 2);
}
}
/*
cerr << "zeroone: ";
for(int i = 0; i < d.size() ; i++) {
cerr << d[i] << " ";
}
cerr << endl;
*/
int m = d.size();
if (m < k * 2 + 1) {
cout << n << endl;
return 0;
}
int ans = 0;
int tmp = 0;
for (int i = 0; i < m - k * 2; i++) {
if ((s[d[i] - 1] == '1') && (i + k * 2 + 1 < m)) {
tmp = d[i + k * 2 + 1] - d[i];
} else {
tmp = d[i + k * 2] - d[i];
}
// cerr << "i: " << i << " tmp: " << tmp << endl;
// cerr <<" tmp: " << tmp << endl;
ans = max(ans, tmp);
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 885,895 | 885,896 | u330661451 | cpp |
p03074 | #include <algorithm>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
#define INT_MAX_VALUE 2147483647
#define LONG_LONG_MAX_VALUE 9223372036854775807
#define ll long long
#define ld long double
struct XX {
int a;
int i;
};
class xxGreater {
public:
bool operator()(const XX &riLeft, const XX &riRight) const {
//第2条件
if ((riLeft.a) == (riRight.a)) {
return riLeft.i >
riRight.i; //<:昇順(小さいものから順番)、>:降順(大きいものから順番)
//プライオリティキューの場合は > で、top()すると値の小さいものがとれる
}
//第1条件
return (riLeft.a) > (riRight.a);
}
};
class xxGreater2 {
public:
bool operator()(const XX &riLeft, const XX &riRight) const {
return (riLeft.i) < (riRight.i);
}
};
class xxGreater3 {
public:
bool operator()(const XX &riLeft, const XX &riRight) const {
return (riLeft.a) < (riRight.a);
}
};
// map<long long,long long> prime_f(long long n){
// map<long long,long long>res;
// for(int i=2;i*i<=n;i++){
// while(n%i==0){
// ++res[i];
// n/=i;
// }
// }
// if(n!=1)res[n]=1;
// return res;
//}
// int n;
////int dat[2*10000000];
////int dat2[2*10000000];
// int dat[10];
// int dat2[10];
//
// void init(int n_){
// n=1;
// while(n<n_)n*=2;
// for(int i=0;i<2*n-1;i++){
// dat[i]=0;
// dat2[i]=0;
// }
//}
//
// void initset(int k,int a){
// k+=n-1;
// dat[k]=a;
// while(k>0){
// k=(k-1)/2;
// dat[k]=dat[k*2+1]+dat[k*2+2];
// }
//}
//
////[a,b)の間を[l,r]区間で比較しアップデート
////引数のindexに注意
////nは固定。initで計算すみ
////update2(L[i],R[i]+1,0,0,n,D[i]);
// void update2(int a,int b,int k,int l,int r,int v){//v更新値、区間は0-index
// if(r<=a || b<=l)return;
// if(a<=l && r<=b){
// dat[k]+=dat2[k];
// if(r-l>1){
// dat2[k*2+1]+=dat2[k]/2;
// dat2[k*2+1]+=dat2[k]/2;
// }
// dat2[k]=v*(r-l);
// return;
// }else{
// update2(a,b,k*2+1,l,(l+r)/2,v);
// update2(a,b,k*2+2,(l+r)/2,r,v);
// return;
// }
//}
//
// int query(int a,int b,int k,int l,int r){
// if(r<=a || b<=l)return 0;
// if(a<=l && r<=b){
// dat[k]+=dat2[k];
// if(r-l>1){
// dat2[k*2+1]+=dat2[k]/2;
// dat2[k*2+1]+=dat2[k]/2;
// }
// dat2[k]=0;
// return dat[k];
// }
// else{
// int vl=query(a,b,k*2+1,l,(l+r)/2);
// int vr=query(a,b,k*2+2,(l+r)/2,r);
// return vl+vr;
// }
//}
int main(int argc, const char *argv[]) {
// scanf("%s",S);
// scanf("%d",&N);
// scanf("%lld %lld",&target1,&target2);
// sscanf(tmp.c_str(),"%dd%d%d",&time[i], &dice[i], &z[i]);
// getline(cin, target);
// ifstream ifs("a.txt");//テスト用
// ifs >> a;
//ここから
//入力高速化
ios::sync_with_stdio(false);
cin.tie(0);
// ifstream ifs("a.txt");
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<ll> a;
int cnt = 1;
for (int i = 1; i < s.size(); i++) {
if (s[i] != s[i - 1]) {
a.push_back(cnt);
cnt = 1;
} else {
cnt++;
}
}
a.push_back(cnt);
queue<ll> q;
ll sum = 0;
ll ans = 0;
if (s[0] == '1') {
for (int i = 0; i < 2 * k + 1; i++) {
if (i >= a.size())
break;
q.push(a[i]);
sum += a[i];
}
ans = sum;
for (int i = 2 * k + 1; i < a.size(); i++) {
ll tmp = q.front();
q.pop();
sum = sum - tmp + a[i];
q.push(a[i]);
if ((i - (2 * k + 1)) % 2 != 0) {
ans = max(ans, sum);
}
}
} else {
for (int i = 0; i < 2 * k; i++) {
if (i >= a.size())
break;
q.push(a[i]);
sum += a[i];
}
ans = sum;
for (int i = 2 * k; i < a.size(); i++) {
ll tmp = q.front();
q.pop();
sum = sum - tmp + a[i];
q.push(a[i]);
if ((i - (2 * k)) % 2 != 0) {
ans = max(ans, sum);
}
}
}
sum = 0;
if (s[0] == '0') {
for (int i = 0; i < 2 * k; i++) {
if (i >= a.size())
break;
sum += a[i];
}
ans = max(ans, sum);
}
sum = 0;
if (s[s.size() - 1] == '0') {
for (int i = 0; i < 2 * k; i++) {
if ((int)a.size() - 1 - i < 0)
break;
sum += a[a.size() - 1 - i];
}
ans = max(ans, sum);
}
cout << ans << endl;
//ここまで
// cout << "ans" << endl;
// printf("%.0f\n",ans);//小数点以下表示なし
// printf("%.7f\n",p);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
#define INT_MAX_VALUE 2147483647
#define LONG_LONG_MAX_VALUE 9223372036854775807
#define ll long long
#define ld long double
struct XX {
int a;
int i;
};
class xxGreater {
public:
bool operator()(const XX &riLeft, const XX &riRight) const {
//第2条件
if ((riLeft.a) == (riRight.a)) {
return riLeft.i >
riRight.i; //<:昇順(小さいものから順番)、>:降順(大きいものから順番)
//プライオリティキューの場合は > で、top()すると値の小さいものがとれる
}
//第1条件
return (riLeft.a) > (riRight.a);
}
};
class xxGreater2 {
public:
bool operator()(const XX &riLeft, const XX &riRight) const {
return (riLeft.i) < (riRight.i);
}
};
class xxGreater3 {
public:
bool operator()(const XX &riLeft, const XX &riRight) const {
return (riLeft.a) < (riRight.a);
}
};
// map<long long,long long> prime_f(long long n){
// map<long long,long long>res;
// for(int i=2;i*i<=n;i++){
// while(n%i==0){
// ++res[i];
// n/=i;
// }
// }
// if(n!=1)res[n]=1;
// return res;
//}
// int n;
////int dat[2*10000000];
////int dat2[2*10000000];
// int dat[10];
// int dat2[10];
//
// void init(int n_){
// n=1;
// while(n<n_)n*=2;
// for(int i=0;i<2*n-1;i++){
// dat[i]=0;
// dat2[i]=0;
// }
//}
//
// void initset(int k,int a){
// k+=n-1;
// dat[k]=a;
// while(k>0){
// k=(k-1)/2;
// dat[k]=dat[k*2+1]+dat[k*2+2];
// }
//}
//
////[a,b)の間を[l,r]区間で比較しアップデート
////引数のindexに注意
////nは固定。initで計算すみ
////update2(L[i],R[i]+1,0,0,n,D[i]);
// void update2(int a,int b,int k,int l,int r,int v){//v更新値、区間は0-index
// if(r<=a || b<=l)return;
// if(a<=l && r<=b){
// dat[k]+=dat2[k];
// if(r-l>1){
// dat2[k*2+1]+=dat2[k]/2;
// dat2[k*2+1]+=dat2[k]/2;
// }
// dat2[k]=v*(r-l);
// return;
// }else{
// update2(a,b,k*2+1,l,(l+r)/2,v);
// update2(a,b,k*2+2,(l+r)/2,r,v);
// return;
// }
//}
//
// int query(int a,int b,int k,int l,int r){
// if(r<=a || b<=l)return 0;
// if(a<=l && r<=b){
// dat[k]+=dat2[k];
// if(r-l>1){
// dat2[k*2+1]+=dat2[k]/2;
// dat2[k*2+1]+=dat2[k]/2;
// }
// dat2[k]=0;
// return dat[k];
// }
// else{
// int vl=query(a,b,k*2+1,l,(l+r)/2);
// int vr=query(a,b,k*2+2,(l+r)/2,r);
// return vl+vr;
// }
//}
int main(int argc, const char *argv[]) {
// scanf("%s",S);
// scanf("%d",&N);
// scanf("%lld %lld",&target1,&target2);
// sscanf(tmp.c_str(),"%dd%d%d",&time[i], &dice[i], &z[i]);
// getline(cin, target);
// ifstream ifs("a.txt");//テスト用
// ifs >> a;
//ここから
//入力高速化
ios::sync_with_stdio(false);
cin.tie(0);
// ifstream ifs("a.txt");
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<ll> a;
int cnt = 1;
for (int i = 1; i < s.size(); i++) {
if (s[i] != s[i - 1]) {
a.push_back(cnt);
cnt = 1;
} else {
cnt++;
}
}
a.push_back(cnt);
queue<ll> q;
ll sum = 0;
ll ans = 0;
if (s[0] == '1') {
for (int i = 0; i < 2 * k + 1; i++) {
if (i >= a.size())
break;
q.push(a[i]);
sum += a[i];
}
ans = sum;
for (int i = 2 * k + 1; i < a.size(); i++) {
ll tmp = q.front();
q.pop();
sum = sum - tmp + a[i];
q.push(a[i]);
if ((i - (2 * k + 1)) % 2 != 0) {
ans = max(ans, sum);
}
}
} else {
for (int i = 1; i < 2 * k + 2; i++) {
if (i >= a.size())
break;
q.push(a[i]);
sum += a[i];
}
ans = sum;
for (int i = 2 * k + 2; i < a.size(); i++) {
ll tmp = q.front();
q.pop();
sum = sum - tmp + a[i];
q.push(a[i]);
if ((i - (2 * k)) % 2 != 0) {
ans = max(ans, sum);
}
}
}
sum = 0;
if (s[0] == '0') {
for (int i = 0; i < 2 * k; i++) {
if (i >= a.size())
break;
sum += a[i];
}
ans = max(ans, sum);
}
sum = 0;
if (s[s.size() - 1] == '0') {
for (int i = 0; i < 2 * k; i++) {
if ((int)a.size() - 1 - i < 0)
break;
sum += a[a.size() - 1 - i];
}
ans = max(ans, sum);
}
cout << ans << endl;
//ここまで
// cout << "ans" << endl;
// printf("%.0f\n",ans);//小数点以下表示なし
// printf("%.7f\n",p);
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 885,897 | 885,898 | u649310245 | cpp |
p03074 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<string> vs;
typedef vector<vector<string>> vvs;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
bool praime_numbers[100001];
static const int MOD = 1000000007;
const int int_inf = 2147483647;
const ll long_inf = 9223372036854775807ll;
#define rep(i, n) for (int i = 0; i < n; i++)
//#define rep(j,n) for(int j = 0;j<n;j++)
#define defvi(a, c) vector<int>(a, c)
#define defvvi(a, b, c) vector<vector<int>>(a, vector<int>(b, c))
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
void check_1D(vector<int> &ls);
void check_2D(vector<vector<int>> &ls);
int main() {
ios::sync_with_stdio(false);
//ここからコードを書く
int n, k, check = 1, count = 0, ans = 0, change, beforCheck = -1;
string s;
cin >> n >> k;
cin >> s;
if (s.back() == '0')
s += '1';
else
s += '0';
if (n == 1) {
cout << 1 << endl;
exit(0);
}
for (int i = 0; i < n; i++) {
if (s[i] == '0')
change = k * 2;
else
change = k * 2 + 1;
if (i != 0) {
if (s[i] != s[i - 1])
count--;
}
for (; check < n + 1; check++) {
if (s[check] != s[check - 1] && beforCheck != check)
count++;
if (count >= change) {
ans = max(ans, check - i);
beforCheck = check;
break;
}
}
}
cout << ans << endl;
//ここまで
}
//デバック用関数
//一次元の配列を出力する関数
void check_1D(vector<int> &ls) {
int length = ls.size();
for (int i = 0; i < length; i++) {
cout << ls[i] << ' ';
}
cout << endl;
}
//二次元配列を出力する関数
void check_2D(vector<vector<int>> &ls) {
for (int i = 0; i < ls.size(); i++) {
for (int j = 0; j < ls[0].size(); j++) {
cout << ls[i][j] << ' ';
}
cout << endl;
}
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <stdlib.h>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<string> vs;
typedef vector<vector<string>> vvs;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
bool praime_numbers[100001];
static const int MOD = 1000000007;
const int int_inf = 2147483647;
const ll long_inf = 9223372036854775807ll;
#define rep(i, n) for (int i = 0; i < n; i++)
//#define rep(j,n) for(int j = 0;j<n;j++)
#define defvi(a, c) vector<int>(a, c)
#define defvvi(a, b, c) vector<vector<int>>(a, vector<int>(b, c))
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
void check_1D(vector<int> &ls);
void check_2D(vector<vector<int>> &ls);
int main() {
ios::sync_with_stdio(false);
//ここからコードを書く
int n, k, check = 1, count = 0, ans = 0, change, beforCheck = -1;
string s;
cin >> n >> k;
cin >> s;
if (s.back() == '0')
s += '1';
else
s += '0';
if (n == 1) {
cout << 1 << endl;
exit(0);
}
for (int i = 0; i < n; i++) {
if (s[i] == '0')
change = k * 2;
else
change = k * 2 + 1;
if (i != 0) {
if (s[i] != s[i - 1])
count--;
}
for (; check < n + 1; check++) {
if (s[check] != s[check - 1] && beforCheck != check)
count++;
if (count >= change || check >= n) {
ans = max(ans, check - i);
beforCheck = check;
// cout << check << ' ' << count << ' ' << change << endl;
break;
}
}
}
cout << ans << endl;
//ここまで
}
//デバック用関数
//一次元の配列を出力する関数
void check_1D(vector<int> &ls) {
int length = ls.size();
for (int i = 0; i < length; i++) {
cout << ls[i] << ' ';
}
cout << endl;
}
//二次元配列を出力する関数
void check_2D(vector<vector<int>> &ls) {
for (int i = 0; i < ls.size(); i++) {
for (int j = 0; j < ls[0].size(); j++) {
cout << ls[i][j] << ' ';
}
cout << endl;
}
}
| [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change"
] | 885,907 | 885,908 | u924406834 | cpp |
p03074 | #define REP(i, n) for (int i = 0; i < (int)(n); i++)
#include "bits/stdc++.h"
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K;
cin >> S;
// 左端が逆立ちか否かを表すフラグ変数
bool flag_le_hand = (S[0] == '1');
vector<int> hand(N, 0);
vector<int> stand(N, 0);
int h_idx = 0;
int s_idx = 0;
char p = S[0];
int num_sw = 0;
for (int i = 0; i < N; i++) {
if (p != S[i]) {
num_sw++;
}
if (S[i] == '1') {
h_idx = num_sw / 2;
hand[h_idx]++;
} else {
s_idx = num_sw / 2;
stand[s_idx]++;
}
p = S[i];
}
if (s_idx <= K - 1) {
cout << N;
} else {
int num_cont = 0;
int max_num_cont;
REP(i, K) { num_cont += hand[i] + stand[i]; }
if (flag_le_hand) {
num_cont += hand[K];
}
max_num_cont = num_cont;
REP(i, s_idx - K + 1) {
if (flag_le_hand) {
num_cont -= hand[i] + stand[i];
num_cont += hand[i + K + 1] + stand[i + K];
} else {
if (i == 0) {
num_cont -= stand[i];
} else {
num_cont -= hand[i - 1] + stand[i];
}
num_cont += hand[i + K] + stand[i + K];
}
}
if (max_num_cont < num_cont) {
max_num_cont = num_cont;
}
cout << max_num_cont << endl;
}
return 0;
} | #define REP(i, n) for (int i = 0; i < (int)(n); i++)
#include "bits/stdc++.h"
using namespace std;
int main() {
int N, K;
string S;
cin >> N >> K;
cin >> S;
bool flag_le_hand = (S[0] == '1');
vector<int> hand(N, 0);
vector<int> stand(N, 0);
int h_idx = 0;
int s_idx = 0;
char p = S[0];
int num_sw = 0;
for (int i = 0; i < N; i++) {
if (p != S[i]) {
num_sw++;
}
if (S[i] == '1') {
h_idx = num_sw / 2;
hand[h_idx]++;
} else {
s_idx = num_sw / 2;
stand[s_idx]++;
}
p = S[i];
}
if (s_idx <= K - 1) {
cout << N;
} else {
int num_cont = 0;
int max_num_cont;
REP(i, K) { num_cont += hand[i] + stand[i]; }
if (flag_le_hand) {
num_cont += hand[K];
}
max_num_cont = num_cont;
REP(i, s_idx - K + 1) {
if (flag_le_hand) {
num_cont -= hand[i] + stand[i];
num_cont += hand[i + K + 1] + stand[i + K];
} else {
if (i == 0) {
num_cont -= stand[0];
} else {
num_cont -= hand[i - 1] + stand[i];
}
num_cont += hand[i + K] + stand[i + K];
}
if (max_num_cont < num_cont) {
max_num_cont = num_cont;
}
}
cout << max_num_cont << endl;
}
return 0;
}
| [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change"
] | 885,913 | 885,914 | u518206537 | cpp |
p03074 | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> a;
int b = (s[0] == '0' ? 0 : 1);
a.push_back(1);
for (int i = 1; i < n; ++i) {
if (s[i] == s[i - 1]) {
++a.back();
} else {
a.push_back(1);
}
}
int m = a.size();
for (int i = 1; i < n; ++i)
a[i] += a[i - 1];
int ans = 0;
for (int i = 0; i < m; ++i) {
if (b == 0) {
ans = max(ans, a[min(m - 1, i + 2 * k - 1)] - ((i > 0) ? a[i - 1] : 0));
} else {
ans = max(ans, a[min(m - 1, i + 2 * k)] - ((i > 0) ? a[i - 1] : 0));
}
b = 1 - b;
}
cout << ans << endl;
} | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> a;
int b = (s[0] == '0' ? 0 : 1);
a.push_back(1);
for (int i = 1; i < n; ++i) {
if (s[i] == s[i - 1]) {
++a.back();
} else {
a.push_back(1);
}
}
int m = a.size();
for (int i = 1; i < m; ++i)
a[i] += a[i - 1];
int ans = 0;
for (int i = 0; i < m; ++i) {
if (b == 0) {
ans = max(ans, a[min(m - 1, i + 2 * k - 1)] - ((i > 0) ? a[i - 1] : 0));
} else {
ans = max(ans, a[min(m - 1, i + 2 * k)] - ((i > 0) ? a[i - 1] : 0));
}
b = 1 - b;
}
cout << ans << endl;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 885,933 | 885,934 | u986399983 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, count, p = 0;
string S;
vector<int> group(0);
string check = "10";
cin >> N >> K >> S;
int i = 0;
while (p < S.size()) {
count = 0;
while (p < S.size() && S.at(p) == check.at(i % 2)) {
p++;
count++;
}
group.push_back(count);
i++;
}
if (i % 2 == 0) {
group.push_back(0);
}
int sum = 0, mymax = 0;
if (2 * K + 1 >= group.size()) {
for (int &x : group) {
sum += x;
}
cout << sum << endl;
return 0;
}
for (int j = 1; j + 2 * K < group.size(); j += 2) {
sum = 0;
for (int k = 0; k < 2 * K + 1; k++) {
sum += group.at(j + k - 1);
}
if (sum > mymax) {
mymax = sum;
}
}
cout << mymax << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, count, p = 0;
string S;
vector<int> group(0);
string check = "10";
cin >> N >> K >> S;
int i = 0;
while (p < S.size()) {
count = 0;
while (p < S.size() && S.at(p) == check.at(i % 2)) {
p++;
count++;
}
group.push_back(count);
i++;
}
if (i % 2 == 0) {
group.push_back(0);
}
int sum = 0, mymax = 0;
if (2 * K + 1 >= group.size()) {
for (int &x : group) {
sum += x;
}
cout << sum << endl;
return 0;
}
for (int j = 1; j + 2 * K <= group.size(); j += 2) {
sum = 0;
for (int k = 0; k < 2 * K + 1; k++) {
sum += group.at(j + k - 1);
}
if (sum > mymax) {
mymax = sum;
}
}
cout << mymax << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 885,939 | 885,940 | u825376369 | cpp |
p03074 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define ll long long
#define rep2(i, a, b) for (ll i = a; i <= b; i++)
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep3(i, a, b) for (ll i = a; i >= b; i--)
#define REP(e, v) for (auto e : v)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define tii tuple<int, int, int>
#define pq priority_queue<int>
#define pqg priority_queue<int, vector<int>, greater<int>>
#define pb push_back
#define edge(v, a, b) \
v[a].pb(b); \
v[b].pb(a);
#define vec vector<int>
#define vecll vector<ll>
#define vecstr vector<string>
#define vecch vector<char>
#define vecpii vector<pii>
#define bs binary_search
#define All(c) (c).begin(), (c).end()
using namespace std;
int in() {
int x;
scanf("%d", &x);
return x;
}
string strin() {
string s;
cin >> s;
return s;
}
char chin() {
char c;
cin >> c;
return c;
}
ll lin() {
ll x;
scanf("%lld", &x);
return x;
}
int main() {
int n = in(), k = in();
string s = strin();
vec a(n), b(n + 2, 0);
rep(i, n) a[i] = s.at(i) == '0' ? 0 : 1;
int index = 0;
b[0] = s.at(0) == '1' ? 1 : -1;
rep2(i, 1, n - 1) {
if (a[i] == 1 && b[index] > 0)
b[index]++;
else if (a[i] == 0 && b[index] < 0)
b[index]--;
else if (a[i] == 1 && b[index] < 0)
b[++index] = 1;
else if (a[i] == 0 && b[index] > 0)
b[++index] = -1;
}
int cnt0 = 0;
rep(i, b.size()) {
if (b[i] < 0)
cnt0++;
}
if (k >= cnt0) {
cout << n << endl;
return 0;
}
ll ans = 0;
vecll c(n + 1);
c[0] = 0;
rep(i, n) { c[i + 1] = c[i] + abs(b[i]); }
int p = b[0] > 0 ? 2 : 1;
for (int i = p; i + 2 * k < n + 1; i += 2) {
ans = max(ans, c[i + 2 * k] - c[i - 1]);
}
ans = max(ans, c[2 * k]);
cout << ans << endl;
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define ll long long
#define rep2(i, a, b) for (ll i = a; i <= b; i++)
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep3(i, a, b) for (ll i = a; i >= b; i--)
#define REP(e, v) for (auto e : v)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define tii tuple<int, int, int>
#define pq priority_queue<int>
#define pqg priority_queue<int, vector<int>, greater<int>>
#define pb push_back
#define edge(v, a, b) \
v[a].pb(b); \
v[b].pb(a);
#define vec vector<int>
#define vecll vector<ll>
#define vecstr vector<string>
#define vecch vector<char>
#define vecpii vector<pii>
#define bs binary_search
#define All(c) (c).begin(), (c).end()
using namespace std;
int in() {
int x;
scanf("%d", &x);
return x;
}
string strin() {
string s;
cin >> s;
return s;
}
char chin() {
char c;
cin >> c;
return c;
}
ll lin() {
ll x;
scanf("%lld", &x);
return x;
}
int main() {
int n = in(), k = in();
string s = strin();
vec a(n), b(n + 2, 0);
rep(i, n) a[i] = s.at(i) == '0' ? 0 : 1;
int index = 0;
b[0] = s.at(0) == '1' ? 1 : -1;
rep2(i, 1, n - 1) {
if (a[i] == 1 && b[index] > 0)
b[index]++;
else if (a[i] == 0 && b[index] < 0)
b[index]--;
else if (a[i] == 1 && b[index] < 0)
b[++index] = 1;
else if (a[i] == 0 && b[index] > 0)
b[++index] = -1;
}
int cnt0 = 0;
rep(i, b.size()) {
if (b[i] < 0)
cnt0++;
}
if (k >= cnt0) {
cout << n << endl;
return 0;
}
ll ans = 0;
vecll c(n + 1);
c[0] = 0;
rep(i, n) { c[i + 1] = c[i] + abs(b[i]); }
int p = b[0] > 0 ? 1 : 2;
for (int i = p; i + 2 * k < n + 1; i += 2) {
ans = max(ans, c[i + 2 * k] - c[i - 1]);
}
ans = max(ans, c[2 * k]);
cout << ans << endl;
}
| [] | 885,952 | 885,953 | u434662823 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n);
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
vector<int> states;
//偶数番目(0,2,,)は直立、奇数番目(1,3,,)は逆立ち
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
bool is_stand = true;
int idx = 1;
states.push_back(0);
states.push_back(0);
REP(i, n) {
if (s[i] == '0') {
if (is_stand) {
states[idx]++;
} else {
states.push_back(1);
idx++;
is_stand = true;
}
} else {
if (is_stand) {
states.push_back(1);
idx++;
is_stand = false;
} else {
states[idx]++;
}
}
}
REP(i, k + 2) states.push_back(0);
vector<int> scc;
int fscc = 0;
REP(i, k * 2 + 1) { fscc += states[i]; }
scc.push_back(fscc);
int size = states.size();
idx = 0;
for (int i = k * 2 + 1; i < size; i += 2, idx++) {
scc.push_back(scc[idx] - states[i - k * 2 - 1] - states[i - k * 2 - 0] +
states[i] + states[i + 1]);
}
cout << *MAX_ELEMENT(scc) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
#define RFOR(i, a, b) for (int i = a - 1; i >= b; i--)
#define RREP(i, a) RFOR(i, a, 0)
#define REPALL(i, v) for (int i = 0; i < v.size(); i++)
#define RREPALL(i, v) for (int i = v.size() - 1; i >= 0; i--)
#define SORT(v) sort(v.begin(), v.end())
#define MIN_ELEMENT(v) min_element(v.begin(), v.end())
#define MAX_ELEMENT(v) max_element(v.begin(), v.end())
#define COUNT(v, n) count(v.begin(), v.end(), n);
void YES(bool flag) { cout << (flag ? "YES" : "NO") << endl; }
void Yes(bool flag) { cout << (flag ? "Yes" : "No") << endl; }
void yes(bool flag) { cout << (flag ? "yes" : "no") << endl; }
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1e7;
const ll MOD = 1e9 + 7;
vector<int> states;
//偶数番目(0,2,,)は直立、奇数番目(1,3,,)は逆立ち
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
bool is_stand = true;
int idx = 1;
states.push_back(0);
states.push_back(0);
REP(i, n) {
if (s[i] == '0') {
if (is_stand) {
states[idx]++;
} else {
states.push_back(1);
idx++;
is_stand = true;
}
} else {
if (is_stand) {
states.push_back(1);
idx++;
is_stand = false;
} else {
states[idx]++;
}
}
}
REP(i, k * 2 + 2) states.push_back(0);
vector<int> scc;
int fscc = 0;
REP(i, k * 2 + 1) { fscc += states[i]; }
scc.push_back(fscc);
int size = states.size();
idx = 0;
for (int i = k * 2 + 1; i < size; i += 2, idx++) {
scc.push_back(scc[idx] - states[i - k * 2 - 1] - states[i - k * 2 - 0] +
states[i] + states[i + 1]);
}
cout << *MAX_ELEMENT(scc) << endl;
return 0;
}
| [
"expression.operation.binary.add"
] | 885,958 | 885,955 | u007637377 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j;
string s;
cin >> n >> k >> s;
vector<int> man0(50010);
vector<int> man1(50010);
int a = 0;
int b = 0;
for (i = 0; i < n; i++) {
if (s.at(i) == '0') {
man0.at(a)++;
}
if (s.at(i) == '1') {
man1.at(b)++;
}
if (i >= 1) {
if (s.at(i - 1) == '0' && s.at(i) == '1') {
a++;
} else if (s.at(i - 1) == '1' && s.at(i) == '0') {
b++;
}
}
}
if (man0.at(a) != 0)
a++;
if (man1.at(b) != 0)
b++;
int maxi = 1;
int sum = 0;
for (i = 0; i < max(b - k + 1, 1); i++) {
for (j = i; j < min(i + k, 50005); j++) {
sum += man0.at(j) + man1.at(j);
}
if (i >= 1 && s.at(0) == '0') {
sum += man1.at(i - 1);
}
if (s.at(0) == '1') {
sum += man1.at(min(i + k, 50005));
}
if (sum > maxi) {
maxi = sum;
}
sum = 0;
}
if (k >= n) {
cout << n << endl;
} else {
cout << maxi << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j;
string s;
cin >> n >> k >> s;
vector<int> man0(50010);
vector<int> man1(50010);
int a = 0;
int b = 0;
for (i = 0; i < n; i++) {
if (s.at(i) == '0') {
man0.at(a)++;
}
if (s.at(i) == '1') {
man1.at(b)++;
}
if (i >= 1) {
if (s.at(i - 1) == '0' && s.at(i) == '1') {
a++;
} else if (s.at(i - 1) == '1' && s.at(i) == '0') {
b++;
}
}
}
if (man0.at(a) != 0)
a++;
if (man1.at(b) != 0)
b++;
int maxi = 1;
int sum = 0;
for (i = 0; i < max(a - k + 1, 1); i++) {
for (j = i; j < min(i + k, 50005); j++) {
sum += man0.at(j) + man1.at(j);
}
if (i >= 1 && s.at(0) == '0') {
sum += man1.at(i - 1);
}
if (s.at(0) == '1') {
sum += man1.at(min(i + k, 50005));
}
if (sum > maxi) {
maxi = sum;
}
sum = 0;
}
if (k >= n) {
cout << n << endl;
} else {
cout << maxi << endl;
}
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 885,966 | 885,967 | u989336028 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j;
string s;
cin >> n >> k >> s;
vector<int> man0(50010);
vector<int> man1(50010);
int a = 0;
int b = 0;
for (i = 0; i < n; i++) {
if (s.at(i) == '0') {
man0.at(a)++;
}
if (s.at(i) == '1') {
man1.at(b)++;
}
if (i >= 1) {
if (s.at(i - 1) == '0' && s.at(i) == '1') {
a++;
} else if (s.at(i - 1) == '1' && s.at(i) == '0') {
b++;
}
}
if (man0.at(a) != 0)
a++;
if (man1.at(b) != 0)
b++;
}
int maxi = 1;
int sum = 0;
for (i = 0; i < max(b - k + 1, 1); i++) {
for (j = i; j < min(i + k, 50005); j++) {
sum += man0.at(j) + man1.at(j);
}
if (i >= 1 && s.at(0) == '0') {
sum += man1.at(i - 1);
}
if (s.at(0) == '1') {
sum += man1.at(min(i + k, 50005));
}
if (sum > maxi) {
maxi = sum;
}
sum = 0;
}
if (k >= n) {
cout << n << endl;
} else {
cout << maxi << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j;
string s;
cin >> n >> k >> s;
vector<int> man0(50010);
vector<int> man1(50010);
int a = 0;
int b = 0;
for (i = 0; i < n; i++) {
if (s.at(i) == '0') {
man0.at(a)++;
}
if (s.at(i) == '1') {
man1.at(b)++;
}
if (i >= 1) {
if (s.at(i - 1) == '0' && s.at(i) == '1') {
a++;
} else if (s.at(i - 1) == '1' && s.at(i) == '0') {
b++;
}
}
}
if (man0.at(a) != 0)
a++;
if (man1.at(b) != 0)
b++;
int maxi = 1;
int sum = 0;
for (i = 0; i < max(a - k + 1, 1); i++) {
for (j = i; j < min(i + k, 50005); j++) {
sum += man0.at(j) + man1.at(j);
}
if (i >= 1 && s.at(0) == '0') {
sum += man1.at(i - 1);
}
if (s.at(0) == '1') {
sum += man1.at(min(i + k, 50005));
}
if (sum > maxi) {
maxi = sum;
}
sum = 0;
}
if (k >= n) {
cout << n << endl;
} else {
cout << maxi << endl;
}
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 885,968 | 885,967 | u989336028 | cpp |
p03074 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
typedef long long int ll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR_IN(i, a, b) for (int i = (a); i < (b); i++)
#define BETWEEN(x, a, b) ((x) >= (a) && (x) <= (b))
#define BIT(b, i) (((b) >> (i)) & 1)
#define LOG_F 1
#define LOG(...) \
if (LOG_F) \
fprintf(stderr, __VA_ARGS__)
using namespace std;
ll pow(int x, int n) { return n == 0 ? 1 : x * pow(x, n - 1); }
/*
*/
int n, k;
string s;
int main() {
cin >> n >> k;
cin >> s;
vector<int> a, b;
a.push_back(0);
b.push_back(0);
int cnt = 0;
for (size_t i = 0; i < n; i++) {
if (s[i] == '1') {
if (cnt == 0) {
a.push_back(i);
}
cnt++;
} else {
if (cnt > 0) {
b.push_back(i);
cnt = 0;
}
}
}
a.push_back(n);
b.push_back(n);
size_t m = min(a.size(), b.size());
/* for (size_t i = 0; i < m; i++)
{
cerr << "a[i] = "<< a[i] << ", b[i] = "<< b[i] << endl;
} */
int ans = 0;
for (int i = 0; i < m - k; i++) {
ans = max(ans, b[i + k] - a[i]);
}
if (m <= k) {
ans = n;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
typedef long long int ll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR_IN(i, a, b) for (int i = (a); i < (b); i++)
#define BETWEEN(x, a, b) ((x) >= (a) && (x) <= (b))
#define BIT(b, i) (((b) >> (i)) & 1)
#define LOG_F 1
#define LOG(...) \
if (LOG_F) \
fprintf(stderr, __VA_ARGS__)
using namespace std;
ll pow(int x, int n) { return n == 0 ? 1 : x * pow(x, n - 1); }
/*
*/
int n, k;
string s;
int main() {
cin >> n >> k;
cin >> s;
vector<int> a, b;
a.push_back(0);
b.push_back(0);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
if (cnt == 0) {
a.push_back(i);
}
cnt++;
} else {
if (cnt > 0) {
b.push_back(i);
cnt = 0;
}
}
}
a.push_back(n);
b.push_back(n);
int m = min(a.size(), b.size());
/* for (size_t i = 0; i < m; i++)
{
cerr << "a[i] = "<< a[i] << ", b[i] = "<< b[i] << endl;
} */
int ans = 0;
for (int i = 0; i < m - k; i++) {
ans = max(ans, b[i + k] - a[i]);
}
if (m <= k) {
ans = n;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.primitive.change"
] | 885,973 | 885,974 | u261243803 | cpp |
p03074 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
typedef long long int ll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR_IN(i, a, b) for (int i = (a); i < (b); i++)
#define BETWEEN(x, a, b) ((x) >= (a) && (x) <= (b))
#define BIT(b, i) (((b) >> (i)) & 1)
#define LOG_F 1
#define LOG(...) \
if (LOG_F) \
fprintf(stderr, __VA_ARGS__)
using namespace std;
ll pow(int x, int n) { return n == 0 ? 1 : x * pow(x, n - 1); }
/*
*/
int n, k;
string s;
int main() {
cin >> n >> k;
cin >> s;
vector<int> a, b;
a.push_back(0);
b.push_back(0);
int cnt = 0;
for (size_t i = 0; i < n; i++) {
if (s[i] == '1') {
if (cnt == 0) {
a.push_back(i);
}
cnt++;
} else {
if (cnt > 0) {
b.push_back(i);
cnt = 0;
}
}
}
a.push_back(n);
b.push_back(n);
int m = min(a.size(), b.size());
/* for (size_t i = 0; i < m; i++)
{
cerr << "a[i] = "<< a[i] << ", b[i] = "<< b[i] << endl;
} */
int ans = 0;
for (size_t i = 0; i < m - k; i++) {
ans = max(ans, b[i + k] - a[i]);
}
if (m <= k) {
ans = n;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
typedef long long int ll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR_IN(i, a, b) for (int i = (a); i < (b); i++)
#define BETWEEN(x, a, b) ((x) >= (a) && (x) <= (b))
#define BIT(b, i) (((b) >> (i)) & 1)
#define LOG_F 1
#define LOG(...) \
if (LOG_F) \
fprintf(stderr, __VA_ARGS__)
using namespace std;
ll pow(int x, int n) { return n == 0 ? 1 : x * pow(x, n - 1); }
/*
*/
int n, k;
string s;
int main() {
cin >> n >> k;
cin >> s;
vector<int> a, b;
a.push_back(0);
b.push_back(0);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
if (cnt == 0) {
a.push_back(i);
}
cnt++;
} else {
if (cnt > 0) {
b.push_back(i);
cnt = 0;
}
}
}
a.push_back(n);
b.push_back(n);
int m = min(a.size(), b.size());
/* for (size_t i = 0; i < m; i++)
{
cerr << "a[i] = "<< a[i] << ", b[i] = "<< b[i] << endl;
} */
int ans = 0;
for (int i = 0; i < m - k; i++) {
ans = max(ans, b[i + k] - a[i]);
}
if (m <= k) {
ans = n;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"variable_declaration.type.primitive.change"
] | 885,975 | 885,974 | u261243803 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
bool one_start = (S.at(0) == '1');
vector<int> arr(N + 2);
int idx = 0;
char pre = '1';
if (S.at(0) == '0') { // 0スタートだった
idx++;
arr.at(0) = 0; // 1が0個あることにする
pre = '0';
}
for (int i = 0; i < S.size(); i++) {
if (pre == S.at(i)) {
arr.at(idx)++;
} else {
idx++;
arr.at(idx)++;
}
pre = S.at(i);
}
int max_lensum = 0;
for (int i = 0; i < arr.size(); i = i + 2) {
int lensum = accumulate(arr.begin() + i, arr.begin() + i + 2 * K + 1, 0);
if (lensum > max_lensum)
max_lensum = lensum;
if (i != 0 && arr.at(i) == 0)
break;
}
cout << max_lensum << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
bool one_start = (S.at(0) == '1');
vector<int> arr(1000000);
int idx = 0;
char pre = '1';
if (S.at(0) == '0') { // 0スタートだった
idx++;
arr.at(0) = 0; // 1が0個あることにする
pre = '0';
}
for (int i = 0; i < S.size(); i++) {
if (pre == S.at(i)) {
arr.at(idx)++;
} else {
idx++;
arr.at(idx)++;
}
pre = S.at(i);
}
int max_lensum = 0;
for (int i = 0; i < arr.size(); i = i + 2) {
int lensum = accumulate(arr.begin() + i, arr.begin() + i + 2 * K + 1, 0);
if (lensum > max_lensum)
max_lensum = lensum;
if (i != 0 && arr.at(i) == 0)
break;
}
cout << max_lensum << endl;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 885,980 | 885,979 | u701743518 | cpp |
p03074 | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repf(i, m, n) for (int(i) = m; (i) < n; (i)++)
#define all(v) (v).begin(), (v).end()
#define ll long long
#define vec(name, num) vector<ll> name((num), 0);
#define op(i) cout << (i) << endl;
#define ip(i) cin >> (i);
#define opN cout << "No" << endl;
#define opY cout << "Yes" << endl;
#define opP cout << "Possible" << endl;
#define opI cout << "Impossible" << endl;
#define mat(name, fnum, snum) \
; \
vector<vector<ll>> name((fnum), vector<ll>((snum), 0));
#define debugP \
int debug_point; \
cin >> debug_point;
const ll MOD = 1e9 + 7;
template <typename T> void putv(vector<T> &V) {
// cout << "The elements in the vector are: " << endl;
for (auto x : V)
cout << x << " ";
cout << endl;
}
ll pown(ll fi, ll se) {
ll ans = 1;
rep(i, se) { ans *= fi; }
return ans;
}
template <class T> vector<T> getv(ll n) {
vector<T> Vector_temp;
rep(i, n) {
T input;
cin >> input;
Vector_temp.emplace_back(input);
}
return Vector_temp;
}
ll gcd(ll c, ll b) {
while (1) {
if (c % b != 0) {
ll tmp = b;
b = c % b;
c = tmp;
} else {
return b;
}
}
}
/* <3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3*/
int main() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
vec(a, 0);
vec(b, 0);
ll fst = 0;
ll flag;
if (s[0] == '0') {
fst = 0;
flag = 0;
b.push_back(0);
} else {
fst = 1;
flag = 1;
}
ll cnt = 0;
rep(i, s.size()) {
if (flag == 0) {
if (s[i] == '1') {
flag = 1;
a.push_back(cnt);
cnt = 1;
if (i == (s.size() - 1))
b.push_back(cnt);
} else {
cnt++;
if (i == (s.size() - 1))
a.push_back(cnt);
}
} else {
if (s[i] == '0') {
flag = 0;
b.push_back(cnt);
cnt = 1;
if (i == (s.size() - 1))
a.push_back(cnt);
} else {
cnt++;
if (i == (s.size() - 1))
b.push_back(cnt);
}
}
}
ll ansa = 0;
ll ansb = 0;
if (k >= a.size()) {
op(s.size());
return 0;
}
ll A = a.size();
ll B = b.size();
b.push_back(0);
b.push_back(0);
a.push_back(0);
a.push_back(0);
b.push_back(0);
b.push_back(0);
a.push_back(0);
a.push_back(0);
ll Ans = 0;
rep(i, k) {
Ans += a[i];
Ans += b[i];
}
Ans += b[k];
ll ANS = Ans;
for (int i = 0; i + k < A; i++) {
ll tmp = Ans - b[i] + b[i + k + 1] - a[i] + a[i + k];
Ans = tmp;
ANS = max(ANS, tmp);
}
op(Ans);
return 0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define repf(i, m, n) for (int(i) = m; (i) < n; (i)++)
#define all(v) (v).begin(), (v).end()
#define ll long long
#define vec(name, num) vector<ll> name((num), 0);
#define op(i) cout << (i) << endl;
#define ip(i) cin >> (i);
#define opN cout << "No" << endl;
#define opY cout << "Yes" << endl;
#define opP cout << "Possible" << endl;
#define opI cout << "Impossible" << endl;
#define mat(name, fnum, snum) \
; \
vector<vector<ll>> name((fnum), vector<ll>((snum), 0));
#define debugP \
int debug_point; \
cin >> debug_point;
const ll MOD = 1e9 + 7;
template <typename T> void putv(vector<T> &V) {
// cout << "The elements in the vector are: " << endl;
for (auto x : V)
cout << x << " ";
cout << endl;
}
ll pown(ll fi, ll se) {
ll ans = 1;
rep(i, se) { ans *= fi; }
return ans;
}
template <class T> vector<T> getv(ll n) {
vector<T> Vector_temp;
rep(i, n) {
T input;
cin >> input;
Vector_temp.emplace_back(input);
}
return Vector_temp;
}
ll gcd(ll c, ll b) {
while (1) {
if (c % b != 0) {
ll tmp = b;
b = c % b;
c = tmp;
} else {
return b;
}
}
}
/* <3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3<3*/
int main() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
vec(a, 0);
vec(b, 0);
ll fst = 0;
ll flag;
if (s[0] == '0') {
fst = 0;
flag = 0;
b.push_back(0);
} else {
fst = 1;
flag = 1;
}
ll cnt = 0;
rep(i, s.size()) {
if (flag == 0) {
if (s[i] == '1') {
flag = 1;
a.push_back(cnt);
cnt = 1;
if (i == (s.size() - 1))
b.push_back(cnt);
} else {
cnt++;
if (i == (s.size() - 1))
a.push_back(cnt);
}
} else {
if (s[i] == '0') {
flag = 0;
b.push_back(cnt);
cnt = 1;
if (i == (s.size() - 1))
a.push_back(cnt);
} else {
cnt++;
if (i == (s.size() - 1))
b.push_back(cnt);
}
}
}
ll ansa = 0;
ll ansb = 0;
if (k >= a.size()) {
op(s.size());
return 0;
}
ll A = a.size();
ll B = b.size();
b.push_back(0);
b.push_back(0);
a.push_back(0);
a.push_back(0);
b.push_back(0);
b.push_back(0);
a.push_back(0);
a.push_back(0);
ll Ans = 0;
rep(i, k) {
Ans += a[i];
Ans += b[i];
}
Ans += b[k];
ll ANS = Ans;
for (int i = 0; i + k < A; i++) {
ll tmp = Ans - b[i] + b[i + k + 1] - a[i] + a[i + k];
Ans = tmp;
ANS = max(ANS, tmp);
}
op(ANS);
return 0;
} | [
"identifier.change",
"call.arguments.change"
] | 885,986 | 885,987 | u190234543 | cpp |
p03074 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef vector<pair<ll, ll>> Q;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int maxi(int a, int b) {
if (a > b)
return a;
else
return b;
}
int main() {
int n, k, ans;
cin >> n >> k;
string s;
cin >> s;
//ある範囲をk回1に変える
// 0が終わるとこをinsertする
vector<int> end, start;
rep(i, n) {
if (i < n - 1) {
if (s.at(i) == '0' && s.at(i + 1) == '1')
end.push_back(i + 1);
} else {
if (s.at(i) == '0')
end.push_back(i + 1);
}
}
rep(i, n) {
if (i > 0) {
if (s.at(i) == '0' && s.at(i - 1) == '1')
start.push_back(i + 1);
} else {
if (s.at(i) == '0')
start.push_back(i + 1);
}
}
if (end.size() <= k)
ans = n;
else if (end.size() - 1 > k) {
ans = start[k] - 1;
for (int i = 1; i <= start.size() - k - 1; i++) {
ans = maxi(ans, start[i + k] - 1 - (end[i - 1] + 1));
}
ans = maxi(ans, n - (end[end.size() - 1 - k]));
} else {
ans = maxi(n - end.at(0), start.at(end.size() - 1) - 1);
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef vector<pair<ll, ll>> Q;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int maxi(int a, int b) {
if (a > b)
return a;
else
return b;
}
int main() {
int n, k, ans;
cin >> n >> k;
string s;
cin >> s;
//ある範囲をk回1に変える
// 0が終わるとこをinsertする
vector<int> end, start;
rep(i, n) {
if (i < n - 1) {
if (s.at(i) == '0' && s.at(i + 1) == '1')
end.push_back(i + 1);
} else {
if (s.at(i) == '0')
end.push_back(i + 1);
}
}
rep(i, n) {
if (i > 0) {
if (s.at(i) == '0' && s.at(i - 1) == '1')
start.push_back(i + 1);
} else {
if (s.at(i) == '0')
start.push_back(i + 1);
}
}
if (end.size() <= k)
ans = n;
else if (end.size() - 1 >= k) {
ans = start[k] - 1;
for (int i = 1; i <= start.size() - k - 1; i++) {
ans = maxi(ans, start[i + k] - 1 - (end[i - 1]));
}
ans = maxi(ans, n - (end[end.size() - 1 - k]));
} else {
ans = maxi(n - end.at(0), start.at(end.size() - 1) - 1);
}
cout << ans << endl;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"expression.operation.binary.remove"
] | 885,993 | 885,994 | u620242073 | cpp |
p03074 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef vector<pair<ll, ll>> Q;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int maxi(int a, int b) {
if (a > b)
return a;
else
return b;
}
int main() {
int n, k, ans;
cin >> n >> k;
string s;
cin >> s;
//ある範囲をk回1に変える
// 0が終わるとこをinsertする
vector<int> end, start;
rep(i, n) {
if (i < n - 1) {
if (s.at(i) == '0' && s.at(i + 1) == '1')
end.push_back(i + 1);
} else {
if (s.at(i) == '0')
end.push_back(i + 1);
}
}
rep(i, n) {
if (i > 0) {
if (s.at(i) == '0' && s.at(i - 1) == '1')
start.push_back(i + 1);
} else {
if (s.at(i) == '0')
start.push_back(i + 1);
}
}
if (end.size() <= k)
ans = n;
else if (end.size() - 1 >= k) {
ans = start[k] - 1;
for (int i = 1; i <= start.size() - k - 1; i++) {
ans = maxi(ans, start[i + k] - 1 - (end[i - 1] + 1));
}
ans = maxi(ans, n - (end[end.size() - 1 - k]));
} else {
ans = maxi(n - end.at(0), start.at(end.size() - 1) - 1);
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef vector<pair<ll, ll>> Q;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int maxi(int a, int b) {
if (a > b)
return a;
else
return b;
}
int main() {
int n, k, ans;
cin >> n >> k;
string s;
cin >> s;
//ある範囲をk回1に変える
// 0が終わるとこをinsertする
vector<int> end, start;
rep(i, n) {
if (i < n - 1) {
if (s.at(i) == '0' && s.at(i + 1) == '1')
end.push_back(i + 1);
} else {
if (s.at(i) == '0')
end.push_back(i + 1);
}
}
rep(i, n) {
if (i > 0) {
if (s.at(i) == '0' && s.at(i - 1) == '1')
start.push_back(i + 1);
} else {
if (s.at(i) == '0')
start.push_back(i + 1);
}
}
if (end.size() <= k)
ans = n;
else if (end.size() - 1 >= k) {
ans = start[k] - 1;
for (int i = 1; i <= start.size() - k - 1; i++) {
ans = maxi(ans, start[i + k] - 1 - (end[i - 1]));
}
ans = maxi(ans, n - (end[end.size() - 1 - k]));
} else {
ans = maxi(n - end.at(0), start.at(end.size() - 1) - 1);
}
cout << ans << endl;
} | [
"expression.operation.binary.remove"
] | 885,995 | 885,994 | u620242073 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
#define forN(n, N) for (int n = 0; n < N; n++)
#define res_out(ans) cout << ans << "\n";
#define ll long long
int zero[int(1e6)], one[int(1e6)];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string S;
int N, K, i = 0;
cin >> N >> K >> S;
forN(n, N) {
if (S[n] == '0') {
zero[i]++;
if (n + 1 < N && S[n + 1] == '1')
i++;
} else
one[i]++;
}
int num, ans = 0;
forN(n, i) {
num = 0;
for (int m = 0; m < K && m + n <= i; m++) {
num += zero[n + m] + one[n + m];
}
if (n + K <= i)
num += one[n + K];
if (ans < num)
ans = num;
}
res_out(ans) return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define forN(n, N) for (int n = 0; n < N; n++)
#define res_out(ans) cout << ans << "\n";
#define ll long long
int zero[int(1e6)], one[int(1e6)];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string S;
int N, K, i = 0;
cin >> N >> K >> S;
forN(n, N) {
if (S[n] == '0') {
zero[i]++;
if (n + 1 < N && S[n + 1] == '1')
i++;
} else
one[i]++;
}
int num, ans = 0;
forN(n, i + 1) {
num = 0;
for (int m = 0; m < K && m + n <= i; m++) {
num += zero[n + m] + one[n + m];
}
if (n + K <= i)
num += one[n + K];
if (ans < num)
ans = num;
}
res_out(ans) return 0;
} | [
"expression.operation.binary.add"
] | 885,998 | 885,999 | u382251756 | cpp |
p03074 | #include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> stand;
vector<int> reverse;
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
count++;
} else {
if (count) {
stand.push_back(count);
count = 0;
}
}
}
if (count) {
stand.push_back(count);
}
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count++;
} else {
if (count) {
reverse.push_back(count);
count = 0;
}
}
}
if (count) {
reverse.push_back(count);
}
vector<int> stand_cum(stand.size() + 1);
stand_cum[0] = 0;
for (int i = 0; i < stand.size(); i++) {
stand_cum[i + 1] = stand_cum[i] + stand[i];
}
vector<int> reverse_cum(reverse.size() + 1);
reverse_cum[0] = 0;
for (int i = 0; i < reverse.size(); i++) {
reverse_cum[i + 1] = reverse_cum[i] + reverse[i];
}
int ans = 0;
if (stand.size() <= k) {
ans = n;
} else {
reverse_cum.push_back(reverse_cum[reverse_cum.size() - 1]);
for (int i = 0; i < stand.size() - k + 1; i++) {
if (s[0] == '1') {
ans = max(ans, stand_cum[i + k] - stand_cum[i] +
reverse_cum[i + k + 1] - reverse_cum[i]);
} else {
if (i == 0) {
ans = max(ans, stand_cum[i + k] - stand_cum[i] + reverse_cum[i + k] -
reverse_cum[i]);
} else {
ans = max(ans, stand_cum[i + k] - stand_cum[i] + reverse_cum[i + k] -
reverse_cum[i - 1]);
}
}
}
}
cout << ans << endl;
} | #include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> stand;
vector<int> reverse;
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
count++;
} else {
if (count) {
stand.push_back(count);
count = 0;
}
}
}
if (count) {
stand.push_back(count);
}
count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
count++;
} else {
if (count) {
reverse.push_back(count);
count = 0;
}
}
}
if (count) {
reverse.push_back(count);
}
vector<int> stand_cum(stand.size() + 1);
stand_cum[0] = 0;
for (int i = 0; i < stand.size(); i++) {
stand_cum[i + 1] = stand_cum[i] + stand[i];
}
vector<int> reverse_cum(reverse.size() + 1);
reverse_cum[0] = 0;
for (int i = 0; i < reverse.size(); i++) {
reverse_cum[i + 1] = reverse_cum[i] + reverse[i];
}
int ans = 0;
if (stand.size() <= k) {
ans = n;
} else {
reverse_cum.push_back(reverse_cum[reverse_cum.size() - 1]);
for (int i = 0; i < stand.size() - k + 1; i++) {
if (s[0] == '1') {
ans = max(ans, stand_cum[i + k] - stand_cum[i] +
reverse_cum[i + k + 1] - reverse_cum[i]);
} else {
if (i == 0) {
ans = max(ans, stand_cum[i + k] - stand_cum[i] + reverse_cum[i + k] -
reverse_cum[i]);
} else {
ans = max(ans, stand_cum[i + k] - stand_cum[i] + reverse_cum[i + k] -
reverse_cum[i - 1]);
}
}
}
}
cout << ans << endl;
} | [
"assignment.add"
] | 886,006 | 886,007 | u270681687 | cpp |
p03074 | //
// Created by 江口慎悟 on 2019-04-13.
//
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
void a() {
int A, B;
cin >> A >> B;
int ans = 0;
if (A > B) {
ans += A;
A--;
} else {
ans += B;
B--;
}
if (A > B) {
ans += A;
A--;
} else {
ans += B;
B--;
}
cout << ans;
}
void b() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H[i];
}
int c = 0;
int max_h = 0;
for (int i = 0; i < N; i++) {
if (max_h <= H[i]) {
c++;
max_h = H[i];
}
}
cout << c;
}
void c() {
string S;
cin >> S;
int N = S.size();
int stBlack = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0 && S[i] == '1')
stBlack++;
if (i % 2 == 1 && S[i] == '0')
stBlack++;
}
int stWhite = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0 && S[i] == '0')
stWhite++;
if (i % 2 == 1 && S[i] == '1')
stWhite++;
}
cout << min(stBlack, stWhite);
}
void d() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> st, ed;
if (S[0] == '1') {
st.push_back(0);
}
for (int i = 1; i < N; i++) {
if (S[i - 1] == '0' && S[i] == '1') {
st.push_back(i);
}
}
for (int i = 0; i < N - 1; i++) {
if (S[i] == '1' && S[i + 1] == '0') {
ed.push_back(i);
}
}
ed.push_back(N - 1); //必ず
int edMaxIdx = ed.size() - 1;
int maxOne = 0;
if (S[0] == '0') {
maxOne = ed[min(edMaxIdx, 0 + K)] + 1;
}
for (int stIdx = 0; stIdx < st.size(); stIdx++) {
int len = ed[min(edMaxIdx, stIdx + K)] - st[stIdx] + 1;
maxOne = max(maxOne, len);
}
cout << maxOne;
}
int main() {
d();
return 0;
}
| //
// Created by 江口慎悟 on 2019-04-13.
//
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
void a() {
int A, B;
cin >> A >> B;
int ans = 0;
if (A > B) {
ans += A;
A--;
} else {
ans += B;
B--;
}
if (A > B) {
ans += A;
A--;
} else {
ans += B;
B--;
}
cout << ans;
}
void b() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H[i];
}
int c = 0;
int max_h = 0;
for (int i = 0; i < N; i++) {
if (max_h <= H[i]) {
c++;
max_h = H[i];
}
}
cout << c;
}
void c() {
string S;
cin >> S;
int N = S.size();
int stBlack = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0 && S[i] == '1')
stBlack++;
if (i % 2 == 1 && S[i] == '0')
stBlack++;
}
int stWhite = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0 && S[i] == '0')
stWhite++;
if (i % 2 == 1 && S[i] == '1')
stWhite++;
}
cout << min(stBlack, stWhite);
}
void d() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> st, ed;
if (S[0] == '1') {
st.push_back(0);
}
for (int i = 1; i < N; i++) {
if (S[i - 1] == '0' && S[i] == '1') {
st.push_back(i);
}
}
for (int i = 0; i < N - 1; i++) {
if (S[i] == '1' && S[i + 1] == '0') {
ed.push_back(i);
}
}
ed.push_back(N - 1); //必ず
int edMaxIdx = ed.size() - 1;
int maxOne = 0;
if (S[0] == '0') {
maxOne = ed[min(edMaxIdx, K - 1)] + 1;
}
for (int stIdx = 0; stIdx < st.size(); stIdx++) {
int len = ed[min(edMaxIdx, stIdx + K)] - st[stIdx] + 1;
maxOne = max(maxOne, len);
}
cout << maxOne;
}
int main() {
d();
return 0;
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 886,013 | 886,014 | u040092786 | cpp |
p03074 |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
void a() {
int A, B;
cin >> A >> B;
int ans = 0;
if (A > B) {
ans += A;
A--;
} else {
ans += B;
B--;
}
if (A > B) {
ans += A;
A--;
} else {
ans += B;
B--;
}
cout << ans;
}
void b() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H[i];
}
int c = 0;
int max_h = 0;
for (int i = 0; i < N; i++) {
if (max_h <= H[i]) {
c++;
max_h = H[i];
}
}
cout << c;
}
void c() {
string S;
cin >> S;
int N = S.size();
int stBlack = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0 && S[i] == '1')
stBlack++;
if (i % 2 == 1 && S[i] == '0')
stBlack++;
}
int stWhite = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0 && S[i] == '0')
stWhite++;
if (i % 2 == 1 && S[i] == '1')
stWhite++;
}
cout << min(stBlack, stWhite);
}
void d() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> st, ed;
if (S[0] == '1') {
st.push_back(0);
}
for (int i = 1; i < N; i++) {
if (S[i - 1] == '0' && S[i] == '1') {
st.push_back(i);
}
}
for (int i = 0; i < N - 1; i++) {
if (S[i] == '1' && S[i + 1] == '0') {
ed.push_back(i);
}
}
ed.push_back(N - 1); //必ず
int edMaxIdx = ed.size() - 1;
int maxOne = 0;
if (S[0] == '0') {
maxOne = ed[min(edMaxIdx, 0 + K)];
}
for (int stIdx = 0; stIdx < st.size(); stIdx++) {
int len = ed[min(edMaxIdx, stIdx + K)] - st[stIdx] + 1;
maxOne = max(maxOne, len);
}
cout << maxOne;
}
int main() {
d();
return 0;
}
| //
// Created by 江口慎悟 on 2019-04-13.
//
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
void a() {
int A, B;
cin >> A >> B;
int ans = 0;
if (A > B) {
ans += A;
A--;
} else {
ans += B;
B--;
}
if (A > B) {
ans += A;
A--;
} else {
ans += B;
B--;
}
cout << ans;
}
void b() {
int N;
cin >> N;
vector<int> H(N);
for (int i = 0; i < N; i++) {
cin >> H[i];
}
int c = 0;
int max_h = 0;
for (int i = 0; i < N; i++) {
if (max_h <= H[i]) {
c++;
max_h = H[i];
}
}
cout << c;
}
void c() {
string S;
cin >> S;
int N = S.size();
int stBlack = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0 && S[i] == '1')
stBlack++;
if (i % 2 == 1 && S[i] == '0')
stBlack++;
}
int stWhite = 0;
for (int i = 0; i < N; i++) {
if (i % 2 == 0 && S[i] == '0')
stWhite++;
if (i % 2 == 1 && S[i] == '1')
stWhite++;
}
cout << min(stBlack, stWhite);
}
void d() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> st, ed;
if (S[0] == '1') {
st.push_back(0);
}
for (int i = 1; i < N; i++) {
if (S[i - 1] == '0' && S[i] == '1') {
st.push_back(i);
}
}
for (int i = 0; i < N - 1; i++) {
if (S[i] == '1' && S[i + 1] == '0') {
ed.push_back(i);
}
}
ed.push_back(N - 1); //必ず
int edMaxIdx = ed.size() - 1;
int maxOne = 0;
if (S[0] == '0') {
maxOne = ed[min(edMaxIdx, K - 1)] + 1;
}
for (int stIdx = 0; stIdx < st.size(); stIdx++) {
int len = ed[min(edMaxIdx, stIdx + K)] - st[stIdx] + 1;
maxOne = max(maxOne, len);
}
cout << maxOne;
}
int main() {
d();
return 0;
}
| [
"expression.operation.binary.remove",
"assignment.change"
] | 886,015 | 886,014 | u040092786 | cpp |
p03074 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
int main() {
int N, K;
string S;
vector<int> v;
cin >> N >> K >> S;
char now = '1';
int cnt = 0;
for (int i = 0; i < N; i++) {
if (now == S[i]) {
cnt++;
} else {
v.push_back(cnt);
cnt = 1;
now = S[i];
}
}
if (cnt != 0)
v.push_back(cnt);
if (now == '0')
v.push_back(0);
int ans = 0;
if (2 * K + 1 >= v.size()) {
ans = N;
} else {
vector<int> sum(v.size());
sum[0] = v[0];
for (int i = 1; i < v.size(); i++) {
sum[i] = sum[i - 1] + v[i];
}
for (int i = 0; 2 * K - i + 1 < v.size(); i += 2) {
if (i == 0) {
ans = max(ans, sum[2 * K + i]);
} else {
ans = max(ans, sum[2 * K + i] - sum[i - 1]);
}
}
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
int main() {
int N, K;
string S;
vector<int> v;
cin >> N >> K >> S;
char now = '1';
int cnt = 0;
for (int i = 0; i < N; i++) {
if (now == S[i]) {
cnt++;
} else {
v.push_back(cnt);
cnt = 1;
now = S[i];
}
}
if (cnt != 0)
v.push_back(cnt);
if (now == '0')
v.push_back(0);
int ans = 0;
if (2 * K + 1 >= v.size()) {
ans = N;
} else {
vector<int> sum(v.size());
sum[0] = v[0];
for (int i = 1; i < v.size(); i++) {
sum[i] = sum[i - 1] + v[i];
}
for (int i = 0; 2 * K + i < v.size(); i += 2) {
if (i == 0) {
ans = max(ans, sum[2 * K + i]);
} else {
ans = max(ans, sum[2 * K + i] - sum[i - 1]);
}
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.branch.if.condition.change"
] | 886,028 | 886,029 | u394033362 | cpp |
p03074 | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
int main() {
int N, K;
string S;
vector<int> v;
cin >> N >> K >> S;
char now = '1';
int cnt = 0;
for (int i = 0; i < N; i++) {
if (now == S[i]) {
cnt++;
} else {
v.push_back(cnt);
cnt = 1;
now = S[i];
}
}
if (cnt != 0)
v.push_back(cnt);
if (now == '0')
v.push_back(0);
int ans = 0;
if (2 * K + 1 >= v.size()) {
ans = N;
} else {
vector<int> sum(v.size());
sum[0] = v[0];
for (int i = 1; i < v.size(); i++) {
sum[i] = sum[i - 1] + v[i];
}
for (int i = 0; 2 * K - i + 1 <= v.size(); i += 2) {
if (i == 0) {
ans = max(ans, sum[2 * K + i]);
} else {
ans = max(ans, sum[2 * K + i] - sum[i - 1]);
}
}
}
cout << ans << endl;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
int main() {
int N, K;
string S;
vector<int> v;
cin >> N >> K >> S;
char now = '1';
int cnt = 0;
for (int i = 0; i < N; i++) {
if (now == S[i]) {
cnt++;
} else {
v.push_back(cnt);
cnt = 1;
now = S[i];
}
}
if (cnt != 0)
v.push_back(cnt);
if (now == '0')
v.push_back(0);
int ans = 0;
if (2 * K + 1 >= v.size()) {
ans = N;
} else {
vector<int> sum(v.size());
sum[0] = v[0];
for (int i = 1; i < v.size(); i++) {
sum[i] = sum[i - 1] + v[i];
}
for (int i = 0; 2 * K + i < v.size(); i += 2) {
if (i == 0) {
ans = max(ans, sum[2 * K + i]);
} else {
ans = max(ans, sum[2 * K + i] - sum[i - 1]);
}
}
}
cout << ans << endl;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 886,030 | 886,029 | u394033362 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define pb push_back
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (n); ++i)
const int mod = 1000000007;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
string s;
cin >> s;
int cnt = 0;
vector<int> a;
vector<int> c;
rep(i, n) {
if (s.at(i) == '0')
cnt++;
else {
if (cnt)
a.pb(cnt);
cnt = 0;
}
}
if (cnt)
a.pb(cnt);
cnt = 0;
rep(i, n) {
if (s.at(i) == '1')
cnt++;
else {
if (cnt)
c.pb(cnt);
cnt = 0;
}
}
if (cnt)
c.pb(cnt);
vector<int> b(a.size() + 1);
vector<int> d(c.size() + 1);
rep(i, a.size()) b.at(i + 1) += a.at(i) + b.at(i);
rep(i, c.size()) d.at(i + 1) += c.at(i) + d.at(i);
if (a.size() <= k) {
cout << n << endl;
} else {
if (a.size() == c.size()) {
if (s.at(0) == '0') {
int ans = 0;
for (int i = k; i < b.size(); ++i) {
if (i == k)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k));
else if (i == b.size() - 1)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k - 1));
else
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k - 1));
}
cout << ans << endl;
} else {
int ans = 0;
for (int i = k; i < b.size(); ++i) {
if (i == k)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i + 1) - d.at(i - k));
else if (i == b.size() - 1)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k));
else
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i + 1) - d.at(i - k));
}
cout << ans << endl;
}
} else if (a.size() > c.size()) {
int ans = 0;
for (int i = k; i < b.size(); ++i) {
if (i == k)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k));
else if (i == b.size() - 1)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i - 1) - d.at(i - k - 1));
else
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k));
}
cout << ans << endl;
} else {
int ans = 0;
for (int i = k; i < b.size(); ++i) {
if (i == k)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i + 1) - d.at(i - k));
else if (i == b.size() - 1)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i + 1) - d.at(i - k));
else
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i + 1) - d.at(i - k));
}
cout << ans << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define pb push_back
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (n); ++i)
const int mod = 1000000007;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
string s;
cin >> s;
int cnt = 0;
vector<int> a;
vector<int> c;
rep(i, n) {
if (s.at(i) == '0')
cnt++;
else {
if (cnt)
a.pb(cnt);
cnt = 0;
}
}
if (cnt)
a.pb(cnt);
cnt = 0;
rep(i, n) {
if (s.at(i) == '1')
cnt++;
else {
if (cnt)
c.pb(cnt);
cnt = 0;
}
}
if (cnt)
c.pb(cnt);
vector<int> b(a.size() + 1);
vector<int> d(c.size() + 1);
rep(i, a.size()) b.at(i + 1) += a.at(i) + b.at(i);
rep(i, c.size()) d.at(i + 1) += c.at(i) + d.at(i);
if (a.size() <= k) {
cout << n << endl;
} else {
if (a.size() == c.size()) {
if (s.at(0) == '0') {
int ans = 0;
for (int i = k; i < b.size(); ++i) {
if (i == k)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k));
else if (i == b.size() - 1)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k - 1));
else
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k - 1));
}
cout << ans << endl;
} else {
int ans = 0;
for (int i = k; i < b.size(); ++i) {
if (i == k)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i + 1) - d.at(i - k));
else if (i == b.size() - 1)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k));
else
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i + 1) - d.at(i - k));
}
cout << ans << endl;
}
} else if (a.size() > c.size()) {
int ans = 0;
for (int i = k; i < b.size(); ++i) {
if (i == k)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k));
else if (i == b.size() - 1)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i - 1) - d.at(i - k - 1));
else
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i) - d.at(i - k - 1));
}
cout << ans << endl;
} else {
int ans = 0;
for (int i = k; i < b.size(); ++i) {
if (i == k)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i + 1) - d.at(i - k));
else if (i == b.size() - 1)
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i + 1) - d.at(i - k));
else
ans = max(ans, b.at(i) - b.at(i - k) + d.at(i + 1) - d.at(i - k));
}
cout << ans << endl;
}
}
}
| [
"assignment.change"
] | 886,037 | 886,038 | u480831358 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
string s;
int main() {
int n, k;
cin >> n >> k;
cin >> s;
s = "@" + s;
int tmp = k;
int r = 1;
for (int i = 1; i <= n; i++) {
if (s[r] == '0' && s[r - 1] == '1') {
if (tmp) {
tmp--;
r++;
} else
break;
} else {
r++;
}
}
int ans = r - 1;
for (int i = 2; i <= n; i++) {
if (s[i] == '1' && s[i - 1] == '0') {
int tmp = 1;
while (r <= n) {
if (s[r] == '0' && s[r - 1] == '1') {
if (tmp) {
tmp--;
r++;
} else
break;
} else {
r++;
}
}
ans = max(ans, r - i);
}
}
cout << ans << '\n';
} | #include <bits/stdc++.h>
using namespace std;
string s;
int main() {
int n, k;
cin >> n >> k;
cin >> s;
s = "1" + s;
int tmp = k;
int r = 1;
for (int i = 1; i <= n; i++) {
if (s[r] == '0' && s[r - 1] == '1') {
if (tmp) {
tmp--;
r++;
} else
break;
} else {
r++;
}
}
int ans = r - 1;
for (int i = 2; i <= n; i++) {
if (s[i] == '1' && s[i - 1] == '0') {
int tmp = 1;
while (r <= n) {
if (s[r] == '0' && s[r - 1] == '1') {
if (tmp) {
tmp--;
r++;
} else
break;
} else {
r++;
}
}
ans = max(ans, r - i);
}
}
cout << ans << '\n';
} | [
"literal.string.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 886,049 | 886,050 | u358988638 | cpp |
p03074 | #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
// cout << fixed << setprecision(10);
string str;
long long int n, m, res[200001] = {}, x, h[30], w, cou = 0, Ma = 0, k,
memo[200000] = {};
cin >> n >> k >> str;
memo[0] = 1;
for (int i = 1; i < n; i++) {
if (str[i] != str[i - 1]) {
cou++;
}
memo[cou]++;
}
if (str[0] == '0') {
for (int i = 0; i < 2 * k; i++) {
res[0] += memo[i];
}
res[1] = res[0] - memo[0] + memo[2 * k] + memo[2 * k + 1];
int p = 1;
while (cou > 2 * (k + p) - 12) {
p++;
res[p] = res[p - 1] - memo[2 * p - 3] - memo[2 * p - 2] +
memo[2 * (k + p) - 3] + memo[2 * (k + p) - 2];
}
sort(res, res + p + 1);
cout << res[p];
} else {
for (int i = 0; i <= 2 * k; i++) {
res[0] += memo[i];
}
int p = 0;
while (cou > 2 * (k + p) - 12) {
p++;
res[p] = res[p - 1] - memo[2 * p - 2] - memo[2 * p - 1] +
memo[2 * (k + p) - 1] + memo[2 * (k + p)];
}
sort(res, res + p + 1);
cout << res[p];
}
}
| #include <algorithm>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int main() {
// cout << fixed << setprecision(10);
string str;
long long int n, m, res[300101] = {}, x, h[30], w, cou = 0, Ma = 0, k,
memo[300100] = {};
cin >> n >> k >> str;
memo[0] = 1;
for (int i = 1; i < n; i++) {
if (str[i] != str[i - 1]) {
cou++;
}
memo[cou]++;
}
if (str[0] == '0') {
for (int i = 0; i < 2 * k; i++) {
res[0] += memo[i];
}
res[1] = res[0] - memo[0] + memo[2 * k] + memo[2 * k + 1];
int p = 1;
while (cou > 2 * (k + p) - 12) {
p++;
res[p] = res[p - 1] - memo[2 * p - 3] - memo[2 * p - 2] +
memo[2 * (k + p) - 1] + memo[2 * (k + p) - 2];
}
sort(res, res + p + 1);
cout << res[p];
} else {
for (int i = 0; i <= 2 * k; i++) {
res[0] += memo[i];
}
int p = 0;
while (cou > 2 * (k + p) - 12) {
p++;
res[p] = res[p - 1] - memo[2 * p - 2] - memo[2 * p - 1] +
memo[2 * (k + p) - 1] + memo[2 * (k + p)];
}
sort(res, res + p + 1);
cout << res[p];
}
}
| [
"literal.number.change",
"variable_declaration.array_dimensions.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 886,053 | 886,054 | u018872912 | cpp |
p03074 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<long long, long long> LLP;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> reversed, stand;
int count = 0;
if (S[0] == '0')
reversed.push_back(0);
for (int i = 0; i < N; i++) {
if (i != 0) {
if (S[i - 1] != S[i]) {
if (S[i] == '0')
reversed.push_back(count);
else
stand.push_back(count);
count = 0;
}
}
count++;
}
if (S[N - 1] == '0') {
stand.push_back(count);
reversed.push_back(0);
} else
reversed.push_back(count);
int i = 0;
int now_count = reversed[0];
int maximum = now_count;
while (stand.size() >= ++i) {
now_count += (stand[i - 1] + reversed[i]);
if (i > K)
now_count -= (stand[i - K] + reversed[i - K - 1]);
maximum = max(maximum, now_count);
}
cout << maximum << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<long long, long long> LLP;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vector<int> reversed, stand;
int count = 0;
if (S[0] == '0')
reversed.push_back(0);
for (int i = 0; i < N; i++) {
if (i != 0) {
if (S[i - 1] != S[i]) {
if (S[i] == '0')
reversed.push_back(count);
else
stand.push_back(count);
count = 0;
}
}
count++;
}
if (S[N - 1] == '0') {
stand.push_back(count);
reversed.push_back(0);
} else
reversed.push_back(count);
int i = 0;
int now_count = reversed[0];
int maximum = now_count;
while (stand.size() >= ++i) {
now_count += (stand[i - 1] + reversed[i]);
if (i > K)
now_count -= (stand[i - K - 1] + reversed[i - K - 1]);
maximum = max(maximum, now_count);
}
cout << maximum << endl;
return 0;
} | [
"assignment.change"
] | 886,059 | 886,060 | u997325490 | cpp |
p03074 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define all(x) (x).begin(), x.end()
#define pb push_back
using namespace std;
using ll = long long;
const ll mod = 1000000007;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int ddx[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int ddy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
bool debug = false;
/*---------------------------------------------------*/
#define int long long
signed main() {
int N, K;
string S;
cin >> N >> K >> S;
vector<int> data;
int cnt = 0;
char n = S[0];
for (int i = 0; i < S.size(); i++) {
if (S[i] == n)
cnt++;
else {
if (n == '0')
data.push_back(-cnt);
else
data.push_back(cnt);
cnt = 1;
n = S[i];
}
}
if (n == '0')
data.push_back(-cnt);
else
data.push_back(cnt);
ll ans = 0, count = 0;
int right = 0;
for (int left = 0; left < data.size(); left++) {
while (right < data.size()) {
if (data[right] < 0) {
if (K == 0) {
break;
}
count += -(data[right]);
K--;
} else {
count += data[right];
}
right++;
}
ans = max(ans, count);
////cerr << left << " " << right << " = " << count << endl;
count -= abs(data[left]);
if (left != 0 && data[left] < 0)
K++;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define all(x) (x).begin(), x.end()
#define pb push_back
using namespace std;
using ll = long long;
const ll mod = 1000000007;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int ddx[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int ddy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
bool debug = false;
/*---------------------------------------------------*/
#define int long long
signed main() {
int N, K;
string S;
cin >> N >> K >> S;
vector<int> data;
int cnt = 0;
char n = S[0];
for (int i = 0; i < S.size(); i++) {
if (S[i] == n)
cnt++;
else {
if (n == '0')
data.push_back(-cnt);
else
data.push_back(cnt);
cnt = 1;
n = S[i];
}
}
if (n == '0')
data.push_back(-cnt);
else
data.push_back(cnt);
ll ans = 0, count = 0;
int right = 0;
for (int left = 0; left < data.size(); left++) {
while (right < data.size()) {
if (data[right] < 0) {
if (K == 0) {
break;
}
count += -(data[right]);
K--;
} else {
count += data[right];
}
right++;
}
ans = max(ans, count);
////cerr << left << " " << right << " = " << count << endl;
count -= abs(data[left]);
if (data[left] < 0)
K++;
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 886,061 | 886,062 | u587248350 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
struct Node {
int l, r;
} a[100005];
int n, m, k;
string s;
int main() {
m = 0;
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 0; i < n; ++i) {
if (s[i] == '0') {
a[m].l = i;
while (s[++i] == '0') {
}
i--;
a[m++].r = i;
}
}
a[m].l = n;
if (m <= k)
return 0 * printf("%d\n", n);
int ans = a[k].l - 1;
for (int i = 1; i + k - 1 < m; ++i) {
ans = max(ans, a[i + k].l - 1 - a[i - 1].r);
}
printf("%d\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
struct Node {
int l, r;
} a[100005];
int n, m, k;
string s;
int main() {
m = 0;
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 0; i < n; ++i) {
if (s[i] == '0') {
a[m].l = i;
while (s[++i] == '0') {
}
i--;
a[m++].r = i;
}
}
a[m].l = n;
if (m <= k)
return 0 * printf("%d\n", n);
int ans = a[k].l;
// cout << ans << endl;
for (int i = 1; i + k - 1 < m; ++i) {
// cout << a[i+k].l-1 << " " << a[i-1].r << endl;
// cout << a[i+k].l - 1 - a[i-1].r << endl;
ans = max(ans, a[i + k].l - 1 - a[i - 1].r);
}
printf("%d\n", ans);
return 0;
}
/*
19 3
0101010101001111001
*/
| [
"expression.operation.binary.remove"
] | 886,065 | 886,066 | u318486253 | cpp |
p03074 | #include <bits/stdc++.h>
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
#define ull unsigned long long
#define vi vector<ll>
#define vvi vector<vi>
#define DBG_N(hoge) cerr << " " << (hoge) << endl;
#define DBG cerr << "!" << endl;
#define BITLE(n) (1LL << ((ll)n))
#define BITCNT(n) (__builtin_popcountll(n))
#define SUBS(s, f, t) ((s).substr((f)-1, (t) - (f) + 1))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
ll rui[411111];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
string s;
cin >> s;
vi num;
vi num2;
for (int i = 0; i < s.size(); i++) {
ll cnt = 0;
while (i < s.size() && s[i] == '0') {
cnt++;
i++;
}
num.pb(cnt);
cnt = 0;
while (i < s.size() && s[i] == '1') {
cnt++;
i++;
}
i--;
num2.pb(cnt);
}
ll ans = 0;
for (int i = 0; i < num.size(); i++) {
rui[i * 2 + 1] += rui[i * 2] + num[i];
rui[i * 2 + 2] += rui[i * 2 + 1] + num2[i];
}
for (int i = num.size() * 2; i < 411111; i++)
rui[i] = rui[i - 1];
for (int i = 1; i < 111111; i++) {
if (i % 2 == 1)
ans = max(ans, rui[i + k * 2 - 1] - rui[i - 1]);
else
ans = max(ans, rui[i + k * 2] - rui[i - 1]);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define INF 1e9
#define llINF 1e18
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
#define ull unsigned long long
#define vi vector<ll>
#define vvi vector<vi>
#define DBG_N(hoge) cerr << " " << (hoge) << endl;
#define DBG cerr << "!" << endl;
#define BITLE(n) (1LL << ((ll)n))
#define BITCNT(n) (__builtin_popcountll(n))
#define SUBS(s, f, t) ((s).substr((f)-1, (t) - (f) + 1))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
ll rui[411111];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
string s;
cin >> s;
vi num;
vi num2;
for (int i = 0; i < s.size(); i++) {
ll cnt = 0;
while (i < s.size() && s[i] == '0') {
cnt++;
i++;
}
num.pb(cnt);
cnt = 0;
while (i < s.size() && s[i] == '1') {
cnt++;
i++;
}
i--;
num2.pb(cnt);
}
ll ans = 0;
for (int i = 0; i < num.size(); i++) {
rui[i * 2 + 1] += rui[i * 2] + num[i];
rui[i * 2 + 2] += rui[i * 2 + 1] + num2[i];
}
for (int i = num.size() * 2 + 1; i < 411111; i++)
rui[i] = rui[i - 1];
for (int i = 1; i < 111111; i++) {
if (i % 2 == 1)
ans = max(ans, rui[i + k * 2 - 1] - rui[i - 1]);
else
ans = max(ans, rui[i + k * 2] - rui[i - 1]);
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change"
] | 886,071 | 886,072 | u905715926 | cpp |
p03074 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
int main() {
ll n, k;
string s;
cin >> n >> k >> s;
vector<pair<ll, ll>> v;
bool f = s[0] == '1';
ll cnt = 0;
REP(i, s.size()) {
if (f) {
if (s[i] == '1') {
cnt++;
} else {
v.push_back({cnt, 1});
f = false;
cnt = 1;
}
} else {
if (s[i] == '0') {
cnt++;
} else {
v.push_back({cnt, 1});
f = true;
cnt = 1;
}
}
}
v.push_back({cnt, f ? 1 : 0});
if (s[0] == '1') {
if (k >= v.size() / 2) {
cout << n << endl;
return 0;
}
ll sum = 0;
REP(i, k * 2 + 1) { sum += v[i].first; }
ll ans = sum;
for (ll i = k * 2 + 2; i < v.size(); i += 2) {
sum += v[i].first + v[i - 1].first;
sum -= v[i - k * 2 - 2].first + v[i - k * 2 - 1].first;
ans = max(ans, sum);
}
if (v.size() % 2 == 0) {
ll l = v.size() - 1;
sum += v[l].first;
sum -= v[l - 2 * k - 1].first + v[l - 2 * k].first;
ans = max(ans, sum);
}
cout << ans << endl;
} else {
if (k >= (v.size() + 1) / 2) {
cout << n << endl;
return 0;
}
ll sum = 0;
REP(i, k * 2) { sum += v[i].first; }
ll ans = sum;
if (k * 2 + 1 < n) {
sum += v[k * 2].first + v[k * 2 + 1].first - v[0].first;
ans = max(ans, sum);
}
for (ll i = k * 2 + 3; i < v.size(); i += 2) {
sum += v[i].first + v[i - 1].first;
sum -= v[i - k * 2 - 2].first + v[i - k * 2 - 1].first;
ans = max(ans, sum);
}
if (v.size() % 2 == 1) {
ll l = v.size() - 1;
sum += v[l].first;
sum -= v[l - 2 * k].first;
ans = max(ans, sum);
}
cout << ans << endl;
}
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define REP(i, n) for (ll i = 0; i < n; i++)
int main() {
ll n, k;
string s;
cin >> n >> k >> s;
vector<pair<ll, ll>> v;
bool f = s[0] == '1';
ll cnt = 0;
REP(i, s.size()) {
if (f) {
if (s[i] == '1') {
cnt++;
} else {
v.push_back({cnt, 1});
f = false;
cnt = 1;
}
} else {
if (s[i] == '0') {
cnt++;
} else {
v.push_back({cnt, 1});
f = true;
cnt = 1;
}
}
}
v.push_back({cnt, f ? 1 : 0});
if (s[0] == '1') {
if (k >= v.size() / 2) {
cout << n << endl;
return 0;
}
ll sum = 0;
REP(i, k * 2 + 1) { sum += v[i].first; }
ll ans = sum;
for (ll i = k * 2 + 2; i < v.size(); i += 2) {
sum += v[i].first + v[i - 1].first;
sum -= v[i - k * 2 - 2].first + v[i - k * 2 - 1].first;
ans = max(ans, sum);
}
if (v.size() % 2 == 0) {
ll l = v.size() - 1;
sum += v[l].first;
sum -= v[l - 2 * k - 1].first + v[l - 2 * k].first;
ans = max(ans, sum);
}
cout << ans << endl;
} else {
if (k >= (v.size() + 1) / 2) {
cout << n << endl;
return 0;
}
ll sum = 0;
REP(i, k * 2) { sum += v[i].first; }
ll ans = sum;
if (k * 2 + 1 < v.size()) {
sum += v[k * 2].first + v[k * 2 + 1].first - v[0].first;
ans = max(ans, sum);
}
for (ll i = k * 2 + 3; i < v.size(); i += 2) {
sum += v[i].first + v[i - 1].first;
sum -= v[i - k * 2 - 2].first + v[i - k * 2 - 1].first;
ans = max(ans, sum);
}
if (v.size() % 2 == 1) {
ll l = v.size() - 1;
sum += v[l].first;
sum -= v[l - 2 * k].first;
ans = max(ans, sum);
}
cout << ans << endl;
}
} | [
"control_flow.branch.if.condition.change",
"call.add"
] | 886,073 | 886,074 | u711985352 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> v, w;
int now = 0;
char c = s[0];
for (int i = 0; i < s.size(); i++) {
if (s[i] == c) {
now++;
} else {
if (c == '0') {
v.push_back(now);
c = '1';
} else {
w.push_back(now);
c = '0';
}
now = 1;
}
}
if (c == '0') {
v.push_back(now);
c = '1';
} else {
w.push_back(now);
c = '0';
}
int sv[v.size() + 1], sw[w.size() + 1];
sv[0] = 0;
sw[0] = 0;
for (int i = 0; i < v.size(); i++) {
sv[i + 1] = sv[i] + v[i];
}
for (int i = 0; i < w.size(); i++) {
sw[i + 1] = sw[i] + w[i];
}
if (k >= v.size()) {
cout << n << endl;
return 0;
}
if (s[0] == '0') {
int ans = 0;
ans = sv[k] - sv[0] + sw[k] - sw[0];
for (int i = 1; i < v.size() - k - 1; i++) {
ans = max(ans, sv[i + k] - sv[i] + sw[i + k] - sw[i - 1]);
}
if (s[n - 1] == '0') {
ans = max(ans, sv[v.size()] - sv[v.size() - k] + sw[w.size()] -
sw[w.size() - k]);
} else {
ans = max(ans, sv[v.size()] - sv[v.size() - k] + sw[w.size()] -
sw[w.size() - k - 1]);
}
cout << ans << endl;
} else {
int ans = 0;
for (int i = 0; i < v.size() - k - 1; i++) {
ans = max(ans, sv[i + k] - sv[i] + sw[i + k + 1] - sw[i]);
}
if (s[n - 1] == '0') {
ans = max(ans, sv[v.size()] - sv[v.size() - k] + sw[w.size()] -
sw[w.size() - k]);
} else {
ans = max(ans, sv[v.size()] - sv[v.size() - k] + sw[w.size()] -
sw[w.size() - k - 1]);
}
cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> v, w;
int now = 0;
char c = s[0];
for (int i = 0; i < s.size(); i++) {
if (s[i] == c) {
now++;
} else {
if (c == '0') {
v.push_back(now);
c = '1';
} else {
w.push_back(now);
c = '0';
}
now = 1;
}
}
if (c == '0') {
v.push_back(now);
c = '1';
} else {
w.push_back(now);
c = '0';
}
int sv[v.size() + 1], sw[w.size() + 1];
sv[0] = 0;
sw[0] = 0;
for (int i = 0; i < v.size(); i++) {
sv[i + 1] = sv[i] + v[i];
}
for (int i = 0; i < w.size(); i++) {
sw[i + 1] = sw[i] + w[i];
}
if (k >= v.size()) {
cout << n << endl;
return 0;
}
if (s[0] == '0') {
int ans = 0;
ans = sv[k] - sv[0] + sw[k] - sw[0];
for (int i = 1; i < v.size() - k; i++) {
ans = max(ans, sv[i + k] - sv[i] + sw[i + k] - sw[i - 1]);
}
if (s[n - 1] == '0') {
ans = max(ans, sv[v.size()] - sv[v.size() - k] + sw[w.size()] -
sw[w.size() - k]);
} else {
ans = max(ans, sv[v.size()] - sv[v.size() - k] + sw[w.size()] -
sw[w.size() - k - 1]);
}
cout << ans << endl;
} else {
int ans = 0;
for (int i = 0; i < v.size() - k; i++) {
ans = max(ans, sv[i + k] - sv[i] + sw[i + k + 1] - sw[i]);
}
if (s[n - 1] == '0') {
ans = max(ans, sv[v.size()] - sv[v.size() - k] + sw[w.size()] -
sw[w.size() - k]);
} else {
ans = max(ans, sv[v.size()] - sv[v.size() - k] + sw[w.size()] -
sw[w.size() - k - 1]);
}
cout << ans << endl;
}
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 886,077 | 886,078 | u357265888 | cpp |
p03074 | #include <algorithm>
#include <array>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
int main() {
int N, K;
std::string S;
std::vector<int> back;
std::vector<int> stand;
std::cin >> N >> K;
std::cin >> S;
int head = 0;
while (head != S.size()) {
int i;
for (i = head; i < S.size(); ++i) {
if (S[i] != '1')
break;
}
back.push_back(i - head);
head = i;
if (head == S.size())
break;
for (; i < S.size(); ++i) {
if (S[i] != '0')
break;
}
stand.push_back(i - head);
head = i;
}
back.push_back(0);
if (stand.size() <= K) {
std::cout << N << "\n";
return 0;
}
int cur = back[0];
for (int i = 1; i < K + 1; ++i)
cur += stand[i - 1] + back[i];
int max = cur;
for (int i = K + 1; i < stand.size(); ++i) {
cur -= back[i - K] + stand[i - K];
cur += stand[i - 1] + back[i];
if (max < cur)
max = cur;
}
std::cout << max << "\n";
}
| #include <algorithm>
#include <array>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
int main() {
int N, K;
std::string S;
std::vector<int> back;
std::vector<int> stand;
std::cin >> N >> K;
std::cin >> S;
int head = 0;
while (head != S.size()) {
int i;
for (i = head; i < S.size(); ++i) {
if (S[i] != '1')
break;
}
back.push_back(i - head);
head = i;
if (head == S.size())
break;
for (; i < S.size(); ++i) {
if (S[i] != '0')
break;
}
stand.push_back(i - head);
head = i;
}
back.push_back(0);
if (stand.size() <= K) {
std::cout << N << "\n";
return 0;
}
int cur = back[0];
for (int i = 1; i < K + 1; ++i)
cur += stand[i - 1] + back[i];
int max = cur;
for (int i = K + 1; i < stand.size() + 1; ++i) {
cur -= back[i - K - 1] + stand[i - K - 1];
cur += stand[i - 1] + back[i];
if (max < cur)
max = cur;
}
std::cout << max << "\n";
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"assignment.change"
] | 886,086 | 886,087 | u504322356 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pp;
typedef long long ll;
#define sz(x) (int)x.size()
int const N = 3e5 + 10, oo = 1e9;
ll const OO = 2e18;
double const eps = 1e-8, PI = acos(-1);
int mod = oo + 7;
int n, k;
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
cin >> s;
vector<pp> zer;
for (int i = 0; i < n; i++) {
if (s[i] == '1')
continue;
int j = i;
while (j < n && s[j] == s[i])
j++;
zer.push_back({i, j - 1});
i = j - 1;
}
if (sz(zer) <= k) {
cout << n << '\n';
return 0;
}
int an = 0, i = 0;
while (i + k - 1 < sz(zer)) {
int c = 0;
if (i)
c += zer[i].first - zer[i - 1].second;
else
c += zer[i].first;
if (i + k == sz(zer))
c += n - zer[i].first - 1;
else
c += zer[i + k].first - zer[i].first;
an = max(an, c);
i++;
}
cout << an;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pp;
typedef long long ll;
#define sz(x) (int)x.size()
int const N = 3e5 + 10, oo = 1e9;
ll const OO = 2e18;
double const eps = 1e-8, PI = acos(-1);
int mod = oo + 7;
int n, k;
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
cin >> s;
vector<pp> zer;
for (int i = 0; i < n; i++) {
if (s[i] == '1')
continue;
int j = i;
while (j < n && s[j] == s[i])
j++;
zer.push_back({i, j - 1});
i = j - 1;
}
if (sz(zer) <= k) {
cout << n << '\n';
return 0;
}
int an = 0, i = 0;
while (i + k - 1 < sz(zer)) {
int c = 0;
if (i)
c += zer[i].first - zer[i - 1].second - 1;
else
c += zer[i].first;
if (i + k == sz(zer))
c += n - zer[i].first;
else
c += zer[i + k].first - zer[i].first;
an = max(an, c);
i++;
}
cout << an;
return 0;
}
| [
"assignment.change",
"expression.operation.binary.remove"
] | 886,088 | 886,089 | u151534880 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
using VS = vector<string>;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
using VL = vector<LL>;
using VVL = vector<VL>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)
#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)
//#pragma GCC optimize ("-O3")
#ifdef YANG33
#include "mydebug.hpp"
#else
#define DD(x)
#endif
const int INF = 1e9;
const LL LINF = 1e16;
const LL MOD = 1000000007;
const double PI = acos(-1.0);
/* ----- 2019/04/13 Problem: ABC 124 D / Link:
* http://abc124.contest.atcoder.jp/tasks/abc124_d ----- */
struct Cumusum {
vector<LL> csum;
Cumusum(vector<LL> &a) {
csum.assign((int)a.size() + 1, 0);
for (int i = 0; i < (int)a.size(); i++) {
csum[i + 1] = csum[i] + a[i];
}
}
Cumusum(vector<int> &a) {
csum.assign((int)a.size() + 1, 0);
for (int i = 0; i < (int)a.size(); i++) {
csum[i + 1] = csum[i] + a[i];
}
}
LL query(int l, int r) {
if (r >= SZ(csum))
r = SZ(csum);
return csum[r] - csum[l];
}
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
LL N, K;
cin >> N >> K;
string s;
cin >> s;
// to block
char pre = s.front();
VI ele;
ele.push_back(0);
ele.push_back(0);
VI is_a;
is_a.push_back(0);
is_a.push_back(pre == '0');
FOR(i, 0, N) {
if (pre == s[i]) {
ele.back()++;
} else {
ele.push_back(1);
is_a.push_back(s[i] == '0');
pre = s[i];
}
}
ele.push_back(0);
is_a.push_back(0);
N = SZ(ele);
Cumusum elesum(ele);
Cumusum isasum(is_a);
DD(De(ele));
DD(De(is_a));
LL ans = 0LL;
FOR(i, 0, N) {
if (is_a[i] == 0)
ans = max(ans, elesum.query(i, i + 2 * K + 1));
}
cout << (ans) << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using VS = vector<string>;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
using VL = vector<LL>;
using VVL = vector<VL>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)
#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)
//#pragma GCC optimize ("-O3")
#ifdef YANG33
#include "mydebug.hpp"
#else
#define DD(x)
#endif
const int INF = 1e9;
const LL LINF = 1e16;
const LL MOD = 1000000007;
const double PI = acos(-1.0);
/* ----- 2019/04/13 Problem: ABC 124 D / Link:
* http://abc124.contest.atcoder.jp/tasks/abc124_d ----- */
struct Cumusum {
vector<LL> csum;
Cumusum(vector<LL> &a) {
csum.assign((int)a.size() + 1, 0);
for (int i = 0; i < (int)a.size(); i++) {
csum[i + 1] = csum[i] + a[i];
}
}
Cumusum(vector<int> &a) {
csum.assign((int)a.size() + 1, 0);
for (int i = 0; i < (int)a.size(); i++) {
csum[i + 1] = csum[i] + a[i];
}
}
LL query(int l, int r) {
if (r >= SZ(csum))
r = SZ(csum) - 1;
return csum[r] - csum[l];
}
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
LL N, K;
cin >> N >> K;
string s;
cin >> s;
// to block
char pre = s.front();
VI ele;
ele.push_back(0);
ele.push_back(0);
VI is_a;
is_a.push_back(0);
is_a.push_back(pre == '0');
FOR(i, 0, N) {
if (pre == s[i]) {
ele.back()++;
} else {
ele.push_back(1);
is_a.push_back(s[i] == '0');
pre = s[i];
}
}
ele.push_back(0);
is_a.push_back(0);
N = SZ(ele);
Cumusum elesum(ele);
Cumusum isasum(is_a);
DD(De(ele));
DD(De(is_a));
LL ans = 0LL;
FOR(i, 0, N) {
if (is_a[i] == 0)
ans = max(ans, elesum.query(i, i + 2 * K + 1));
}
cout << (ans) << "\n";
return 0;
}
| [
"assignment.change"
] | 886,094 | 886,095 | u788341294 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incII(i, l, r) for (int i = (l); i <= (r); ++i)
#define incID(i, l, r) for (int i = (l); i < (r); ++i)
#define decII(i, l, r) for (int i = (r); i >= (l); --i)
#define decID(i, l, r) for (int i = (r)-1; i >= (l); --i)
#define inc(i, n) incID(i, 0, n)
#define inc1(i, n) incII(i, 1, n)
#define dec(i, n) decID(i, 0, n)
#define dec1(i, n) decII(i, 1, n)
#define inII(v, l, r) ((l) <= (v) && (v) <= (r))
#define inID(v, l, r) ((l) <= (v) && (v) < (r))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
template <typename T> bool setmin(T &a, T b) {
if (b < a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmax(T &a, T b) {
if (b > a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmineq(T &a, T b) {
if (b <= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmaxeq(T &a, T b) {
if (b >= a) {
a = b;
return true;
} else {
return false;
}
}
LL mo(LL a, LL b) {
assert(b > 0);
a %= b;
if (a < 0) {
a += b;
}
return a;
}
LL fl(LL a, LL b) {
assert(b > 0);
return (a > 0 ? a / b : (a - b + 1) / b);
}
LL ce(LL a, LL b) {
assert(b > 0);
return (a < 0 ? a / b : (a + b - 1) / b);
}
#define bit(b, i) (((b) >> (i)) & 1)
#define BC __builtin_popcountll
#define SC(T, v) static_cast<T>(v)
#define SI(v) SC(int, v.size())
#define SL(v) SC(LL, v.size())
#define RF(e, v) for (auto &e : v)
#define ei else if
#define UR assert(false)
// ---- ----
int n, k;
string s;
int main() {
cin >> n >> k >> s;
int j = 0, ans = 0, c = 0;
inc(i, n) {
if (s[i] == '0' && (i == 0 || s[i - 1] == '1')) {
c++;
}
if (c <= k) {
setmax(ans, i - j + 1);
} else {
while (c > k) {
if (s[j] == '0' && (j == 0 || s[j - 1] == '1')) {
c--;
}
j++;
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incII(i, l, r) for (int i = (l); i <= (r); ++i)
#define incID(i, l, r) for (int i = (l); i < (r); ++i)
#define decII(i, l, r) for (int i = (r); i >= (l); --i)
#define decID(i, l, r) for (int i = (r)-1; i >= (l); --i)
#define inc(i, n) incID(i, 0, n)
#define inc1(i, n) incII(i, 1, n)
#define dec(i, n) decID(i, 0, n)
#define dec1(i, n) decII(i, 1, n)
#define inII(v, l, r) ((l) <= (v) && (v) <= (r))
#define inID(v, l, r) ((l) <= (v) && (v) < (r))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
template <typename T> bool setmin(T &a, T b) {
if (b < a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmax(T &a, T b) {
if (b > a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmineq(T &a, T b) {
if (b <= a) {
a = b;
return true;
} else {
return false;
}
}
template <typename T> bool setmaxeq(T &a, T b) {
if (b >= a) {
a = b;
return true;
} else {
return false;
}
}
LL mo(LL a, LL b) {
assert(b > 0);
a %= b;
if (a < 0) {
a += b;
}
return a;
}
LL fl(LL a, LL b) {
assert(b > 0);
return (a > 0 ? a / b : (a - b + 1) / b);
}
LL ce(LL a, LL b) {
assert(b > 0);
return (a < 0 ? a / b : (a + b - 1) / b);
}
#define bit(b, i) (((b) >> (i)) & 1)
#define BC __builtin_popcountll
#define SC(T, v) static_cast<T>(v)
#define SI(v) SC(int, v.size())
#define SL(v) SC(LL, v.size())
#define RF(e, v) for (auto &e : v)
#define ei else if
#define UR assert(false)
// ---- ----
int n, k;
string s;
int main() {
cin >> n >> k >> s;
int j = 0, ans = 0, c = 0;
inc(i, n) {
if (s[i] == '0' && (i == 0 || s[i - 1] == '1')) {
c++;
}
if (c <= k) {
setmax(ans, i - j + 1);
} else {
while (c > k) {
if (s[j] == '0' && (j == n - 1 || s[j + 1] == '1')) {
c--;
}
j++;
}
}
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change",
"misc.opposites",
"expression.operator.arithmetic.change"
] | 886,098 | 886,099 | u568652083 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// cout << fixed << setprecision(15);
vector<int> forintinput(int n) {
vector<int> x;
for (int i = 0; i < n; i++) {
int ia;
cin >> ia;
x.push_back(ia);
}
return x;
}
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a >= k) {
cout << ":(" << endl;
} else {
cout << "Yay!" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// cout << fixed << setprecision(15);
vector<int> forintinput(int n) {
vector<int> x;
for (int i = 0; i < n; i++) {
int ia;
cin >> ia;
x.push_back(ia);
}
return x;
}
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k) {
cout << ":(" << endl;
} else {
cout << "Yay!" << endl;
}
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 886,100 | 886,101 | u025223061 | cpp |
p03074 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef vector<ll> V;
typedef vector<V> VV;
int main() {
// Happy hacking!
ll n, k;
string s;
cin >> n >> k;
cin >> s;
V blk_size;
V blk_dist;
ll t_size = 0;
ll t_dist = 0;
bool is_in_blk = false;
if (s[0] == '0') {
is_in_blk = false;
blk_size.push_back(0);
} else {
is_in_blk = true;
}
for (ll i = 0; i < n; i++) {
char c = s[i];
if (is_in_blk) {
if (c == '0') {
is_in_blk = false;
blk_size.push_back(t_size);
t_dist = 1;
} else {
t_size++;
}
} else {
if (c == '0') {
t_dist++;
} else {
is_in_blk = true;
blk_dist.push_back(t_dist);
t_size = 1;
}
}
}
if (is_in_blk) {
blk_size.push_back(t_size);
blk_dist.push_back(0);
} else {
blk_dist.push_back(t_dist);
}
ll score_max = 0;
// calc initial score
ll score_prev = 0;
ll init_idx = 0;
for (; init_idx < k; init_idx++) {
if (init_idx >= blk_size.size())
break;
score_prev += blk_size[init_idx] + blk_dist[init_idx];
}
if (init_idx < blk_size.size()) {
score_prev += blk_size[init_idx];
}
score_max = score_prev;
for (ll i = 1; i < blk_size.size() - k + 1; i++) {
ll score = score_prev;
score -= blk_size[i - 1] + blk_dist[i - 1]; // remove the head block
score += blk_dist[i + k - 1]; // expand
if (i + k < blk_size.size()) {
score += blk_size[i + k];
}
if (score > score_max) {
score_max = score;
}
score_prev = score;
}
cout << score_max << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long int ll;
typedef vector<ll> V;
typedef vector<V> VV;
int main() {
// Happy hacking!
ll n, k;
string s;
cin >> n >> k;
cin >> s;
V blk_size;
V blk_dist;
ll t_size = 0;
ll t_dist = 0;
bool is_in_blk = false;
if (s[0] == '0') {
is_in_blk = false;
blk_size.push_back(0);
} else {
is_in_blk = true;
}
for (ll i = 0; i < n; i++) {
char c = s[i];
if (is_in_blk) {
if (c == '0') {
is_in_blk = false;
blk_size.push_back(t_size);
t_dist = 1;
} else {
t_size++;
}
} else {
if (c == '0') {
t_dist++;
} else {
is_in_blk = true;
blk_dist.push_back(t_dist);
t_size = 1;
}
}
}
if (is_in_blk) {
blk_size.push_back(t_size);
blk_dist.push_back(0);
} else {
blk_dist.push_back(t_dist);
}
ll score_max = 0;
// calc initial score
ll score_prev = 0;
ll init_idx = 0;
for (; init_idx < k; init_idx++) {
if (init_idx >= blk_size.size())
break;
score_prev += blk_size[init_idx] + blk_dist[init_idx];
}
if (init_idx < blk_size.size()) {
score_prev += blk_size[init_idx];
}
score_max = score_prev;
for (ll i = 1; i < ((ll)blk_size.size()) - k + 1; i++) {
ll score = score_prev;
score -= blk_size[i - 1] + blk_dist[i - 1]; // remove the head block
score += blk_dist[i + k - 1]; // expand
if (i + k < blk_size.size()) {
score += blk_size[i + k];
}
if (score > score_max) {
score_max = score;
}
score_prev = score;
}
cout << score_max << endl;
return 0;
}
| [
"control_flow.loop.for.condition.change",
"call.arguments.change"
] | 886,102 | 886,103 | u315265093 | cpp |
p03074 | #include <iostream>
#include <vector>
using namespace std;
void update(int *c, int *p, int *a, int *head, int *size, int a_size, long *sum,
long *max) {
// cout << "add:" << *c << endl;
// push
if (*size < a_size) {
// cout << "size:" << *size<< endl;
a[*head + *size] = *c;
*sum += *c;
*size += *size + 1;
} else {
// cout << "remove:" << a[*head] << endl;
*sum -= a[*head];
a[*head] = *c;
*sum += *c;
*head = (*head + 1) % a_size;
}
if (*p) {
if (*max < *sum) {
// cout << "update: " << *sum << endl;
*max = *sum;
}
}
*p = !(*p);
*c = 1;
}
int main() {
int n, k;
int *a;
cin >> n >> k;
int a_size = 2 * k + 1;
a = new int[a_size];
int head = 0, size = 0;
long sum = 0;
long max = 0;
char s;
int c = 0, p = 1;
for (int i = 0; i < n; i++) {
cin >> s;
s -= '0';
if (s == p) {
c++;
} else {
update(&c, &p, a, &head, &size, a_size, &sum, &max);
}
}
// push
if (c > 0) {
update(&c, &p, a, &head, &size, a_size, &sum, &max);
if (p) {
c = 0;
update(&c, &p, a, &head, &size, a_size, &sum, &max);
}
} else if (p) {
c = 0;
update(&c, &p, a, &head, &size, a_size, &sum, &max);
}
// cout << endl;
cout << max << endl;
} | #include <iostream>
#include <vector>
using namespace std;
void update(long *c, int *p, int *a, int *head, int *size, int a_size,
long *sum, long *max) {
// cout << "add:" << *c << endl;
// push
if (*size < a_size) {
// cout << "size:" << *size<< endl;
a[*head + *size] = *c;
*sum += *c;
*size = *size + 1;
} else {
// cout << "remove:" << a[*head] << endl;
*sum -= a[*head];
a[*head] = *c;
*sum += *c;
*head = (*head + 1) % a_size;
}
if (*p) {
if (*max < *sum) {
// cout << "update: " << *sum << endl;
*max = *sum;
}
}
*p = !(*p);
*c = 1;
}
int main() {
int n, k;
int *a;
cin >> n >> k;
int a_size = 2 * k + 1;
a = new int[a_size];
int head = 0, size = 0;
long sum = 0;
long max = 0;
char s;
long c = 0;
int p = 1;
for (int i = 0; i < n; i++) {
cin >> s;
s -= '0';
if (s == p) {
c++;
} else {
update(&c, &p, a, &head, &size, a_size, &sum, &max);
}
}
// push
if (c > 0) {
update(&c, &p, a, &head, &size, a_size, &sum, &max);
if (p) {
c = 0;
update(&c, &p, a, &head, &size, a_size, &sum, &max);
}
} else if (p) {
c = 0;
update(&c, &p, a, &head, &size, a_size, &sum, &max);
}
// cout << endl;
cout << max << endl;
} | [
"variable_declaration.type.primitive.change",
"assignment.value.change"
] | 886,110 | 886,111 | u199912250 | cpp |
p03074 | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
#define llong long long
#define INF (__INT32_MAX__ / 2)
#define MAX_NK 100000
using namespace std;
int N, K;
string S;
vector<int> sct;
int solve() {
if (S[0] == '0')
sct.push_back(0);
char prev = S[0];
int sct_len = 0;
S.push_back('2');
for (int i = 0; i < S.size(); ++i) {
if (S[i] == prev)
++sct_len;
else {
sct.push_back(sct_len);
sct_len = 1;
}
prev = S[i];
}
if (S[S.size() - 1] == '0')
sct.push_back(0);
int start = 0;
int end = min(K * 2, (int)sct.size() - 1);
int sum = 0;
for (int i = start; i <= end; ++i)
sum += sct[i];
int res = sum;
while (end <= sct.size()) {
sum -= sct[start];
sum -= sct[start + 1];
sum += sct[end + 1];
sum += sct[end + 2];
res = max(res, sum);
end += 2;
start += 2;
}
return res;
}
int main(int argc, char **argv) {
cin >> N >> K;
cin >> S;
printf("%d\n", solve());
} | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
#define llong long long
#define INF (__INT32_MAX__ / 2)
#define MAX_NK 100000
using namespace std;
int N, K;
string S;
vector<int> sct;
int solve() {
if (S[0] == '0')
sct.push_back(0);
char prev = S[0];
int sct_len = 0;
S.push_back('2');
for (int i = 0; i < S.size(); ++i) {
if (S[i] == prev)
++sct_len;
else {
sct.push_back(sct_len);
sct_len = 1;
}
prev = S[i];
}
if (S[S.size() - 2] == '0')
sct.push_back(0);
int start = 0;
int end = min(K * 2, (int)sct.size() - 1);
int sum = 0;
for (int i = start; i <= end; ++i)
sum += sct[i];
int res = sum;
while (end + 2 <= sct.size()) {
sum -= sct[start];
sum -= sct[start + 1];
sum += sct[end + 1];
sum += sct[end + 2];
res = max(res, sum);
end += 2;
start += 2;
}
return res;
}
int main(int argc, char **argv) {
cin >> N >> K;
cin >> S;
printf("%d\n", solve());
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"control_flow.loop.condition.change"
] | 886,114 | 886,115 | u777137418 | cpp |
p03074 | #include <bits/stdc++.h>
#define MB template <class T>
#define Fur(i, x, y) for (int i = x; i <= y; i++)
#define fcin ios::sync_with_stdio(false)
MB T MAX(T x, T y) { return x > y ? x : y; }
using namespace std;
#define N 400000
char ch[N];
int n, k, a[N], d = 1, ans = 0, t;
int main() {
fcin;
cin >> n >> k >> ch;
for (int i = 0; i < n;) {
while (ch[i] == 49)
a[d]++, i++;
d++;
while (ch[i] == 48)
a[d]++, i++;
d++;
}
Fur(i, 1, d) a[i + 1] += a[i];
t = k * 2 + 1;
Fur(i, t, d) ans = MAX(ans, a[i] - a[i - t]), i++;
cout << ans << endl;
} | #include <bits/stdc++.h>
#define MB template <class T>
#define Fur(i, x, y) for (int i = x; i <= y; i++)
#define fcin ios::sync_with_stdio(false)
MB T MAX(T x, T y) { return x > y ? x : y; }
using namespace std;
#define N 400000
char ch[N];
int n, k, a[N], d = 1, ans = 0, t;
int main() {
fcin;
cin >> n >> k >> ch;
for (int i = 0; i < n;) {
while (ch[i] == 49)
a[d]++, i++;
d++;
while (ch[i] == 48)
a[d]++, i++;
d++;
}
Fur(i, 1, d) a[i + 1] += a[i];
t = k * 2 + 1;
Fur(i, 1, d) ans = MAX(ans, a[i] - a[MAX(i - t, 0)]), i++;
cout << ans << endl;
} | [
"assignment.variable.change",
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"call.add",
"call.arguments.add"
] | 886,118 | 886,119 | u871414721 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i <= n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<ll, ll>;
int main() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
vll res0, res1;
ll i = 0, len0 = 0, len1 = 0;
while (1) {
while (s[i] == '0') {
if (len1)
res1.push_back(len1);
len1 = 0;
len0++;
i++;
if (i == n)
break;
}
if (i == n)
break;
while (s[i] == '1') {
if (len0)
res0.push_back(len0);
len0 = 0;
len1++;
i++;
if (i == n)
break;
}
if (i == n)
break;
}
if (len0)
res0.push_back(len0);
if (len1)
res1.push_back(len1);
ll a = res0.size(), b = res1.size();
k = min(k, a);
if (a == b && s[0] == '0') {
res1.push_back(0);
REPR(i, b) res1[i + 1] = res1[i];
res1[0] = 0;
b++;
}
if (a == b && s[0] == '1') {
res1.push_back(0);
}
if (a > b) {
res1.push_back(0);
REPR(i, b) res1[i + 1] = res1[i];
res1[0] = 0;
res1.push_back(0);
b += 2;
}
vll s0(a + 1, 0), s1(b + 1, 0);
REP(i, a) { s0[i + 1] = s0[i] + res0[i]; }
REP(i, b) { s1[i + 1] = s1[i] + res1[i]; }
ll x = a - k + 1, ans = 0;
REP(i, x) {
ll res = s1[k + i + 1] - s1[i] + s0[k + i] - s0[i];
ans = max(ans, res);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i <= n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<ll, ll>;
int main() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
vll res0, res1;
ll i = 0, len0 = 0, len1 = 0;
while (1) {
while (s[i] == '0') {
if (len1)
res1.push_back(len1);
len1 = 0;
len0++;
i++;
if (i == n)
break;
}
if (i == n)
break;
while (s[i] == '1') {
if (len0)
res0.push_back(len0);
len0 = 0;
len1++;
i++;
if (i == n)
break;
}
if (i == n)
break;
}
if (len0)
res0.push_back(len0);
if (len1)
res1.push_back(len1);
ll a = res0.size(), b = res1.size();
k = min(k, a);
if (a == b && s[0] == '0') {
res1.push_back(0);
REPR(i, b) res1[i + 1] = res1[i];
res1[0] = 0;
b++;
}
if (a == b && s[0] == '1') {
res1.push_back(0);
b++;
}
if (a > b) {
res1.push_back(0);
REPR(i, b) res1[i + 1] = res1[i];
res1[0] = 0;
res1.push_back(0);
b += 2;
}
vll s0(a + 1, 0), s1(b + 1, 0);
REP(i, a) { s0[i + 1] = s0[i] + res0[i]; }
REP(i, b) { s1[i + 1] = s1[i] + res1[i]; }
ll x = a - k + 1, ans = 0;
REP(i, x) {
ll res = s1[k + i + 1] - s1[i] + s0[k + i] - s0[i];
ans = max(ans, res);
}
cout << ans << endl;
return 0;
} | [
"expression.unary.arithmetic.add"
] | 886,120 | 886,121 | u986276444 | cpp |
p03074 | #include <algorithm>
#include <climits>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <memory>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
class Stand {
public:
int r;
int num;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<Stand> stand;
stand.emplace_back();
stand.back().r = s[0] == '0' ? 0 : 1;
stand.back().num = 1;
for (int i = 1; i < n; i++) {
if (s[i - 1] == s[i]) {
stand.back().num++;
} else {
stand.emplace_back();
stand.back().r = s[i] == '0' ? 0 : 1;
stand.back().num = stand[stand.size() - 2].num + 1;
}
}
int tmp0 = 0;
for (int i = 0; i < stand.size(); i++) {
if (stand[i].r == 0)
tmp0++;
}
if (tmp0 <= k) {
cout << n << endl;
return 0;
}
int max = 0;
int k_ = k * 2 + 1;
if (s[0] == '0') {
max = stand[k * 2 - 1].num;
for (int i = 1; i + k_ - 1 < stand.size(); i += 2) {
int min = 0;
if (i - 1 >= 0)
min = stand[i - 1].num;
max = std::max(max, stand[i + k_ - 1].num - min);
}
} else {
for (int i = 0; i + k_ - 1 < stand.size(); i++) {
int min = 0;
if (i - 1 >= 0)
min = stand[i - 1].num;
max = std::max(max, stand[i + k_ - 1].num - min);
}
}
if (s[n - 1] == '0') {
int min = 0;
if (stand.size() - 1 - k * 2 >= 0)
min = stand[stand.size() - k * 2 - 1].num;
max = std::max(max, n - min);
}
cout << max << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <memory>
#include <sstream>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
class Stand {
public:
int r;
int num;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<Stand> stand;
stand.emplace_back();
stand.back().r = s[0] == '0' ? 0 : 1;
stand.back().num = 1;
for (int i = 1; i < n; i++) {
if (s[i - 1] == s[i]) {
stand.back().num++;
} else {
stand.emplace_back();
stand.back().r = s[i] == '0' ? 0 : 1;
stand.back().num = stand[stand.size() - 2].num + 1;
}
}
int tmp0 = 0;
for (int i = 0; i < stand.size(); i++) {
if (stand[i].r == 0)
tmp0++;
}
if (tmp0 <= k) {
cout << n << endl;
return 0;
}
int max = 0;
int k_ = k * 2 + 1;
if (s[0] == '0') {
max = stand[k * 2 - 1].num;
for (int i = 1; i + k_ - 1 < stand.size(); i += 2) {
int min = 0;
if (i - 1 >= 0)
min = stand[i - 1].num;
max = std::max(max, stand[i + k_ - 1].num - min);
}
} else {
for (int i = 0; i + k_ - 1 < stand.size(); i += 2) {
int min = 0;
if (i - 1 >= 0)
min = stand[i - 1].num;
max = std::max(max, stand[i + k_ - 1].num - min);
}
}
if (s[n - 1] == '0') {
int min = 0;
if (stand.size() - 1 - k * 2 >= 0)
min = stand[stand.size() - k * 2 - 1].num;
max = std::max(max, n - min);
}
cout << max << endl;
return 0;
} | [] | 886,139 | 886,140 | u830782448 | cpp |
p03074 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define SORT(c) sort((c).begin(), (c).end())
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// sort(v.rbegin(), v.rend(), [](auto& x, auto& y){return x[1] < y[1];});
// cout << fixed << setprecision(10) << ans << defaultfloat << endl;
typedef long long ll;
typedef vector<int> Vi;
typedef vector<ll> Vl;
typedef vector<double> Vd;
typedef vector<string> Vs;
ll mod = 1e9 + 7;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
Vi v;
if (S[0] == '0')
v.push_back(0);
int c = 1;
REP(i, N - 1) {
if (S[i + 1] == S[i]) {
c++;
} else {
v.push_back(c);
c = 1;
}
}
v.push_back(c);
if (S[N] == '0')
v.push_back(0);
// for(auto i:v) cout << i << endl;
int l = 0, r = 2 * K, ans = 0;
if (r + 1 > v.size()) {
cout << accumulate(v.begin(), v.end(), 0) << endl;
return 0;
}
int count = accumulate(v.begin(), v.begin() + r + 1, 0);
ans = count;
while (r + 2 <= v.size() - 1) {
count += v[r + 1] - v[l];
// ans = max({ans,count});
r++;
l++;
count += v[r + 1] - v[l];
ans = max({ans, count});
r++;
l++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define SORT(c) sort((c).begin(), (c).end())
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// sort(v.rbegin(), v.rend(), [](auto& x, auto& y){return x[1] < y[1];});
// cout << fixed << setprecision(10) << ans << defaultfloat << endl;
typedef long long ll;
typedef vector<int> Vi;
typedef vector<ll> Vl;
typedef vector<double> Vd;
typedef vector<string> Vs;
ll mod = 1e9 + 7;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
Vi v;
if (S[0] == '0')
v.push_back(0);
int c = 1;
REP(i, N - 1) {
if (S[i + 1] == S[i]) {
c++;
} else {
v.push_back(c);
c = 1;
}
}
v.push_back(c);
if (S[N - 1] == '0')
v.push_back(0);
// for(auto i:v) cout << i << endl;
int l = 0, r = 2 * K, ans = 0;
if (r + 1 > v.size()) {
cout << accumulate(v.begin(), v.end(), 0) << endl;
return 0;
}
int count = accumulate(v.begin(), v.begin() + r + 1, 0);
ans = count;
while (r + 2 <= v.size() - 1) {
count += v[r + 1] - v[l];
// ans = max({ans,count});
r++;
l++;
count += v[r + 1] - v[l];
ans = max({ans, count});
r++;
l++;
}
cout << ans << endl;
} | [
"control_flow.branch.if.condition.change"
] | 886,159 | 886,160 | u335278042 | cpp |
p03074 | // long time no ac
#include <bits/stdc++.h>
using namespace std;
#define debug(x) cout << #x << " :: " << x << "\n";
#define debug2(x, y) \
cout << #x << " :: " << x << "\t" << #y << " :: " << y << "\n";
#define debug3(x, y, z) \
cout << #x << " :: " << x << "\t" << #y << " :: " << y << "\t" << #z \
<< " :: " << z << "\n";
#define SPEED \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define setprecn(x) cout << fixed << setprecision(x);
#define ll long long int
#define pb push_back
#define pll pair<ll, ll>
#define vll vector<ll>
#define ff first
#define ss second
#define all(a) (a).begin(), (a).end()
#define sz(x) (ll) x.size()
#define hell 1000000007
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repe(i, a, b) for (ll i = a; i < b; i++)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
ll power(ll a, ll b) {
if (b == 0)
return 1;
if (b == 1)
return a;
ll c = power(a, b / 2);
if (b % 2 == 0)
return ((c % hell) * (c % hell)) % hell;
return ((((c % hell) * (c % hell)) % hell) * (a % hell)) % hell;
}
/********************************************************/
// d.erase(unique(all(d)), d.end());
int main() {
SPEED;
ll n, k, m, i, j, c = 0, cs = 0, t;
t = 1;
// cin>>t;
string s;
while (t--) {
// cs++;
cin >> n >> k >> s;
// n=s.length();
// ll a[n][2]={0}
vector<pll> v;
rep(i, n) {
if (s[i] == '1') {
j = i;
while (s[i] == '1')
i++;
v.pb({1, i - j});
} else {
j = i;
while (s[i] == '0')
i++;
v.pb({0, i - j});
}
i--;
}
i = 0, j = 0;
n = v.size();
while (i < n && c < k) {
if (v[i].ff == 0)
c++;
cs += v[i].ss;
i++;
}
if (v[i].ff == 1)
cs += v[i].ss, i++;
m = cs;
while (i < n && j < n) {
// debug3(i,v[i].ff,v[i].ss);
cs -= v[j].ss;
j++;
if (j < n && v[j].ff == 0)
cs -= v[j].ss;
j++;
if (i < n)
cs += v[i].ss;
i++;
if (i < n && v[i].ff == 1)
cs += v[i].ss;
m = max(m, cs);
}
cout << m;
if (t != 0)
cout << "\n";
}
return 0;
} | // long time no ac
#include <bits/stdc++.h>
using namespace std;
#define debug(x) cout << #x << " :: " << x << "\n";
#define debug2(x, y) \
cout << #x << " :: " << x << "\t" << #y << " :: " << y << "\n";
#define debug3(x, y, z) \
cout << #x << " :: " << x << "\t" << #y << " :: " << y << "\t" << #z \
<< " :: " << z << "\n";
#define SPEED \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define setprecn(x) cout << fixed << setprecision(x);
#define ll long long int
#define pb push_back
#define pll pair<ll, ll>
#define vll vector<ll>
#define ff first
#define ss second
#define all(a) (a).begin(), (a).end()
#define sz(x) (ll) x.size()
#define hell 1000000007
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repe(i, a, b) for (ll i = a; i < b; i++)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
ll power(ll a, ll b) {
if (b == 0)
return 1;
if (b == 1)
return a;
ll c = power(a, b / 2);
if (b % 2 == 0)
return ((c % hell) * (c % hell)) % hell;
return ((((c % hell) * (c % hell)) % hell) * (a % hell)) % hell;
}
/********************************************************/
// d.erase(unique(all(d)), d.end());
int main() {
SPEED;
ll n, k, m, i, j, c = 0, cs = 0, t;
t = 1;
// cin>>t;
string s;
while (t--) {
// cs++;
cin >> n >> k >> s;
// n=s.length();
// ll a[n][2]={0}
vector<pll> v;
rep(i, n) {
if (s[i] == '1') {
j = i;
while (s[i] == '1')
i++;
v.pb({1, i - j});
} else {
j = i;
while (s[i] == '0')
i++;
v.pb({0, i - j});
}
i--;
}
i = 0, j = 0;
n = v.size();
while (i < n && c < k) {
if (v[i].ff == 0)
c++;
cs += v[i].ss;
i++;
}
if (v[i].ff == 1)
cs += v[i].ss, i++;
m = cs;
while (i < n && j < n) {
// debug3(i,v[i].ff,v[i].ss);
cs -= v[j].ss;
j++;
if (j < n && v[j].ff == 0)
cs -= v[j].ss, j++;
if (i < n)
cs += v[i].ss;
i++;
if (i < n && v[i].ff == 1)
cs += v[i].ss, i++;
m = max(m, cs);
}
cout << m;
if (t != 0)
cout << "\n";
}
return 0;
} | [] | 886,168 | 886,169 | u355198744 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
string s;
cin >> s;
int ans = 0, l = 0, r = 0;
int cnt = 0;
queue<int> q;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
while (r < n && s[r] == '0') {
r++;
}
q.push(i + 1);
cnt++;
if (cnt > k) {
l = q.front();
q.pop();
cnt--;
}
i = r - 1;
} else {
r++;
}
// cout << l << " " << r << endl;
ans = max(ans, r - l);
// cout << l << " " << r << " " << cnt << endl;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
string s;
cin >> s;
int ans = 0, l = 0, r = 0;
int cnt = 0;
queue<int> q;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
while (r < n && s[r] == '0') {
r++;
}
q.push(r);
cnt++;
if (cnt > k) {
l = q.front();
q.pop();
cnt--;
}
i = r - 1;
} else {
r++;
}
ans = max(ans, r - l);
}
cout << ans << endl;
return 0;
}
| [
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 886,170 | 886,171 | u344122377 | cpp |
p03074 | #include <bits/stdc++.h>
#define ll long long
#define ff first
#define ss second
#define PB push_back
#define MP make_pair
#define pri 10000000007
using namespace std;
void run() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
ll maxi = 0, oldo = 0, oldn = 0;
ll ro = 0, rz = 0;
ll preze[n + 1] = {0}, preon[n + 1] = {0};
for (ll i = 0; i < n; i++) {
if (s[i] == '0' && ((i >= 1) && s[i - 1] == '1')) {
preon[ro] = oldn;
ro++;
}
if (s[i] == '1' && (i >= 1 && s[i - 1] == '0')) {
preze[rz] = oldo;
rz++;
}
if (s[i] == '0') {
oldo++;
oldn = 0;
}
if (s[i] == '1') {
oldn++;
oldo = 0;
}
}
if (s[n - 1] == '1') {
preon[ro] = oldn;
ro++;
} else {
preze[rz] = oldo;
rz++;
}
for (ll i = 1; i < rz; i++) {
preze[i] += preze[i - 1];
}
for (ll i = 1; i < ro; i++) {
preon[i] += preon[i - 1];
}
for (ll i = 0; i < ro; i++) {
// cout<<preon[i]<<" "<<preze[i]<<endl;
ll se = (preon[i] - (i - k - 1 >= 0 ? preon[i - k - 1] : 0));
// cout<<se<<endl;
ll sa = 0;
if (s[0] == '0') {
sa = (preze[i] - (i - k >= 0 ? preze[i - k] : 0));
// cout<<"a";
} else {
sa = ((i - 1 >= 0 ? preze[i - 1] : 0) -
(i - k - 1 >= 0 ? preze[i - k - 1] : 0));
// cout<<(i-1);
}
// cout<<sa<<"ss"<<endl;
se += sa;
maxi = max(maxi, se);
}
ll se = (((ro >= 1) ? preon[ro - 1] : 0) -
(ro - k - 2 >= 0 ? preon[ro - k - 2] : 0));
if (s[n - 1] == '0') {
se += (preze[rz - 1] - (rz - 1 - k >= 0 ? preze[rz - 1 - k] : 0));
}
maxi = max(maxi, se);
if (ro == 0) {
cout << n << endl;
} else {
cout << maxi << endl;
}
}
int main() {
ll t = 1;
// cin>>t;
for (ll i = 0; i < t; i++)
run();
// your code goes here
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define ff first
#define ss second
#define PB push_back
#define MP make_pair
#define pri 10000000007
using namespace std;
void run() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
ll maxi = 0, oldo = 0, oldn = 0;
ll ro = 0, rz = 0;
ll preze[n + 1] = {0}, preon[n + 1] = {0};
for (ll i = 0; i < n; i++) {
if (s[i] == '0' && ((i >= 1) && s[i - 1] == '1')) {
preon[ro] = oldn;
ro++;
}
if (s[i] == '1' && (i >= 1 && s[i - 1] == '0')) {
preze[rz] = oldo;
rz++;
}
if (s[i] == '0') {
oldo++;
oldn = 0;
}
if (s[i] == '1') {
oldn++;
oldo = 0;
}
}
if (s[n - 1] == '1') {
preon[ro] = oldn;
ro++;
} else {
preze[rz] = oldo;
rz++;
}
for (ll i = 1; i < rz; i++) {
preze[i] += preze[i - 1];
}
for (ll i = 1; i < ro; i++) {
preon[i] += preon[i - 1];
}
for (ll i = 0; i < ro; i++) {
// cout<<preon[i]<<" "<<preze[i]<<endl;
ll se = (preon[i] - (i - k - 1 >= 0 ? preon[i - k - 1] : 0));
// cout<<se<<endl;
ll sa = 0;
if (s[0] == '0') {
sa = (preze[i] - (i - k >= 0 ? preze[i - k] : 0));
// cout<<"a";
} else {
sa = ((i - 1 >= 0 ? preze[i - 1] : 0) -
(i - k - 1 >= 0 ? preze[i - k - 1] : 0));
// cout<<(i-1);
}
// cout<<sa<<"ss"<<endl;
se += sa;
maxi = max(maxi, se);
}
ll se = (((ro >= 1) ? preon[ro - 1] : 0) -
(ro - k - 1 >= 0 ? preon[ro - k - 1] : 0));
// out<<se;
if (s[n - 1] == '0') {
se += (preze[rz - 1] - (rz - 1 - k >= 0 ? preze[rz - 1 - k] : 0));
}
maxi = max(maxi, se);
if (ro == 0) {
cout << n << endl;
} else {
cout << maxi << endl;
}
}
int main() {
ll t = 1;
// cin>>t;
for (ll i = 0; i < t; i++)
run();
// your code goes here
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_access.subscript.index.change"
] | 886,176 | 886,177 | u874786170 | cpp |
p03074 | #include <bits/stdc++.h>
#define ll long long
#define ff first
#define ss second
#define PB push_back
#define MP make_pair
#define pri 10000000007
using namespace std;
void run() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
ll maxi = 0, oldo = 0, oldn = 0;
ll ro = 0, rz = 0;
ll preze[n + 1] = {0}, preon[n + 1] = {0};
for (ll i = 0; i < n; i++) {
if (s[i] == '0' && ((i >= 1) && s[i - 1] == '1')) {
preon[ro] = oldn;
ro++;
}
if (s[i] == '1' && (i >= 1 && s[i - 1] == '0')) {
preze[rz] = oldo;
rz++;
}
if (s[i] == '0') {
oldo++;
oldn = 0;
}
if (s[i] == '1') {
oldn++;
oldo = 0;
}
}
if (s[n - 1] == '1') {
preon[ro] = oldn;
ro++;
} else {
preze[rz] = oldo;
rz++;
}
for (ll i = 1; i < rz; i++) {
preze[i] += preze[i - 1];
}
for (ll i = 1; i < ro; i++) {
preon[i] += preon[i - 1];
}
for (ll i = 0; i < ro; i++) {
// cout<<preon[i]<<" "<<preze[i]<<endl;
ll se = (preon[i] - (i - k - 1 >= 0 ? preon[i - k - 1] : 0));
// cout<<se<<endl;
ll sa = 0;
if (s[0] == '0') {
sa = (preze[i] - (i - k >= 0 ? preze[i - k] : 0));
// cout<<"a";
} else {
sa = ((i - 1 >= 0 ? preze[i - 1] : 0) -
(i - k - 1 >= 0 ? preze[i - k - 1] : 0));
// cout<<(i-1);
}
// cout<<sa<<"ss"<<endl;
se += sa;
maxi = max(maxi, se);
}
ll se = (((ro >= 1) ? preon[ro - 1] : 0) -
(ro - k - 2 >= 0 ? preon[ro - k - 2] : 0));
if (s[n] == '0') {
se += (preze[rz - 1] - (rz - 1 - k >= 0 ? preze[rz - 1 - k] : 0));
}
maxi = max(maxi, se);
if (ro == 0) {
cout << n << endl;
} else {
cout << maxi << endl;
}
}
int main() {
ll t = 1;
// cin>>t;
for (ll i = 0; i < t; i++)
run();
// your code goes here
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define ff first
#define ss second
#define PB push_back
#define MP make_pair
#define pri 10000000007
using namespace std;
void run() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
ll maxi = 0, oldo = 0, oldn = 0;
ll ro = 0, rz = 0;
ll preze[n + 1] = {0}, preon[n + 1] = {0};
for (ll i = 0; i < n; i++) {
if (s[i] == '0' && ((i >= 1) && s[i - 1] == '1')) {
preon[ro] = oldn;
ro++;
}
if (s[i] == '1' && (i >= 1 && s[i - 1] == '0')) {
preze[rz] = oldo;
rz++;
}
if (s[i] == '0') {
oldo++;
oldn = 0;
}
if (s[i] == '1') {
oldn++;
oldo = 0;
}
}
if (s[n - 1] == '1') {
preon[ro] = oldn;
ro++;
} else {
preze[rz] = oldo;
rz++;
}
for (ll i = 1; i < rz; i++) {
preze[i] += preze[i - 1];
}
for (ll i = 1; i < ro; i++) {
preon[i] += preon[i - 1];
}
for (ll i = 0; i < ro; i++) {
// cout<<preon[i]<<" "<<preze[i]<<endl;
ll se = (preon[i] - (i - k - 1 >= 0 ? preon[i - k - 1] : 0));
// cout<<se<<endl;
ll sa = 0;
if (s[0] == '0') {
sa = (preze[i] - (i - k >= 0 ? preze[i - k] : 0));
// cout<<"a";
} else {
sa = ((i - 1 >= 0 ? preze[i - 1] : 0) -
(i - k - 1 >= 0 ? preze[i - k - 1] : 0));
// cout<<(i-1);
}
// cout<<sa<<"ss"<<endl;
se += sa;
maxi = max(maxi, se);
}
ll se = (((ro >= 1) ? preon[ro - 1] : 0) -
(ro - k - 1 >= 0 ? preon[ro - k - 1] : 0));
// out<<se;
if (s[n - 1] == '0') {
se += (preze[rz - 1] - (rz - 1 - k >= 0 ? preze[rz - 1 - k] : 0));
}
maxi = max(maxi, se);
if (ro == 0) {
cout << n << endl;
} else {
cout << maxi << endl;
}
}
int main() {
ll t = 1;
// cin>>t;
for (ll i = 0; i < t; i++)
run();
// your code goes here
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 886,178 | 886,177 | u874786170 | cpp |
p03074 | #include <bits/stdc++.h>
#define ll long long
#define ff first
#define ss second
#define PB push_back
#define MP make_pair
#define pri 10000000007
using namespace std;
void run() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
ll maxi = 0, oldo = 0, oldn = 0;
ll ro = 0, rz = 0;
ll preze[n + 1] = {0}, preon[n + 1] = {0};
for (ll i = 0; i < n; i++) {
if (s[i] == '0' && ((i >= 1) && s[i - 1] == '1')) {
preon[ro] = oldn;
ro++;
}
if (s[i] == '1' && (i >= 1 && s[i - 1] == '0')) {
preze[rz] = oldo;
rz++;
}
if (s[i] == '0') {
oldo++;
oldn = 0;
}
if (s[i] == '1') {
oldn++;
oldo = 0;
}
}
if (s[n - 1] == '1') {
preon[ro] = oldn;
ro++;
} else {
preze[rz] = oldo;
rz++;
}
for (ll i = 1; i < rz; i++) {
preze[i] += preze[i - 1];
}
for (ll i = 1; i < ro; i++) {
preon[i] += preon[i - 1];
}
for (ll i = 0; i < ro; i++) {
// cout<<preon[i]<<" "<<preze[i]<<endl;
ll se = (preon[i] - (i - k - 1 >= 0 ? preon[i - k - 1] : 0));
// cout<<se<<endl;
ll sa = 0;
if (s[0] == '0') {
sa = (preze[i] - (i - k >= 0 ? preze[i - k] : 0));
// cout<<"a";
} else {
sa = ((i - 1 >= 0 ? preze[i - 1] : 0) -
(i - k - 1 >= 0 ? preze[i - k - 1] : 0));
// cout<<(i-1);
}
// cout<<sa<<"ss"<<endl;
se += sa;
maxi = max(maxi, se);
}
ll se = (((ro >= 1) ? preon[ro - 1] : 0) -
(ro - k - 2 >= 0 ? preon[ro - k - 2] : 0));
if (s[n] == '0') {
se += (s[rz - 1] - (rz - 1 - k >= 0 ? s[rz - 1 - k] : 0));
}
maxi = max(maxi, se);
if (ro == 0) {
cout << n << endl;
} else {
cout << maxi << endl;
}
}
int main() {
ll t = 1;
// cin>>t;
for (ll i = 0; i < t; i++)
run();
// your code goes here
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define ff first
#define ss second
#define PB push_back
#define MP make_pair
#define pri 10000000007
using namespace std;
void run() {
ll n, k;
cin >> n >> k;
string s;
cin >> s;
ll maxi = 0, oldo = 0, oldn = 0;
ll ro = 0, rz = 0;
ll preze[n + 1] = {0}, preon[n + 1] = {0};
for (ll i = 0; i < n; i++) {
if (s[i] == '0' && ((i >= 1) && s[i - 1] == '1')) {
preon[ro] = oldn;
ro++;
}
if (s[i] == '1' && (i >= 1 && s[i - 1] == '0')) {
preze[rz] = oldo;
rz++;
}
if (s[i] == '0') {
oldo++;
oldn = 0;
}
if (s[i] == '1') {
oldn++;
oldo = 0;
}
}
if (s[n - 1] == '1') {
preon[ro] = oldn;
ro++;
} else {
preze[rz] = oldo;
rz++;
}
for (ll i = 1; i < rz; i++) {
preze[i] += preze[i - 1];
}
for (ll i = 1; i < ro; i++) {
preon[i] += preon[i - 1];
}
for (ll i = 0; i < ro; i++) {
// cout<<preon[i]<<" "<<preze[i]<<endl;
ll se = (preon[i] - (i - k - 1 >= 0 ? preon[i - k - 1] : 0));
// cout<<se<<endl;
ll sa = 0;
if (s[0] == '0') {
sa = (preze[i] - (i - k >= 0 ? preze[i - k] : 0));
// cout<<"a";
} else {
sa = ((i - 1 >= 0 ? preze[i - 1] : 0) -
(i - k - 1 >= 0 ? preze[i - k - 1] : 0));
// cout<<(i-1);
}
// cout<<sa<<"ss"<<endl;
se += sa;
maxi = max(maxi, se);
}
ll se = (((ro >= 1) ? preon[ro - 1] : 0) -
(ro - k - 1 >= 0 ? preon[ro - k - 1] : 0));
// out<<se;
if (s[n - 1] == '0') {
se += (preze[rz - 1] - (rz - 1 - k >= 0 ? preze[rz - 1 - k] : 0));
}
maxi = max(maxi, se);
if (ro == 0) {
cout << n << endl;
} else {
cout << maxi << endl;
}
}
int main() {
ll t = 1;
// cin>>t;
for (ll i = 0; i < t; i++)
run();
// your code goes here
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.value.change",
"identifier.change"
] | 886,179 | 886,177 | u874786170 | cpp |
p03074 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define repp(i, m, n) for (int i = m, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define clr(ar, val) memset(ar, val, sizeof(ar))
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef long double ld;
int main(void) {
vector<pair<int, int>> hito;
int n, k, tmp = 0, len, ans = 0;
string s;
cin >> n >> k;
cin >> s;
rep(i, n + 1) {
if (i == 0) {
if (s[0] == '0')
hito.push_back(make_pair(1, 0));
} else if (i == n) {
hito.push_back(make_pair((int)(s[i - 1] - '0'), tmp));
if (s[n - 1] == '0')
hito.push_back(make_pair(1, 0));
} else if (n > 1 && s[i] != s[i - 1]) {
hito.push_back(make_pair((int)(s[i - 1] - '0'), tmp));
tmp = 0;
}
tmp++;
}
len = hito.size();
if (2 * k + 1 >= len)
ans = n;
else {
rep(i, 2 * k + 1) ans += hito[i].second;
int ans_tmp = ans;
for (int i = 2 * k; i < len - 2; i += 2) {
ans_tmp = ans - hito[i - 2 * k].second - hito[i - 2 * k + 1].second +
hito[i + 1].second + hito[i + 2].second;
chmax(ans, ans_tmp);
}
}
/* rep(i, hito.size()){
cout << (int)hito[i].first << " " << hito[i].second << endl;
} */
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define repp(i, m, n) for (int i = m, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define clr(ar, val) memset(ar, val, sizeof(ar))
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef long double ld;
int main(void) {
vector<pair<int, int>> hito;
int n, k, tmp = 0, len, ans = 0;
string s;
cin >> n >> k;
cin >> s;
rep(i, n + 1) {
if (i == 0) {
if (s[0] == '0')
hito.push_back(make_pair(1, 0));
} else if (i == n) {
hito.push_back(make_pair((int)(s[i - 1] - '0'), tmp));
if (s[n - 1] == '0')
hito.push_back(make_pair(1, 0));
} else if (n > 1 && s[i] != s[i - 1]) {
hito.push_back(make_pair((int)(s[i - 1] - '0'), tmp));
tmp = 0;
}
tmp++;
}
len = hito.size();
if (2 * k + 1 >= len)
ans = n;
else {
rep(i, 2 * k + 1) ans += hito[i].second;
// cout << ans << endl;
int ans_tmp = ans;
for (int i = 2 * k; i < len - 2; i += 2) {
ans_tmp = ans_tmp - hito[i - 2 * k].second - hito[i - 2 * k + 1].second +
hito[i + 1].second + hito[i + 2].second;
chmax(ans, ans_tmp);
// cout << i - 2 * k + 2 << " " << i + 2 << " " << ans_tmp << endl;
}
}
/* rep(i, hito.size()){
cout << (int)hito[i].first << " " << hito[i].second << endl;
} */
cout << ans << endl;
return 0;
} | [
"assignment.value.change",
"identifier.change",
"expression.operation.binary.change"
] | 886,184 | 886,185 | u617380180 | cpp |
p03074 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string s;
cin >> N >> K;
cin >> s;
//最後にN=1を考慮を
if (N == 1) {
cout << 1 << endl;
return 0;
}
int sz = 1;
for (int i = 0; i < N - 1; i++) {
if (s[i] != s[i + 1]) {
sz++;
}
}
if (s[0] == 48)
sz++;
if (s[N - 1] == 48)
sz++;
if (sz == 1) {
cout << N << endl;
return 0;
}
// szは箱の数
//箱の長さを計算
int ms = 49;
int count = 0;
int idx = 0;
vector<int> x(sz, 0);
for (int i = 0; i < N; i++) {
if (s[i] != ms) {
x[idx] = count;
count = 0;
idx++;
ms = s[i];
}
count++;
}
x[idx] = count;
int k = K * 2 + 1; //取れる箱の最大数
if (k > sz)
k = sz;
//最初のk個の連続した箱の長さを計算
int gk = 0, maxgk = 0;
for (int i = 0; i < k; i++) {
gk += x[i];
}
maxgk = gk;
//そこから2箱ずつずらして長さの最大値を計算
for (int i = 3; i < sz;) {
gk += x[i]; // 3
gk += x[i + 1]; // 4
gk -= x[i - 3]; // 0
gk -= x[i - 2]; // 1
i += 2;
if (maxgk < gk)
maxgk = gk;
}
cout << maxgk << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
string s;
cin >> N >> K;
cin >> s;
//最後にN=1を考慮を
if (N == 1) {
cout << 1 << endl;
return 0;
}
int sz = 1;
for (int i = 0; i < N - 1; i++) {
if (s[i] != s[i + 1]) {
sz++;
}
}
if (s[0] == 48)
sz++;
if (s[N - 1] == 48)
sz++;
if (sz == 1) {
cout << N << endl;
return 0;
}
// szは箱の数
//箱の長さを計算
int ms = 49;
int count = 0;
int idx = 0;
vector<int> x(sz, 0);
for (int i = 0; i < N; i++) {
if (s[i] != ms) {
x[idx] = count;
count = 0;
idx++;
ms = s[i];
}
count++;
}
x[idx] = count;
int k = K * 2 + 1; //取れる箱の最大数
if (k > sz)
k = sz;
//最初のk個の連続した箱の長さを計算
int gk = 0, maxgk = 0;
for (int i = 0; i < k; i++) {
gk += x[i];
}
maxgk = gk;
//そこから2箱ずつずらして長さの最大値を計算
for (int i = k; i < sz;) {
gk += x[i]; // 3
gk += x[i + 1]; // 4
gk -= x[i - k]; // 0
gk -= x[i - k + 1]; // 1
i += 2;
if (maxgk < gk)
maxgk = gk;
}
cout << maxgk << endl;
return 0;
} | [
"variable_declaration.value.change",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.initializer.change",
"assignment.value.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change",
"assignment.change"
] | 886,186 | 886,187 | u837951457 | cpp |
p03074 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define sz(c) ((int)(c).size())
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
const int MAX = 1e5 + 5;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vi ct0 = {0};
vi ct1 = {0};
int now = 0;
int ct = 0;
rep(i, N) {
if (now == 0) {
if (S[i] == '0')
ct++;
if (S[i] == '1') {
ct0.push_back(ct);
now = 1;
ct = 1;
}
} else {
if (S[i] == '1')
ct++;
if (S[i] == '0') {
ct1.push_back(ct);
now = 0;
ct = 1;
}
}
}
if (now == 0)
ct0.push_back(ct);
if (now == 1) {
ct1.push_back(ct);
ct0.push_back(0);
}
int l = sz(ct1);
ct1.push_back(0);
// rep(i,l)cout<<ct0[i]<<ct1[i];
// cout<<ct0[l];
if (l <= K) {
cout << N << endl;
return 0;
}
vi sum0(l + 1, 0);
vi sum1(l + 1, 0);
rep1(i, l) sum0[i] = sum0[i - 1] + ct0[i];
rep1(i, l - 1) sum1[i] = sum1[i - 1] + ct1[i];
// rep(i,l+1)cout<<sum1[i]<<" ";
int ans = 0;
for (int i = K; i <= l; i++) {
int m;
if (i != K)
m = sum0[i] - sum0[i - K] + sum1[i] - sum1[i - K - 1];
else
m = sum0[i] - sum0[i - K] + sum1[i];
ans = max(ans, m);
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define sz(c) ((int)(c).size())
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
const int MAX = 1e5 + 5;
int main() {
int N, K;
cin >> N >> K;
string S;
cin >> S;
vi ct0 = {0};
vi ct1 = {0};
int now = 0;
int ct = 0;
rep(i, N) {
if (now == 0) {
if (S[i] == '0')
ct++;
if (S[i] == '1') {
ct0.push_back(ct);
now = 1;
ct = 1;
}
} else {
if (S[i] == '1')
ct++;
if (S[i] == '0') {
ct1.push_back(ct);
now = 0;
ct = 1;
}
}
}
if (now == 0)
ct0.push_back(ct);
if (now == 1) {
ct1.push_back(ct);
ct0.push_back(0);
}
int l = sz(ct1);
ct1.push_back(0);
// rep(i,l)cout<<ct0[i]<<ct1[i];
// cout<<ct0[l];
if (l <= K) {
cout << N << endl;
return 0;
}
vi sum0(l + 1, 0);
vi sum1(l + 1, 0);
rep1(i, l) sum0[i] = sum0[i - 1] + ct0[i];
rep1(i, l) sum1[i] = sum1[i - 1] + ct1[i];
// rep(i,l+1)cout<<sum0[i]<<" ";
// cout<<endl;
// rep(i,l+1)cout<<sum1[i]<<" ";
// cout<<endl;
int ans = 0;
for (int i = K; i <= l; i++) {
int m;
if (i != K)
m = sum0[i] - sum0[i - K] + sum1[i] - sum1[i - K - 1];
else
m = sum0[i] - sum0[i - K] + sum1[i];
// cout<<m<<" ";
ans = max(ans, m);
}
cout << ans << endl;
} | [
"expression.operation.binary.remove"
] | 886,188 | 886,189 | u228214259 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
int main() {
int a[5];
int k;
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> k;
rep(i, 5) {
rep2(j, i + 1, 4) {
if (abs(a[j] - a[i]) > k) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yay!" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
int main() {
int a[5];
int k;
cin >> a[0] >> a[1] >> a[2] >> a[3] >> a[4] >> k;
rep(i, 4) {
rep2(j, i + 1, 5) {
// cout<<a[j]<<" "<<a[i]<<" "<<abs(a[j]-a[i])<<endl;
if (abs(a[j] - a[i]) > k) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yay!" << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change"
] | 886,291 | 886,292 | u406647332 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a < k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a <= k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 886,293 | 886,294 | u037675438 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a < k)
cout << "Yey!" << endl;
else
cout << ":(" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a <= k)
cout << "Yay!" << endl;
else
cout << ":(" << endl;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"io.output.change"
] | 886,295 | 886,294 | u037675438 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a(5);
int k;
int i, j, han;
for (i = 0; i < 5; i++) {
cin >> a.at(i);
}
cin >> k;
han = 0;
for (i = 0; i < 4; i++) {
for (j = i + 1; j < 4; j++) {
if (abs(a.at(i) - a.at(j)) > k) {
han++;
}
}
}
if (han == 0) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a(5);
int k;
int i, j, han;
for (i = 0; i < 5; i++) {
cin >> a.at(i);
}
cin >> k;
han = 0;
for (i = 0; i < 4; i++) {
for (j = i + 1; j < 5; j++) {
if (abs(a.at(i) - a.at(j)) > k) {
han++;
}
}
}
if (han == 0) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 886,301 | 886,302 | u764118909 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (k - a > 18)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a > k)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
} | [
"identifier.change",
"control_flow.branch.if.condition.change",
"identifier.replace.add",
"literal.replace.remove"
] | 886,309 | 886,310 | u896726004 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
const unsigned int MOD = 1000000007;
#define ll long long
#define PI 3.1416
string day[] = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
vector<string> v;
void dfs(string str, string t = "", int cnt = 0) {
if (cnt == 2) {
v.push_back(t);
return;
} else {
for (int i = 0; i < str.size(); i++) {
dfs(str, t + str[i], cnt + 1);
}
}
}
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
int a[5], k;
// while(1){
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
(a[4] - a[0]) > k ? cout << "No" << endl : cout << "Yay!" << endl;
// }
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const unsigned int MOD = 1000000007;
#define ll long long
#define PI 3.1416
string day[] = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
vector<string> v;
void dfs(string str, string t = "", int cnt = 0) {
if (cnt == 2) {
v.push_back(t);
return;
} else {
for (int i = 0; i < str.size(); i++) {
dfs(str, t + str[i], cnt + 1);
}
}
}
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
int a[5], k;
// while(1){
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
a[4] - a[0] > k ? cout << ":(" << endl : cout << "Yay!" << endl;
// }
return 0;
}
| [
"literal.string.change",
"expression.operation.binary.change"
] | 886,313 | 886,314 | u207235471 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
const unsigned int MOD = 1000000007;
#define ll long long
#define PI 3.1416
string day[] = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
vector<string> v;
void dfs(string str, string t = "", int cnt = 0) {
if (cnt == 2) {
v.push_back(t);
return;
} else {
for (int i = 0; i < str.size(); i++) {
dfs(str, t + str[i], cnt + 1);
}
}
}
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
int a[5], k;
// while(1){
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
a[4] - a[0] > k ? cout << "No" << endl : cout << "Yay!" << endl;
// }
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const unsigned int MOD = 1000000007;
#define ll long long
#define PI 3.1416
string day[] = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
vector<string> v;
void dfs(string str, string t = "", int cnt = 0) {
if (cnt == 2) {
v.push_back(t);
return;
} else {
for (int i = 0; i < str.size(); i++) {
dfs(str, t + str[i], cnt + 1);
}
}
}
int main() {
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
int a[5], k;
// while(1){
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
cin >> k;
a[4] - a[0] > k ? cout << ":(" << endl : cout << "Yay!" << endl;
// }
return 0;
}
| [
"literal.string.change",
"expression.operation.binary.change"
] | 886,315 | 886,314 | u207235471 | cpp |
p03075 | // 123 A
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int a[5];
for (int i = 0; i < 5; i++)
cin >> a[i];
int k;
cin >> k;
string ans;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 4; j++) {
if (a[j] - a[i] > k) {
ans = ":(";
break;
}
}
}
if (ans == ":(")
cout << ans << endl;
else
cout << "Yay!" << endl;
return 0;
} | // 123 A
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int a[5];
for (int i = 0; i < 5; i++)
cin >> a[i];
int k;
cin >> k;
string ans;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (a[j] - a[i] > k) {
ans = ":(";
break;
}
}
}
if (ans == ":(")
cout << ans << endl;
else
cout << "Yay!" << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 886,320 | 886,321 | u448922807 | cpp |
p03075 | // 123 A
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int a[5];
for (int i = 0; i < 5; i++)
cin >> a[i];
int k;
cin >> k;
string ans;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 4; j++) {
if (a[j] - a[i] >= k) {
ans = ":(";
break;
}
}
}
if (ans == ":(")
cout << ans << endl;
else
cout << "Yay!" << endl;
return 0;
} | // 123 A
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <string>
#include <vector>
using namespace std;
int main() {
int a[5];
for (int i = 0; i < 5; i++)
cin >> a[i];
int k;
cin >> k;
string ans;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
if (a[j] - a[i] > k) {
ans = ":(";
break;
}
}
}
if (ans == ":(")
cout << ans << endl;
else
cout << "Yay!" << endl;
return 0;
} | [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 886,322 | 886,321 | u448922807 | cpp |
p03075 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> code;
for (int i = 0; i < 5; i++) {
cin >> code.at(i);
}
int K;
cin >> K;
int dif;
for (int i = 0; i < 4; i++) {
for (int j = 1; j < 5; j++) {
dif = code.at(j) - code.at(i);
if (dif > K) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yay!" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> code(5);
for (int i = 0; i < 5; i++) {
cin >> code.at(i);
}
int K;
cin >> K;
int dif;
for (int i = 0; i < 4; i++) {
for (int j = 1; j < 5; j++) {
dif = code.at(j) - code.at(i);
if (dif > K) {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yay!" << endl;
} | [
"call.arguments.add"
] | 886,323 | 886,324 | u726957641 | cpp |
p03075 | #include <iostream>
using namespace std;
int main(void) {
int f[5], k;
cin >> f[0] >> f[1] >> f[2] >> f[3] >> f[4] >> k;
int max = f[0], min = f[0];
for (int i = 1; i < 5; i++) {
if (max < f[i]) {
max = f[i];
}
if (min > f[i]) {
max = f[i];
}
}
if ((max - min) < k) {
puts("Yay!");
} else {
puts(":(");
}
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
int f[5], k;
cin >> f[0] >> f[1] >> f[2] >> f[3] >> f[4] >> k;
int max = f[0], min = f[0];
for (int i = 1; i < 5; i++) {
if (max < f[i]) {
max = f[i];
}
if (min > f[i]) {
max = f[i];
}
}
if ((max - min) <= k) {
puts("Yay!");
} else {
puts(":(");
}
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 886,325 | 886,326 | u793856757 | cpp |
p03075 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if ((e - a) < k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if ((e - a) > k) {
cout << ":(" << endl;
} else {
cout << "Yay!" << endl;
}
return 0;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"literal.string.change",
"io.output.change"
] | 886,329 | 886,330 | u848339218 | cpp |
p03075 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
int l = e - a;
string ans;
if (l < k)
ans = "Yay!";
else
ans = ":(";
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
int l = e - a;
string ans;
if (l <= k)
ans = "Yay!";
else
ans = ":(";
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 886,336 | 886,337 | u053990350 | cpp |
p03075 | #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
vector<int> bitSearch(int bit, int n) {
vector<int> S;
rep(i, n) if (bit & (1 << i)) S.push_back(i);
return S;
}
int main() {
VEC(int, a, 5);
int k;
cin >> k;
rep(i, 5) {
for (int j = i + 1; j < 5; j++) {
if (abs(a[i] - a[j] > k)) {
cout << ":(";
return 0;
}
}
}
cout << "Yay!";
}
| #include <iostream>
#include <stdio.h>
//#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <float.h>
#include <iomanip>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 1e9
#define rep(i, n) for (int i = 0; (i) < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); (i) <= (int)(b); i++)
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define vec(type, n) vector<type>(n)
#define vvec(m, n) vector<vector<int>>(int(m), vector<int>(n))
#define ALL(a) (a).begin(), (a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
vector<int> bitSearch(int bit, int n) {
vector<int> S;
rep(i, n) if (bit & (1 << i)) S.push_back(i);
return S;
}
int main() {
VEC(int, a, 5);
int k;
cin >> k;
rep(i, 5) {
for (int j = i + 1; j < 5; j++) {
// cout<<abs(a[i]-a[j])<<endl;
if (abs(a[i] - a[j]) > k) {
cout << ":(";
return 0;
}
}
}
cout << "Yay!";
}
| [
"control_flow.branch.if.condition.change"
] | 886,338 | 886,339 | u516525290 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.