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 |
|---|---|---|---|---|---|---|---|
p03013 | // 復習
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9 + 7;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<bool> safe(n + 1, true);
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
safe[a] = false;
}
vector<ll> dp(n + 1);
dp[0] = 1;
dp[1] = safe[1];
for (int i = 2; i <= n; ++i) {
dp[i] = (dp[i - 1] + dp[i - 2]) * safe[i];
}
cout << dp[n] % MOD << endl;
return 0;
} | // 復習
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9 + 7;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<bool> safe(n + 1, true);
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
safe[a] = false;
}
vector<ll> dp(n + 1);
dp[0] = 1;
dp[1] = safe[1];
for (int i = 2; i <= n; ++i) {
dp[i] = (dp[i - 1] % MOD + dp[i - 2] % MOD) * safe[i];
}
cout << dp[n] % MOD << endl;
return 0;
} | [
"assignment.change"
] | 826,409 | 826,410 | u436741428 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
long x = 1000000007;
long n, m;
cin >> n >> m;
vector<bool> a(n + 1);
for (long i = 0; i < m; i++) {
int k;
cin >> k;
a.at(k) = true;
}
vector<long> p(n + 1, 0);
p.at(0) = !a.at(0);
if (n > 1)
p.at(1) = !a.at(1);
for (int i = 2; i < n + 1; i++) {
if (a.at(i))
p.at(i) = 0;
else
p.at(i) = (p.at(i - 1) + p.at(i - 2)) % x;
}
cout << p.at(n) % x << endl;
// for(int i=0;i<n+1;i++) cout<<p.at(i)<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long x = 1000000007;
long n, m;
cin >> n >> m;
vector<bool> a(n + 1);
for (long i = 0; i < m; i++) {
int k;
cin >> k;
a.at(k) = true;
}
vector<long> p(n + 1, 0);
p.at(0) = !a.at(0);
p.at(1) = !a.at(1);
for (int i = 2; i < n + 1; i++) {
if (a.at(i))
p.at(i) = 0;
else
p.at(i) = (p.at(i - 1) + p.at(i - 2)) % x;
}
cout << p.at(n) % x << endl;
// for(int i=0;i<n+1;i++) cout<<p.at(i)<<endl;
}
| [] | 826,443 | 826,444 | u813174766 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define T = 1000000007
using namespace std;
long long *a;
const long long mod = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
a = new long long[n + 2];
a[0] = 1;
a[1] = 1;
for (int i = 1; i < n + 2; i++) {
a[i] = -1;
}
for (int i = 0; i < m; i++) {
long long t;
cin >> t;
a[t] = false;
}
for (int i = 1; i < n + 1; i++) {
if (a[i + 1])
a[i + 1] = (a[i] + a[i - 1]) % mod;
}
cout << a[n] << endl;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define T = 1000000007
using namespace std;
long long *a;
const long long mod = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
a = new long long[n + 1];
a[0] = 1;
a[1] = 1;
for (int i = 2; i < n + 1; i++) {
a[i] = -1;
}
for (int i = 0; i < m; i++) {
long long t;
cin >> t;
a[t] = false;
}
for (int i = 1; i < n; i++) {
if (a[i + 1])
a[i + 1] = (a[i] + a[i - 1]) % mod;
}
cout << a[n] << endl;
} | [
"literal.number.change",
"assignment.value.change",
"expression.operation.binary.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 826,462 | 826,463 | u020230257 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
bool z[100011];
int ans[100011];
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
z[a] = true;
}
z[0] = 1;
z[1] = (int)(!z[1]) * 1;
for (int i = 2; i <= n; i++)
if (!z[i])
ans[i] = (ans[i - 1] + ans[i - 2]) % 1000000007;
cout << ans[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
bool z[100011];
int ans[100011];
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
z[a] = true;
}
ans[0] = 1;
ans[1] = (int)(!z[1]) * 1;
for (int i = 2; i <= n; i++)
if (!z[i])
ans[i] = (ans[i - 1] + ans[i - 2]) % 1000000007;
cout << ans[n] << endl;
return 0;
} | [
"assignment.variable.change",
"identifier.change"
] | 826,466 | 826,467 | u514602572 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
bool z[100011];
int ans[100011];
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
z[a] = true;
}
z[0] = 1;
z[1] = (int)(!z[1]) * 1;
for (int i = 2; i <= n; i++)
if (!z[i])
ans[i] = (ans[i - 1] + ans[i - 2]) % 1000000007;
cout << ans[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
bool z[100011];
int ans[100011];
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
z[a] = true;
}
ans[0] = 1;
ans[1] = (int)(!z[1]) * 1;
for (int i = 2; i <= n; i++)
if (!z[i])
ans[i] = (ans[i - 1] + ans[i - 2]) % 1000000007;
cout << ans[n] << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.variable.change"
] | 826,468 | 826,467 | u514602572 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
ll a[n + 7] = {0};
a[0] = 1;
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int t;
cin >> t;
a[t] = -1;
}
if (a[1] != -1)
a[1] = 1;
else
a[1] = 0;
for (int i = 2; i < n + 1; i++) {
if (a[i] == -1)
a[i] = 0;
else
a[i] = a[i - 1] + a[i - 2];
}
cout << a[n] % 1000000007;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
ll a[n + 7] = {0};
a[0] = 1;
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int t;
cin >> t;
a[t] = -1;
}
if (a[1] != -1)
a[1] = 1;
else
a[1] = 0;
for (int i = 2; i < n + 1; i++) {
if (a[i] == -1)
a[i] = 0;
else
a[i] = (a[i - 1] + a[i - 2]) % 1000000007;
}
cout << a[n] % 1000000007;
return 0;
}
| [
"assignment.change"
] | 826,478 | 826,479 | u466568754 | cpp |
p03013 | #include "bits/stdc++.h"
using namespace std;
#define COUNTOF(array) (sizeof(array) / sizeof(array[0]))
#define OUT(P) cout << (P) << endl
#define OUT2(P1, P2) cout << (P1) << " " << (P2) << endl
#define PRINT_ARRAY(P) \
for (int i = 0; i < P.size(); i++) \
cout << P[i] << endl;
#define PRINT_ARRAY_INLINE(P) \
do { \
for (int i = 0; i < P.size(); i++) \
cout << P[i] << " "; \
cout << endl; \
} while (0)
#define PRINT_ARRAY_WITH_LABEL(L, P) \
do { \
cout << L << ": "; \
PRINT_ARRAY_INLINE(P); \
cout << endl; \
} while (0)
typedef long long ll;
const long DIVIDE = 1e9 + 7;
int sum_digits(int num);
template <class T> vector<T> copy_vector(vector<T> vec);
int gcd(int a, int b);
// ****** print functions ****** //
template <class T, class U> void print_pairs(const vector<pair<T, U>> pairs);
template <class K, class V> void print_map(const map<K, V> m);
int main() {
int n, m;
cin >> n >> m;
vector<long> floors(n + 1, 0);
vector<bool> dropped(n + 1, false);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
dropped[a] = true;
}
floors[1] = (dropped[1]) ? 0 : 1;
if (n >= 2) {
floors[2] = (dropped[2]) ? 0 : floors[1] + 1;
for (int i = 3; i <= n; i++) {
if (dropped[i])
continue;
else {
long one_step = floors[i - 1];
long two_step = floors[i - 2];
floors[i] = one_step + two_step;
}
}
}
// PRINT_ARRAY_INLINE(floors);
cout << floors[n] % DIVIDE << endl;
return 0;
}
/******************************/
/***** DECRARED FUNCTIONS *****/
/******************************/
int sum_digits(int num) {
int rtn = 0;
while (num != 0) {
int tmp = num % 10;
rtn += tmp;
num /= 10;
}
return rtn;
}
// vectorのコピー
template <class T> vector<T> copy_vector(vector<T> vec) {
vector<T> rtn;
rtn.reserve(vec.size());
copy(vec.begin(), vec.end(), back_inserter(rtn));
return rtn;
}
// ユークリウッドの互除法
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
template <class T, class U> void print_pairs(const vector<pair<T, U>> &pairs) {
for (int i = 0; i < pairs.size(); i++) {
cout << "(" << pairs[i].first << ", " << pairs[i].second << ")"
<< " ";
}
cout << endl;
}
template <class K, class V> void print_map(const map<K, V> &m) {
for (auto it = m.cbegin(); it != m.cend(); it++) {
cout << it->first << ": " << it->second << endl;
}
}
| #include "bits/stdc++.h"
using namespace std;
#define COUNTOF(array) (sizeof(array) / sizeof(array[0]))
#define OUT(P) cout << (P) << endl
#define OUT2(P1, P2) cout << (P1) << " " << (P2) << endl
#define PRINT_ARRAY(P) \
for (int i = 0; i < P.size(); i++) \
cout << P[i] << endl;
#define PRINT_ARRAY_INLINE(P) \
do { \
for (int i = 0; i < P.size(); i++) \
cout << P[i] << " "; \
cout << endl; \
} while (0)
#define PRINT_ARRAY_WITH_LABEL(L, P) \
do { \
cout << L << ": "; \
PRINT_ARRAY_INLINE(P); \
cout << endl; \
} while (0)
typedef long long ll;
const long DIVIDE = 1e9 + 7;
int sum_digits(int num);
template <class T> vector<T> copy_vector(vector<T> vec);
int gcd(int a, int b);
// ****** print functions ****** //
template <class T, class U> void print_pairs(const vector<pair<T, U>> pairs);
template <class K, class V> void print_map(const map<K, V> m);
int main() {
int n, m;
cin >> n >> m;
vector<long> floors(n + 1, 0);
vector<bool> dropped(n + 1, false);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
dropped[a] = true;
}
floors[1] = (dropped[1]) ? 0 : 1;
if (n >= 2) {
floors[2] = (dropped[2]) ? 0 : floors[1] + 1;
for (int i = 3; i <= n; i++) {
if (dropped[i])
continue;
else {
long one_step = floors[i - 1];
long two_step = floors[i - 2];
floors[i] = (one_step + two_step) % DIVIDE;
}
}
}
// PRINT_ARRAY_INLINE(floors);
cout << floors[n] % DIVIDE << endl;
return 0;
}
/******************************/
/***** DECRARED FUNCTIONS *****/
/******************************/
int sum_digits(int num) {
int rtn = 0;
while (num != 0) {
int tmp = num % 10;
rtn += tmp;
num /= 10;
}
return rtn;
}
// vectorのコピー
template <class T> vector<T> copy_vector(vector<T> vec) {
vector<T> rtn;
rtn.reserve(vec.size());
copy(vec.begin(), vec.end(), back_inserter(rtn));
return rtn;
}
// ユークリウッドの互除法
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
template <class T, class U> void print_pairs(const vector<pair<T, U>> &pairs) {
for (int i = 0; i < pairs.size(); i++) {
cout << "(" << pairs[i].first << ", " << pairs[i].second << ")"
<< " ";
}
cout << endl;
}
template <class K, class V> void print_map(const map<K, V> &m) {
for (auto it = m.cbegin(); it != m.cend(); it++) {
cout << it->first << ": " << it->second << endl;
}
}
| [
"assignment.change"
] | 826,491 | 826,492 | u026686258 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define PI 3.1415926535897932384626433
#define mod 1000000007
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a * b / gcd(a, b); }
int main() {
int n, m;
cin >> n >> m;
vector<int> a(m, false);
for (int i = 0; i < m; i++) {
int num;
cin >> num;
a[num] = true;
}
vector<int> dp(n + 2, 0);
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (a[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
// cout << dp[i] << endl;
}
cout << dp[0] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define PI 3.1415926535897932384626433
#define mod 1000000007
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a * b / gcd(a, b); }
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n + 1, false);
for (int i = 0; i < m; i++) {
int num;
cin >> num;
a[num] = true;
}
vector<int> dp(n + 2, 0);
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (a[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
// cout << dp[i] << endl;
}
cout << dp[0] << endl;
return 0;
}
| [
"assignment.change"
] | 826,515 | 826,516 | u167755809 | cpp |
p03013 | // dp(n) = dp(n-1) + dp(n-2) で, a の値によって分岐する.
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = (1 << 30) - 1;
const ll MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
// 段数と一致させたいので N+1 個を true で初期化
vector<int> oks(N + 1, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
oks[a] = false;
}
// N-1 段目で dp[i+2] するので, 余分に1個多く初期化
vector<ll> dp(N + 1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
if (!oks[i])
dp[i] = 0;
(dp[i + 1] += dp[i]) %= MOD;
(dp[i + 2] += dp[i]) %= MOD;
}
cout << dp[N] << endl;
return 0;
} | // dp(n) = dp(n-1) + dp(n-2) で, a の値によって分岐する.
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = (1 << 30) - 1;
const ll MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
// 0 ~ N 段目を考えるので N+1
vector<int> oks(N + 1, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
oks[a] = false;
}
vector<ll> dp(N + 2);
dp[0] = 1;
for (int i = 0; i < N; i++) {
if (!oks[i])
dp[i] = 0;
(dp[i + 1] += dp[i]) %= MOD;
(dp[i + 2] += dp[i]) %= MOD;
}
cout << dp[N] << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,521 | 826,522 | u933685059 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORE(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repe(i, n) for (int i = 0; i <= (n); ++i)
#define ALL(v) (v).begin(), (v).end()
#define SP cout << fixed << setprecision(10)
typedef pair<int, int> P;
const int INF = (int)1e9;
const int MOD = (int)1e9 + 7;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> ok(n + 1, true);
rep(i, m) {
int a;
cin >> a;
ok[a] = false;
}
vector<ll> dp(n + 1);
dp[0] = 1;
rep(i, n) {
FORE(j, i + 1, min(n, i + 2)) {
if (ok[j]) {
dp[j] += dp[i];
dp[j] %= MOD;
}
}
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORE(i, a, b) for (int i = (a); i <= (b); ++i)
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repe(i, n) for (int i = 0; i <= (n); ++i)
#define ALL(v) (v).begin(), (v).end()
#define SP cout << fixed << setprecision(10)
typedef pair<int, int> P;
const int INF = (int)1e9;
const ll MOD = (ll)1e9 + 7;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> ok(n + 1, true);
rep(i, m) {
int a;
cin >> a;
ok[a] = false;
}
vector<ll> dp(n + 1);
dp[0] = 1;
rep(i, n) {
FORE(j, i + 1, min(n, i + 2)) {
if (ok[j]) {
dp[j] += dp[i];
dp[j] %= MOD;
}
}
}
cout << dp[n] << endl;
return 0;
} | [
"expression.operator.compare.change",
"preprocessor.define.value.change",
"variable_declaration.type.change",
"expression.operation.binary.change"
] | 826,527 | 826,528 | u995997203 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<bool> broken(n, false);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<ll> fib(n);
int j = 0;
fib[0] = 1;
fib[1] = 1 - broken[1];
for (int i = 2; i <= n; i++) {
fib[i] = broken[i] ? 0 : (fib[i - 1] + fib[i - 2]) % mod;
}
cout << fib[n] << endl;
} | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<bool> broken(n + 1, false);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<ll> fib(n + 1);
int j = 0;
fib[0] = 1;
fib[1] = 1 - broken[1];
for (int i = 2; i <= n; i++) {
fib[i] = broken[i] ? 0 : (fib[i - 1] + fib[i - 2]) % mod;
}
cout << fib[n] << endl;
} | [
"assignment.change"
] | 826,533 | 826,534 | u240685518 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <istream>
#include <random>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <vector>
using namespace std;
typedef long long ll;
ll sum = 0;
int main() {
ll N, M;
ll waru = 1000000007;
cin >> N >> M;
vector<ll> a(N + 1, 0);
ll m = 0;
for (ll i = 0; i < M; i++) {
cin >> m;
a[m] = -1;
}
// vector<vector<ll > > dp(N, vector<ll >(N + 1, -1));
a[0] = 1;
for (ll i = 0; i < N; i++) {
if (a[i] == -1) {
continue;
}
if (a[i + 1] != -1) {
a[i + 1] += a[i];
a[i + 1] %= waru;
}
if (a[i + 2] != -1) {
a[i + 2] += a[i];
a[i + 2] %= waru;
}
}
cout << a[N] << endl;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <istream>
#include <random>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <vector>
using namespace std;
typedef long long ll;
ll sum = 0;
int main() {
ll N, M;
ll waru = 1000000007;
cin >> N >> M;
vector<ll> a(N + 2, 0);
ll m = 0;
for (ll i = 0; i < M; i++) {
cin >> m;
a[m] = -1;
}
// vector<vector<ll > > dp(N, vector<ll >(N + 1, -1));
a[0] = 1;
for (ll i = 0; i < N; i++) {
if (a[i] == -1) {
continue;
}
if (a[i + 1] != -1) {
a[i + 1] += a[i];
a[i + 1] %= waru;
}
if (a[i + 2] != -1) {
a[i + 2] += a[i];
a[i + 2] %= waru;
}
}
cout << a[N] << endl;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,541 | 826,542 | u048791623 | cpp |
p03013 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define ll long long
#define MOD 1000000007
#define INF 1000000000000000000
#define rnd mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
// Read the question carefully and see all the given sample tests
// Think about the correctness before implementing
int main() {
int n, m;
cin >> n >> m;
int a[m];
map<int, int> ma;
ll b[n + 1];
for (int i = 0; i < m; i++) {
cin >> a[i];
ma[a[i]] = 1;
}
b[0] = 0;
if (ma[1] != 1)
b[1] = 1;
else
b[1] = 0;
for (int i = 2; i <= n; i++) {
if (ma[i] == 1)
b[i] = 0;
else
b[i] = (b[i - 1] + b[i - 2]) % MOD;
}
cout << b[n] << "\n";
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define ll long long
#define MOD 1000000007
#define INF 1000000000000000000
#define rnd mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
// Read the question carefully and see all the given sample tests
// Think about the correctness before implementing
int main() {
int n, m;
cin >> n >> m;
int a[m];
map<int, int> ma;
ll b[n + 1];
for (int i = 0; i < m; i++) {
cin >> a[i];
ma[a[i]] = 1;
}
b[0] = 1;
if (ma[1] != 1)
b[1] = 1;
else
b[1] = 0;
for (int i = 2; i <= n; i++) {
if (ma[i] == 1)
b[i] = 0;
else
b[i] = (b[i - 1] + b[i - 2]) % MOD;
}
cout << b[n] << "\n";
}
| [
"literal.number.change",
"assignment.value.change"
] | 826,554 | 826,555 | u702496216 | cpp |
p03013 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define ll long long
#define MOD 1000000007
#define INF 1000000000000000000
#define rnd mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
// Read the question carefully and see all the given sample tests
// Think about the correctness before implementing
int main() {
int n, m;
cin >> n >> m;
int a[m];
map<int, int> ma;
ll b[n + 1];
for (int i = 0; i < m; i++) {
cin >> a[i];
ma[a[i]] = 1;
}
b[0] = 0;
if (ma[1] != 1)
b[1] = 1;
else
b[1] = 0;
for (int i = 3; i <= n; i++) {
if (ma[i] == 1)
b[i] = 0;
else
b[i] = (b[i - 1] + b[i - 2]) % MOD;
}
cout << b[n] << "\n";
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define ll long long
#define MOD 1000000007
#define INF 1000000000000000000
#define rnd mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
// Read the question carefully and see all the given sample tests
// Think about the correctness before implementing
int main() {
int n, m;
cin >> n >> m;
int a[m];
map<int, int> ma;
ll b[n + 1];
for (int i = 0; i < m; i++) {
cin >> a[i];
ma[a[i]] = 1;
}
b[0] = 1;
if (ma[1] != 1)
b[1] = 1;
else
b[1] = 0;
for (int i = 2; i <= n; i++) {
if (ma[i] == 1)
b[i] = 0;
else
b[i] = (b[i - 1] + b[i - 2]) % MOD;
}
cout << b[n] << "\n";
}
| [
"literal.number.change",
"assignment.value.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 826,556 | 826,555 | u702496216 | cpp |
p03013 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define ll long long
#define MOD 1000000007
#define INF 1000000000000000000
#define rnd mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
// Read the question carefully and see all the given sample tests
// Think about the correctness before implementing
int main() {
int n, m;
cin >> n >> m;
int a[m];
map<int, int> ma;
int b[n + 1];
for (int i = 0; i < m; i++) {
cin >> a[i];
ma[a[i]] = 1;
}
b[0] = 0;
if (ma[1] != 1)
b[1] = 1;
else
b[1] = 0;
for (int i = 3; i <= n; i++) {
if (ma[i] == 1)
b[i] = 0;
else
b[i] = (b[i - 1] + b[i - 2]) % MOD;
}
cout << b[n] << "\n";
}
| #include <algorithm>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <vector>
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define ll long long
#define MOD 1000000007
#define INF 1000000000000000000
#define rnd mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
using namespace std;
// Read the question carefully and see all the given sample tests
// Think about the correctness before implementing
int main() {
int n, m;
cin >> n >> m;
int a[m];
map<int, int> ma;
ll b[n + 1];
for (int i = 0; i < m; i++) {
cin >> a[i];
ma[a[i]] = 1;
}
b[0] = 1;
if (ma[1] != 1)
b[1] = 1;
else
b[1] = 0;
for (int i = 2; i <= n; i++) {
if (ma[i] == 1)
b[i] = 0;
else
b[i] = (b[i - 1] + b[i - 2]) % MOD;
}
cout << b[n] << "\n";
}
| [
"variable_declaration.type.change",
"literal.number.change",
"assignment.value.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 826,557 | 826,555 | u702496216 | cpp |
p03013 | #include "bits/stdc++.h"
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> check(N + 1, true);
for (int i = 0; i < N; i++) {
int a;
cin >> a;
check[a] = false;
}
vector<long long int> dp(N + 1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j <= min(N, i + 2); j++) {
if (check[j]) {
dp[j] += dp[i];
dp[j] %= mod;
}
}
}
cout << dp[N] << endl;
} | #include "bits/stdc++.h"
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> check(N + 1, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
check[a] = false;
}
vector<long long int> dp(N + 1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j <= min(N, i + 2); j++) {
if (check[j]) {
dp[j] += dp[i];
dp[j] %= mod;
}
}
}
cout << dp[N] << endl;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 826,574 | 826,575 | u887207211 | cpp |
p03013 | using namespace std;
#include <bits/stdc++.h>
#define rep(i, s) for (int i = 0; i < s; ++i)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define all(v) (v.begin(), v.end())
#define EACH(i, s) \
for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
#define VEC(a, n) vector<int> a(n)
#define PQ(a) priority_queue<int> a
#define PQmin(a) priority_queue<int, : vector<int>, greater<int>> a
#define PAIR pair<int, int>
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
#define EPS (1e-7)
#define INF (1e10)
#define PI (acos(-1))
const ll mod = 1000000007;
bool f(string s) {
bool ans = true;
rep(i, s.size() / 2) {
if (s[i] != s[s.size() / 2 + i]) {
ans = false;
break;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
vector<bool> oks(N + 1, true);
rep(i, M) {
int a;
cin >> a;
oks[a] = false;
}
vector<ll> dp(N + 1);
dp[0] = 1;
rep(now, N) {
FOR(next, now + 1, min(N, now + 2)) {
if (oks[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| using namespace std;
#include <bits/stdc++.h>
#define rep(i, s) for (int i = 0; i < s; ++i)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define all(v) (v.begin(), v.end())
#define EACH(i, s) \
for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
#define VEC(a, n) vector<int> a(n)
#define PQ(a) priority_queue<int> a
#define PQmin(a) priority_queue<int, : vector<int>, greater<int>> a
#define PAIR pair<int, int>
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
#define EPS (1e-7)
#define INF (1e10)
#define PI (acos(-1))
const ll mod = 1000000007;
bool f(string s) {
bool ans = true;
rep(i, s.size() / 2) {
if (s[i] != s[s.size() / 2 + i]) {
ans = false;
break;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
vector<bool> oks(N + 1, true);
rep(i, M) {
int a;
cin >> a;
oks[a] = false;
}
vector<ll> dp(N + 1);
dp[0] = 1;
rep(now, N) {
FOR(next, now + 1, min(N, now + 2) + 1) {
if (oks[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| [
"expression.operation.binary.add"
] | 826,577 | 826,578 | u535810324 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
const long long MOD = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<bool> b(n, true);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
b[a] = false;
}
vector<long long> dp(n + 1, 0);
dp[0] = 1;
for (int i = 0; i < n; i++) {
if (b[i + 1])
(dp[i + 1] += dp[i]) % MOD;
if (b[i + 2] && i < n - 1)
(dp[i + 2] += dp[i]) % MOD;
}
cout << dp[n] % MOD << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
const long long MOD = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<bool> b(n, true);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
b[a] = false;
}
vector<long long> dp(n + 1, 0);
dp[0] = 1;
for (int i = 0; i < n; i++) {
if (b[i + 1])
(dp[i + 1] += dp[i]) %= MOD;
if (b[i + 2] && i < n - 1)
(dp[i + 2] += dp[i]) %= MOD;
}
cout << dp[n] % MOD << endl;
return 0;
} | [
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change"
] | 826,605 | 826,606 | u513736711 | cpp |
p03013 | #define _GLIBCXX_DEBUG
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define ALL(v) (v).begin(), (v).end()
const int mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> a(N, true);
for (int i = 0; i < M; i++) {
int t;
cin >> t;
a[t] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
if (a[1])
dp[1] = 1;
for (int i = 2; i <= N; i++) {
if (a[i]) {
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= mod;
}
}
cout << dp[N] << endl;
return 0;
}
| #define _GLIBCXX_DEBUG
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define ALL(v) (v).begin(), (v).end()
const int mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> a(N + 1, true);
for (int i = 0; i < M; i++) {
int t;
cin >> t;
a[t] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
if (a[1])
dp[1] = 1;
for (int i = 2; i <= N; i++) {
if (a[i]) {
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= mod;
}
}
cout << dp[N] << endl;
return 0;
}
| [
"assignment.change"
] | 826,610 | 826,611 | u547844563 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
static const int mod = 1e+7;
static const long long INF = 1LL << 60;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> a(N + 1, true); //壊れている床
rep(i, M) {
int num;
cin >> num;
a[num] = false;
}
vector<long long int> dp(N + 1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j <= min(N, i + 2); j++) {
if (a[j]) {
dp[j] += dp[i];
dp[j] %= mod;
}
}
}
cout << dp[N] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
static const int mod = 1e9 + 7;
static const long long INF = 1LL << 60;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> a(N + 1, true); //壊れている床
rep(i, M) {
int num;
cin >> num;
a[num] = false;
}
vector<long long int> dp(N + 1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j <= min(N, i + 2); j++) {
if (a[j]) {
dp[j] += dp[i];
dp[j] %= mod;
}
}
}
cout << dp[N] << endl;
}
| [
"literal.number.change"
] | 826,635 | 826,636 | u747087681 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
long long md = 1000000007;
int main() {
int n;
int m;
cin >> n >> m;
vector<int> a(n + 1, 0);
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = -1;
}
vector<long long> dp(n + 1);
dp[0] = 1;
if (a[1] == -1)
dp[1] = 0;
else
dp[1] = 1;
for (int i = 1; i <= n; i++) {
if (a[i] == -1) {
dp[i] = 0;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % md;
}
}
cout << dp[n];
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
long long md = 1000000007;
int main() {
int n;
int m;
cin >> n >> m;
vector<int> a(n + 1, 0);
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = -1;
}
vector<long long> dp(n + 1);
dp[0] = 1;
if (a[1] == -1)
dp[1] = 0;
else
dp[1] = 1;
for (int i = 2; i <= n; i++) {
if (a[i] == -1) {
dp[i] = 0;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % md;
}
}
cout << dp[n];
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 826,637 | 826,638 | u435266469 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i >= 0; i--)
#define all(v) v.begin(), v.end()
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> broken(N, 0);
rep(i, M) {
int x;
cin >> x;
broken[x] = 1;
}
vector<ll> dp(N + 1);
dp[0] = 1;
if (broken[1] == 1) {
dp[1] = 0;
} else {
dp[1] = 1;
}
for (int i = 2; i < N + 1; i++) {
if (broken[i] == 1) {
dp[i] = 0;
} else {
dp[i] = dp[i - 1] + dp[i - 2];
}
}
cout << dp[N] % 1000000007 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i >= 0; i--)
#define all(v) v.begin(), v.end()
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> broken(N, 0);
rep(i, M) {
int x;
cin >> x;
broken[x] = 1;
}
vector<ll> dp(N + 1);
dp[0] = 1;
if (broken[1] == 1) {
dp[1] = 0;
} else {
dp[1] = 1;
}
for (int i = 2; i < N + 1; i++) {
if (broken[i] == 1) {
dp[i] = 0;
} else {
dp[i] = dp[i - 1] % 1000000007 + dp[i - 2] % 1000000007;
}
}
cout << dp[N] % 1000000007 << endl;
} | [
"assignment.change"
] | 826,652 | 826,653 | u356539385 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<vector<ll>> VV;
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define rep(i, n) REP(i, 0, n)
const int INF = 1e9;
const int MOD = 1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define ALL(v) v.begin(), v.end()
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define Each(a, b) for (auto &a : b)
#define REPM(i, mp) for (auto i = mp.begin(); i != mp.end(); ++i)
#define dbgmap(mp) \
for (auto i = mp.begin(); i != mp.end(); ++i) { \
cout << i->first << ":" << i->second << endl; \
}
#define sum(v) accumulate(ALL(v), 0)
#define fi first
#define se second
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i];
if (i < len - 1)
s << " ";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
Vec way(n + 1, 0);
Vec brk(m + 1, 0);
rep(i, m) {
ll tmp;
cin >> tmp;
brk[tmp] = 1;
}
ll ans = 0;
way[0] = 1;
if (brk[1] == 1) {
way[1] = 0;
} else {
way[1] = 1;
}
REP(i, 2, n + 1) {
if (brk[i] == 1) {
way[i] = 0;
} else {
way[i] = way[i - 1] + way[i - 2];
way[i] %= MOD;
}
}
ans = way[n];
// dbg(way);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<vector<ll>> VV;
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define rep(i, n) REP(i, 0, n)
const int INF = 1e9;
const int MOD = 1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define ALL(v) v.begin(), v.end()
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define Each(a, b) for (auto &a : b)
#define REPM(i, mp) for (auto i = mp.begin(); i != mp.end(); ++i)
#define dbgmap(mp) \
for (auto i = mp.begin(); i != mp.end(); ++i) { \
cout << i->first << ":" << i->second << endl; \
}
#define sum(v) accumulate(ALL(v), 0)
#define fi first
#define se second
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i];
if (i < len - 1)
s << " ";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
Vec way(n + 1, 0);
Vec brk(100005, 0);
rep(i, m) {
ll tmp;
cin >> tmp;
brk[tmp] = 1;
}
ll ans = 0;
way[0] = 1;
if (brk[1] == 1) {
way[1] = 0;
} else {
way[1] = 1;
}
REP(i, 2, n + 1) {
if (brk[i] == 1) {
way[i] = 0;
} else {
way[i] = way[i - 1] + way[i - 2];
way[i] %= MOD;
}
}
ans = way[n];
// dbg(way);
cout << ans << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 826,659 | 826,660 | u592686932 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<vector<ll>> VV;
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define rep(i, n) REP(i, 0, n)
const int INF = 1e9;
const int MOD = 1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define ALL(v) v.begin(), v.end()
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define Each(a, b) for (auto &a : b)
#define REPM(i, mp) for (auto i = mp.begin(); i != mp.end(); ++i)
#define dbgmap(mp) \
for (auto i = mp.begin(); i != mp.end(); ++i) { \
cout << i->first << ":" << i->second << endl; \
}
#define sum(v) accumulate(ALL(v), 0)
#define fi first
#define se second
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i];
if (i < len - 1)
s << " ";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
Vec way(n + 1, 0);
Vec brk(m + 1, 0);
rep(i, m) {
int tmp;
cin >> tmp;
brk[tmp] = 1;
}
ll ans = 0;
way[0] = 1;
if (brk[1] == 1) {
way[1] = 0;
} else {
way[1] = 1;
}
REP(i, 2, n + 1) {
if (brk[i] == 1) {
way[i] = 0;
} else {
way[i] = way[i - 1] + way[i - 2];
way[i] %= MOD;
}
}
ans = way[n];
// dbg(way);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<vector<ll>> VV;
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define rep(i, n) REP(i, 0, n)
const int INF = 1e9;
const int MOD = 1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define ALL(v) v.begin(), v.end()
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a, b)
#define Each(a, b) for (auto &a : b)
#define REPM(i, mp) for (auto i = mp.begin(); i != mp.end(); ++i)
#define dbgmap(mp) \
for (auto i = mp.begin(); i != mp.end(); ++i) { \
cout << i->first << ":" << i->second << endl; \
}
#define sum(v) accumulate(ALL(v), 0)
#define fi first
#define se second
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
// vector
template <typename T> ostream &operator<<(ostream &s, const vector<T> &v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i];
if (i < len - 1)
s << " ";
}
return s;
}
// 2 dimentional vector
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
Vec way(n + 1, 0);
Vec brk(100005, 0);
rep(i, m) {
ll tmp;
cin >> tmp;
brk[tmp] = 1;
}
ll ans = 0;
way[0] = 1;
if (brk[1] == 1) {
way[1] = 0;
} else {
way[1] = 1;
}
REP(i, 2, n + 1) {
if (brk[i] == 1) {
way[i] = 0;
} else {
way[i] = way[i - 1] + way[i - 2];
way[i] %= MOD;
}
}
ans = way[n];
// dbg(way);
cout << ans << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove",
"variable_declaration.type.change"
] | 826,661 | 826,660 | u592686932 | cpp |
p03013 | #include <algorithm>
#include <assert.h>
#include <complex>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define X first
#define Y second
#define pb(x) push_back(x)
#define FOR(k, n) for (int k = 0; k < n; k++)
#define FORN(k, s, n) for (int k = s; k < n; k++)
#define debug(x) printf("x = %d\n", x);
#define debug2(x, y) printf("x = %d, y = %d\n", x, y);
#define debug3(x, y, z) printf("x = %d, y = %d, z = %d\n", x, y, z);
#define debug4(x, y, z, t) \
printf("x = %d, y = %d, z = %d, t = %d\n", x, y, z, t);
#pragma warning(disable : 6031)
#pragma warning(disable : 4101)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef long double ld;
typedef complex<double> cd;
const int INF = 1e9;
const long long LINF = 1e18;
const double PI = acos(-1);
// Solution
const int MAXN = 1000005;
const ll MOD = 1000000007ll;
ll n, m, x, A[MAXN], DP[MAXN];
int main() {
scanf("%lld%lld", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%lld", &x);
A[x] = 1;
}
if (n > 1 && !A[n - 1]) {
DP[n - 1] = 1;
}
if (n > 2 && !A[n - 2]) {
DP[n - 2] = 1 + DP[n - 1];
}
for (int i = n - 3; i >= 0; i--) {
if (!A[i]) {
DP[i] = (DP[i + 1] + DP[i + 2]) % MOD;
}
}
printf("%lld\n", DP[0]);
return 0;
} | #include <algorithm>
#include <assert.h>
#include <complex>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define X first
#define Y second
#define pb(x) push_back(x)
#define FOR(k, n) for (int k = 0; k < n; k++)
#define FORN(k, s, n) for (int k = s; k < n; k++)
#define debug(x) printf("x = %d\n", x);
#define debug2(x, y) printf("x = %d, y = %d\n", x, y);
#define debug3(x, y, z) printf("x = %d, y = %d, z = %d\n", x, y, z);
#define debug4(x, y, z, t) \
printf("x = %d, y = %d, z = %d, t = %d\n", x, y, z, t);
#pragma warning(disable : 6031)
#pragma warning(disable : 4101)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef long double ld;
typedef complex<double> cd;
const int INF = 1e9;
const long long LINF = 1e18;
const double PI = acos(-1);
// Solution
const int MAXN = 1000005;
const ll MOD = 1000000007ll;
ll n, m, x, A[MAXN], DP[MAXN];
int main() {
scanf("%lld%lld", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%lld", &x);
A[x] = 1;
}
if (n >= 1 && !A[n - 1]) {
DP[n - 1] = 1;
}
if (n >= 2 && !A[n - 2]) {
DP[n - 2] = 1 + DP[n - 1];
}
for (int i = n - 3; i >= 0; i--) {
if (!A[i]) {
DP[i] = (DP[i + 1] + DP[i + 2]) % MOD;
}
}
printf("%lld\n", DP[0]);
return 0;
} | [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 826,670 | 826,671 | u018828540 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
const int mod = 1000000007;
vector<int> dp(n + 2);
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = dp[i + 1] + dp[i + 2] % mod;
}
cout << dp[0] << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
const int mod = 1000000007;
vector<int> dp(n + 2);
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| [] | 826,680 | 826,681 | u765789766 | cpp |
p03013 | #include <algorithm>
#include <cassert>
#include <cstdint>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
#ifdef DEBUG
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#define REP(i, n) for (LL i = 0, i##_len = (n); i < i##_len; ++i)
LL gcd(LL a, LL b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
template <LL MOD = 1000000007> class MODLL {
public:
LL x;
MODLL(const LL _x) : x(_x % MOD){};
MODLL operator+(const MODLL rhs) const { return MODLL(*this) += rhs; }
MODLL operator-(const MODLL rhs) const { return MODLL(*this) -= rhs; }
MODLL operator*(const MODLL rhs) const { return MODLL(*this) *= rhs; }
MODLL operator/(const MODLL rhs) const { return MODLL(*this) /= rhs; }
MODLL &operator+=(const MODLL rhs) {
x += rhs.x;
x %= MOD;
return *this;
}
MODLL &operator-=(const MODLL rhs) {
x -= rhs.x;
x %= MOD;
if (x < 0)
x += MOD;
return *this;
}
MODLL &operator*=(const MODLL rhs) {
x *= rhs.x;
x %= MOD;
return *this;
}
MODLL inv() const {
if (x == 0) {
throw "does not have inverse";
}
LL a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
return MODLL(u);
}
MODLL &operator/=(const MODLL rhs) {
(*this) *= rhs.inv();
return *this;
}
MODLL pow(ULL n) const {
MODLL res = 1;
MODLL a = x;
while (n > 0) {
if (n & 1)
res *= a;
a = a * a;
n >>= 1;
}
return res;
}
};
typedef MODLL<> ML;
void test() {
{
ML x = 3;
assert(x.pow(45).x == 644897553);
}
{
for (int i = 1; i < 13; i++) {
MODLL<13> x = i;
assert((x.inv().x * i) % 13 == 1);
}
}
}
int main() {
LL N, M;
std::cin >> N >> M;
std::vector<int> H(N, 0);
for (LL i = 0; i < M; i++) {
int a;
cin >> a;
H[a] = 1;
}
std::vector<ML> dp(N + 1, 0);
dp[N] = 1;
for (int i = N - 1; i >= 0; i--) {
if (H[i]) {
dp[i] = 0;
continue;
}
dp[i] = dp[i + 1] + dp[i + 2];
}
std::cout << dp[0].x << std::endl;
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cstdint>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
#ifdef DEBUG
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#define REP(i, n) for (LL i = 0, i##_len = (n); i < i##_len; ++i)
LL gcd(LL a, LL b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
template <LL MOD = 1000000007> class MODLL {
public:
LL x;
MODLL(const LL _x) : x(_x % MOD){};
MODLL operator+(const MODLL rhs) const { return MODLL(*this) += rhs; }
MODLL operator-(const MODLL rhs) const { return MODLL(*this) -= rhs; }
MODLL operator*(const MODLL rhs) const { return MODLL(*this) *= rhs; }
MODLL operator/(const MODLL rhs) const { return MODLL(*this) /= rhs; }
MODLL &operator+=(const MODLL rhs) {
x += rhs.x;
x %= MOD;
return *this;
}
MODLL &operator-=(const MODLL rhs) {
x -= rhs.x;
x %= MOD;
if (x < 0)
x += MOD;
return *this;
}
MODLL &operator*=(const MODLL rhs) {
x *= rhs.x;
x %= MOD;
return *this;
}
MODLL inv() const {
if (x == 0) {
throw "does not have inverse";
}
LL a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0)
u += MOD;
return MODLL(u);
}
MODLL &operator/=(const MODLL rhs) {
(*this) *= rhs.inv();
return *this;
}
MODLL pow(ULL n) const {
MODLL res = 1;
MODLL a = x;
while (n > 0) {
if (n & 1)
res *= a;
a = a * a;
n >>= 1;
}
return res;
}
};
typedef MODLL<> ML;
void test() {
{
ML x = 3;
assert(x.pow(45).x == 644897553);
}
{
for (int i = 1; i < 13; i++) {
MODLL<13> x = i;
assert((x.inv().x * i) % 13 == 1);
}
}
}
int main() {
LL N, M;
std::cin >> N >> M;
std::vector<int> H(N, 0);
for (LL i = 0; i < M; i++) {
LL a;
cin >> a;
H[a] = 1;
}
std::vector<ML> dp(N + 2, 0);
dp[N] = 1;
for (LL i = N - 1; i >= 0; i--) {
if (H[i]) {
dp[i] = 0;
continue;
}
dp[i] = dp[i + 1] + dp[i + 2];
}
std::cout << dp[0].x << std::endl;
return 0;
}
| [
"variable_declaration.type.change",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.for.initializer.change"
] | 826,691 | 826,692 | u842192201 | cpp |
p03013 | /*
オーダー
10**6 余裕を持って間に合う
10**7 おそらく間に合う 余裕を持って間に合う
10**8 非常にシンプルな処理でない限り厳しい おそらく間に合う
10**9 非常にシンプルな処理でない限り厳しい
logn :OK
n :10^7
nlogn :10^6
n**2 :10^4
n**3 :300
2**n :20
n! :10
// 各桁の和を計算する関数
int findSumOfDigits(int n) {
int sum = 0;
while (n > 0) { // n が 0 になるまで
sum += n % 10;
n /= 10;
}
return sum;
}
sort(a, a + N, greater<int>()); // a[0:N] を大きい順にソート
int num[110] = {0}; // バケット
for (int i = 0; i < N; ++i) {
num[d[i]]++; // d[i] が 1 個増える
}
map<string, int> mp; // 連想配列 map<キー型, 値型> オブジェクト名
for (int i = 0; i < N; ++i) {
auto itr = mp.find(s[i]); // s[i] が設定されているか？
if(itr != mp.end() ) {
mp[s[i]] += 1;
}
else {
mp[s[i]] += 1 ;
}
}
stack<int> s; //intをデータとするスタックを用意
s.push(1); //{} -> {1}
printf("%d\n", s.top()); // 3
s.pop();
queue<int> que; //intをデータとするキューを用意
que.push(1); //{} -> {1}
printf("%d\n", que.front()); // 1
que.pop();
*/
#include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
// #define for(i,a,b) for (int i=(a);i<(b);++i)
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i, n) for (long long i = 0; i < (long long)(n); i++)
#define pb push_back // vectorに要素追加
#define INF (ll)1e18
// int
// // 各桁の和を計算する関数
// int findSumOfDigits(int n) {
// int amari = 0;
// int keta = 0;
// while (n > 0) { // n が 0 になるまで
// amari += n % 2;
// if (keta%2==0)
// n /= 10;
// }
// return sum;
// }
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
const ll MAX_N = 1e5;
ll N, M;
ll a[MAX_N + 1] = {0};
ll dp[MAX_N + 1]; // メモ化テーブル
ll n_div = 1e9 + 7;
// i番目以降の品物から重さの総和がj以下になるように選ぶ
void rec(ll i) {
if (i == 0)
dp[i] = 1;
else if (a[i] == 1)
dp[i] = 0;
else if (a[i] == 0 & i == 1)
dp[i] = 1;
else
dp[i] = dp[i - 2] + dp[i - 1];
dp[i] %= n_div;
return;
}
int main() {
// 入力
cin >> N >> M;
for (ll i = 0; i < N; ++i) {
ll tmp;
cin >> tmp;
a[tmp] = 1;
}
// 解法
// DP
memset(dp, -1, sizeof(dp));
REP(i, N + 1) rec(i);
//出力
// REP(i,N+1)printf("%lld\n", dp[i]);
cout << dp[N] << endl;
}
| /*
オーダー
10**6 余裕を持って間に合う
10**7 おそらく間に合う 余裕を持って間に合う
10**8 非常にシンプルな処理でない限り厳しい おそらく間に合う
10**9 非常にシンプルな処理でない限り厳しい
logn :OK
n :10^7
nlogn :10^6
n**2 :10^4
n**3 :300
2**n :20
n! :10
// 各桁の和を計算する関数
int findSumOfDigits(int n) {
int sum = 0;
while (n > 0) { // n が 0 になるまで
sum += n % 10;
n /= 10;
}
return sum;
}
sort(a, a + N, greater<int>()); // a[0:N] を大きい順にソート
int num[110] = {0}; // バケット
for (int i = 0; i < N; ++i) {
num[d[i]]++; // d[i] が 1 個増える
}
map<string, int> mp; // 連想配列 map<キー型, 値型> オブジェクト名
for (int i = 0; i < N; ++i) {
auto itr = mp.find(s[i]); // s[i] が設定されているか？
if(itr != mp.end() ) {
mp[s[i]] += 1;
}
else {
mp[s[i]] += 1 ;
}
}
stack<int> s; //intをデータとするスタックを用意
s.push(1); //{} -> {1}
printf("%d\n", s.top()); // 3
s.pop();
queue<int> que; //intをデータとするキューを用意
que.push(1); //{} -> {1}
printf("%d\n", que.front()); // 1
que.pop();
*/
#include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
// #define for(i,a,b) for (int i=(a);i<(b);++i)
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i, n) for (long long i = 0; i < (long long)(n); i++)
#define pb push_back // vectorに要素追加
#define INF (ll)1e18
// int
// // 各桁の和を計算する関数
// int findSumOfDigits(int n) {
// int amari = 0;
// int keta = 0;
// while (n > 0) { // n が 0 になるまで
// amari += n % 2;
// if (keta%2==0)
// n /= 10;
// }
// return sum;
// }
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
const ll MAX_N = 1e5;
ll N, M;
ll a[MAX_N + 1] = {0};
ll dp[MAX_N + 1]; // メモ化テーブル
ll n_div = 1e9 + 7;
// i番目以降の品物から重さの総和がj以下になるように選ぶ
void rec(ll i) {
if (i == 0)
dp[i] = 1;
else if (a[i] == 1)
dp[i] = 0;
else if (a[i] == 0 & i == 1)
dp[i] = 1;
else
dp[i] = dp[i - 2] + dp[i - 1];
dp[i] %= n_div;
return;
}
int main() {
// 入力
cin >> N >> M;
for (ll i = 0; i < M; ++i) {
ll tmp;
cin >> tmp;
a[tmp] = 1;
}
// 解法
// DP
memset(dp, -1, sizeof(dp));
REP(i, N + 1) rec(i);
//出力
// REP(i,N+1)printf("%lld\n", dp[i]);
cout << dp[N] << endl;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 826,711 | 826,712 | u757738907 | cpp |
p03013 | /*
オーダー
10**6 余裕を持って間に合う
10**7 おそらく間に合う 余裕を持って間に合う
10**8 非常にシンプルな処理でない限り厳しい おそらく間に合う
10**9 非常にシンプルな処理でない限り厳しい
logn :OK
n :10^7
nlogn :10^6
n**2 :10^4
n**3 :300
2**n :20
n! :10
// 各桁の和を計算する関数
int findSumOfDigits(int n) {
int sum = 0;
while (n > 0) { // n が 0 になるまで
sum += n % 10;
n /= 10;
}
return sum;
}
sort(a, a + N, greater<int>()); // a[0:N] を大きい順にソート
int num[110] = {0}; // バケット
for (int i = 0; i < N; ++i) {
num[d[i]]++; // d[i] が 1 個増える
}
map<string, int> mp; // 連想配列 map<キー型, 値型> オブジェクト名
for (int i = 0; i < N; ++i) {
auto itr = mp.find(s[i]); // s[i] が設定されているか？
if(itr != mp.end() ) {
mp[s[i]] += 1;
}
else {
mp[s[i]] += 1 ;
}
}
stack<int> s; //intをデータとするスタックを用意
s.push(1); //{} -> {1}
printf("%d\n", s.top()); // 3
s.pop();
queue<int> que; //intをデータとするキューを用意
que.push(1); //{} -> {1}
printf("%d\n", que.front()); // 1
que.pop();
*/
#include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
// #define for(i,a,b) for (int i=(a);i<(b);++i)
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i, n) for (long long i = 0; i < (long long)(n); i++)
#define pb push_back // vectorに要素追加
#define INF (ll)1e18
// int
// // 各桁の和を計算する関数
// int findSumOfDigits(int n) {
// int amari = 0;
// int keta = 0;
// while (n > 0) { // n が 0 になるまで
// amari += n % 2;
// if (keta%2==0)
// n /= 10;
// }
// return sum;
// }
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
const ll MAX_N = 1e5;
ll N, M;
ll a[MAX_N + 1];
ll dp[MAX_N + 1]; // メモ化テーブル
ll n_div = 1e9 + 7;
// i番目以降の品物から重さの総和がj以下になるように選ぶ
void rec(ll i) {
if (i == 0)
dp[i] = 1;
else if (a[i] == 1)
dp[i] = 0;
else if (a[i] == 0 & i == 1)
dp[i] = 1;
else
dp[i] = dp[i - 2] + dp[i - 1];
dp[i] %= n_div;
return;
}
int main() {
// 入力
cin >> N >> M;
for (ll i = 0; i < N; ++i) {
ll tmp;
cin >> tmp;
a[tmp] = 1;
}
// 解法
// DP
memset(dp, -1, sizeof(dp));
REP(i, N + 1) rec(i);
//出力
// REP(i,N+1)printf("%lld\n", dp[i]);
cout << dp[N] << endl;
}
| /*
オーダー
10**6 余裕を持って間に合う
10**7 おそらく間に合う 余裕を持って間に合う
10**8 非常にシンプルな処理でない限り厳しい おそらく間に合う
10**9 非常にシンプルな処理でない限り厳しい
logn :OK
n :10^7
nlogn :10^6
n**2 :10^4
n**3 :300
2**n :20
n! :10
// 各桁の和を計算する関数
int findSumOfDigits(int n) {
int sum = 0;
while (n > 0) { // n が 0 になるまで
sum += n % 10;
n /= 10;
}
return sum;
}
sort(a, a + N, greater<int>()); // a[0:N] を大きい順にソート
int num[110] = {0}; // バケット
for (int i = 0; i < N; ++i) {
num[d[i]]++; // d[i] が 1 個増える
}
map<string, int> mp; // 連想配列 map<キー型, 値型> オブジェクト名
for (int i = 0; i < N; ++i) {
auto itr = mp.find(s[i]); // s[i] が設定されているか？
if(itr != mp.end() ) {
mp[s[i]] += 1;
}
else {
mp[s[i]] += 1 ;
}
}
stack<int> s; //intをデータとするスタックを用意
s.push(1); //{} -> {1}
printf("%d\n", s.top()); // 3
s.pop();
queue<int> que; //intをデータとするキューを用意
que.push(1); //{} -> {1}
printf("%d\n", que.front()); // 1
que.pop();
*/
#include <algorithm>
#include <bitset>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
// #define for(i,a,b) for (int i=(a);i<(b);++i)
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i, n) for (long long i = 0; i < (long long)(n); i++)
#define pb push_back // vectorに要素追加
#define INF (ll)1e18
// int
// // 各桁の和を計算する関数
// int findSumOfDigits(int n) {
// int amari = 0;
// int keta = 0;
// while (n > 0) { // n が 0 になるまで
// amari += n % 2;
// if (keta%2==0)
// n /= 10;
// }
// return sum;
// }
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
const ll MAX_N = 1e5;
ll N, M;
ll a[MAX_N + 1] = {0};
ll dp[MAX_N + 1]; // メモ化テーブル
ll n_div = 1e9 + 7;
// i番目以降の品物から重さの総和がj以下になるように選ぶ
void rec(ll i) {
if (i == 0)
dp[i] = 1;
else if (a[i] == 1)
dp[i] = 0;
else if (a[i] == 0 & i == 1)
dp[i] = 1;
else
dp[i] = dp[i - 2] + dp[i - 1];
dp[i] %= n_div;
return;
}
int main() {
// 入力
cin >> N >> M;
for (ll i = 0; i < M; ++i) {
ll tmp;
cin >> tmp;
a[tmp] = 1;
}
// 解法
// DP
memset(dp, -1, sizeof(dp));
REP(i, N + 1) rec(i);
//出力
// REP(i,N+1)printf("%lld\n", dp[i]);
cout << dp[N] << endl;
}
| [
"variable_declaration.value.change",
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 826,713 | 826,712 | u757738907 | cpp |
p03013 | /*input
9
*/
#include <bits/stdc++.h>
#define ll long long int
#define ull unsigned long long
#define mod 1000000007
#define inf 1000000000000000001
#define all(c) c.begin(), c.end()
#define mem(a, val) memset(a, val, sizeof(a))
#define eb emplace_back
#define sz(a) int((a).size())
#define pb push_back
#define tr(c, i) for(typeof((c).begin() i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define rep(i, j, n) for (ll i = j; i < n; i++)
#define mp make_pair
#define N 998244353
#define PI acos(-1.0)
// if (s.find('R') != std::string::npos)
// s.replace(s.find("10"), sizeof("10") - 1, "");
using namespace std;
int main() {
// added the two lines below
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
ll x, n;
cin >> x >> n;
map<ll, ll> m;
for (int i = 0; i < n; i++) {
ll k;
cin >> k;
m[k] = 1;
}
ll dp[x + 1];
dp[0] = 1;
if (m[1])
dp[1] = 0;
else
dp[1] = 0;
for (int i = 2; i <= x; i++) {
if (m[i])
dp[i] = 0;
else {
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] = dp[i] % 1000000007;
;
}
// cout<<dp[i]<<' ';
}
cout << dp[x];
} | /*input
9
*/
#include <bits/stdc++.h>
#define ll long long int
#define ull unsigned long long
#define mod 1000000007
#define inf 1000000000000000001
#define all(c) c.begin(), c.end()
#define mem(a, val) memset(a, val, sizeof(a))
#define eb emplace_back
#define sz(a) int((a).size())
#define pb push_back
#define tr(c, i) for(typeof((c).begin() i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define rep(i, j, n) for (ll i = j; i < n; i++)
#define mp make_pair
#define N 998244353
#define PI acos(-1.0)
// if (s.find('R') != std::string::npos)
// s.replace(s.find("10"), sizeof("10") - 1, "");
using namespace std;
int main() {
// added the two lines below
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
ll x, n;
cin >> x >> n;
map<ll, ll> m;
for (int i = 0; i < n; i++) {
ll k;
cin >> k;
m[k] = 1;
}
ll dp[x + 1];
dp[0] = 1;
if (m[1])
dp[1] = 0;
else
dp[1] = 1;
for (int i = 2; i <= x; i++) {
if (m[i])
dp[i] = 0;
else {
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] = dp[i] % 1000000007;
;
}
// cout<<dp[i]<<' ';
}
cout << dp[x];
} | [
"literal.number.change",
"assignment.value.change"
] | 826,725 | 826,726 | u297921353 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <set>
using namespace std;
#define int long long
int stairs[100005];
set<int> s;
const int mod = 1000000007;
int32_t main() {
stairs[0] = 1;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
s.insert(x);
}
if (!(*s.lower_bound(1) == 1))
stairs[1] = 1;
else
for (int i = 2; i <= n; i++) {
stairs[i] = (stairs[i - 1] + stairs[i - 2]) % mod;
if (*s.lower_bound(i) == i)
stairs[i] = 0;
}
cout << stairs[n] % mod;
return 0;
} | #include <algorithm>
#include <iostream>
#include <set>
using namespace std;
#define int long long
int stairs[100005];
set<int> s;
const int mod = 1000000007;
int32_t main() {
stairs[0] = 1;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
s.insert(x);
}
if (!(*s.lower_bound(1) == 1))
stairs[1] = 1;
for (int i = 2; i <= n; i++) {
stairs[i] = (stairs[i - 1] + stairs[i - 2]) % mod;
if (*s.lower_bound(i) == i)
stairs[i] = 0;
}
cout << stairs[n] % mod;
return 0;
} | [
"control_flow.branch.else.remove"
] | 826,736 | 826,737 | u488087935 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define fs first
#define sc second
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(m + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 2] + dp[i + 1]) % 1000000007;
}
cout << dp[0] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define fs first
#define sc second
typedef pair<ll, ll> l_l;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 2] + dp[i + 1]) % 1000000007;
}
cout << dp[0] << endl;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,746 | 826,747 | u703214333 | cpp |
p03013 | // abca29c.cpp : Typical Stairs
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MOD 1000000007
#define rp(i, n) for (int i = 0; i < (n); i++)
int main() {
int n, m;
cin >> n >> m;
vector<bool> ok(n + 1, true);
rp(i, n) {
int a;
cin >> a;
ok[a] = false;
}
vector<ll> dp(n + 1);
dp[0] = 1;
rp(now, n) for (int next = now + 1; next <= min(n, now + 2);
next++) if (ok[next]) dp[next] = (dp[next] + dp[now]) % MOD;
cout << dp[n] << endl;
} | // abca29c.cpp : Typical Stairs
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define MOD 1000000007
#define rp(i, n) for (int i = 0; i < (n); i++)
int main() {
int n, m;
cin >> n >> m;
vector<bool> ok(n + 1, true);
rp(i, m) {
int a;
cin >> a;
ok[a] = false;
}
vector<ll> dp(n + 1);
dp[0] = 1;
rp(now, n) for (int next = now + 1; next <= min(n, now + 2);
next++) if (ok[next]) dp[next] = (dp[next] + dp[now]) % MOD;
cout << dp[n] << endl;
} | [] | 826,750 | 826,751 | u525065967 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1, 0);
vector<long> dp(n + 1, 0);
const int mod = 1000000007;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 1;
}
dp[n] = 1; //初期化
for (int i = n - 1; i >= 0; i--) {
if (broken[i] == 1) {
dp[i] = 0; //壊れているところに0をいれる
} else {
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
}
cout << dp[0] << endl;
// for
// tableの作成
// for(int i=0; i<n-1; i++){ for(int j=0; i<2; i++){
// if i+j == a[i] // i+jがa[i]に含まれていた時
// dp[i][j] = i+j;
// cout << a[i] << endl;
// }
// }
// vector<list<int>> a(n);
// a[i].push_back(a[i+1])
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1, 0);
vector<long long> dp(n + 2, 0);
const int mod = 1000000007;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 1;
}
dp[n] = 1; //初期化
for (int i = n - 1; i >= 0; i--) {
if (broken[i] == 1) {
dp[i] = 0; //壊れているところに0をいれる
} else {
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
}
cout << dp[0] << endl;
// for
// tableの作成
// for(int i=0; i<n-1; i++){ for(int j=0; i<2; i++){
// if i+j == a[i] // i+jがa[i]に含まれていた時
// dp[i][j] = i+j;
// cout << a[i] << endl;
// }
// }
// vector<list<int>> a(n);
// a[i].push_back(a[i+1])
return 0;
} | [
"variable_declaration.type.widen.change",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,752 | 826,753 | u100919930 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1, 0);
vector<int> dp(n + 1, 0);
const int mod = 1000000007;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 1;
}
dp[n] = 1; //初期化
for (int i = n - 1; i >= 0; i--) {
if (broken[i] == 1) {
dp[i] = 0; //壊れているところに0をいれる
} else {
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
}
cout << dp[0] << endl;
// for
// tableの作成
// for(int i=0; i<n-1; i++){ for(int j=0; i<2; i++){
// if i+j == a[i] // i+jがa[i]に含まれていた時
// dp[i][j] = i+j;
// cout << a[i] << endl;
// }
// }
// vector<list<int>> a(n);
// a[i].push_back(a[i+1])
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1, 0);
vector<long long> dp(n + 2, 0);
const int mod = 1000000007;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 1;
}
dp[n] = 1; //初期化
for (int i = n - 1; i >= 0; i--) {
if (broken[i] == 1) {
dp[i] = 0; //壊れているところに0をいれる
} else {
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
}
cout << dp[0] << endl;
// for
// tableの作成
// for(int i=0; i<n-1; i++){ for(int j=0; i<2; i++){
// if i+j == a[i] // i+jがa[i]に含まれていた時
// dp[i][j] = i+j;
// cout << a[i] << endl;
// }
// }
// vector<list<int>> a(n);
// a[i].push_back(a[i+1])
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,754 | 826,753 | u100919930 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
#define INF 1e9
typedef long long LL;
const LL mod = 1e9 + 7;
int main() {
LL N, M;
cin >> N >> M;
vector<LL> a(N + 1);
rep(i, M) {
int num;
cin >> num;
a[num] = 1;
}
vector<LL> dp(N);
dp[0] = 1;
if (a[1] == 0)
dp[1] = 1;
for (int i = 2; i <= N; i++) {
if (a[i] == 0) {
dp[i] = dp[i - 2] + dp[i - 1];
dp[i] %= mod;
}
}
int answer = dp[N];
cout << answer << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
#define INF 1e9
typedef long long LL;
const LL mod = 1e9 + 7;
int main() {
LL N, M;
cin >> N >> M;
vector<LL> a(N + 1);
rep(i, M) {
int num;
cin >> num;
a[num] = 1;
}
vector<LL> dp(N + 1);
dp[0] = 1;
if (a[1] == 0)
dp[1] = 1;
for (int i = 2; i <= N; i++) {
if (a[i] == 0) {
dp[i] = dp[i - 2] + dp[i - 1];
dp[i] %= mod;
}
}
int answer = dp[N];
cout << answer << endl;
return 0;
} | [
"assignment.change"
] | 826,764 | 826,765 | u293072892 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
int a;
for (int i = 0; i < N; i++) {
cin >> a;
ok[a] = false;
}
vector<int> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(N, now + 2); next++) {
if (ok[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
int a;
for (int i = 0; i < M; i++) {
cin >> a;
ok[a] = false;
}
vector<int> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(N, now + 2); next++) {
if (ok[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 826,766 | 826,767 | u863841238 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
int a;
for (int i = 0; i < M; i++) {
cin >> a;
ok[i] = false;
}
vector<long long> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(N, now + 2); next++) {
if (ok[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
int a;
for (int i = 0; i < M; i++) {
cin >> a;
ok[a] = false;
}
vector<int> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(N, now + 2); next++) {
if (ok[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change"
] | 826,768 | 826,767 | u863841238 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
int a;
for (int i = 0; i < M; i++) {
cin >> a;
ok[i] = false;
}
vector<long long> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(N, now + 2); next++) {
if (ok[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
int a;
for (int i = 0; i < M; i++) {
cin >> a;
ok[a] = false;
}
vector<int> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(N, now + 2); next++) {
if (ok[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change"
] | 826,769 | 826,767 | u863841238 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
int a;
for (int i = 0; i < M; i++) {
cin >> a;
ok[i] = false;
}
vector<long long> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(N, now + 2); next++) {
if (ok[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
int a;
for (int i = 0; i < M; i++) {
cin >> a;
ok[a] = false;
}
vector<long long> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(N, now + 2); next++) {
if (ok[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 826,768 | 826,770 | u863841238 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
int a;
for (int i = 0; i < M; i++) {
cin >> a;
ok[i] = false;
}
vector<long long> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(N, now + 2); next++) {
if (ok[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
int a;
for (int i = 0; i < M; i++) {
cin >> a;
ok[a] = false;
}
vector<long long> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(N, now + 2); next++) {
if (ok[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 826,769 | 826,770 | u863841238 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i++) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| [] | 826,771 | 826,772 | u023473244 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n);
rep(i, n) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| [] | 826,778 | 826,779 | u653482689 | cpp |
p03013 | #include <bits/stdc++.h>
#define debug(x) cerr << #x << ": " << x << '\n';
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = (int)1e9;
const int MOD = (int)1e9 + 7;
// fatorial.cpp depend on this.
#ifndef MOD_INT
#define MOD_INT
template <int mod> struct ModInt {
private:
int x;
public:
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
template <typename T> operator T() const { return (T)x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using mint = ModInt<MOD>;
#endif
int main(void) {
int N, M;
cin >> N >> M;
vector<bool> available(N + 2, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
available[a] = false;
}
vector<mint> vec(N + 1, 0);
vec[0] = 1;
for (int i = 0; i < N; i++) {
if (available[i + 1])
vec[i + 1] += vec[i];
if (available[i + 2])
vec[i + 2] += vec[i];
}
cout << vec[N] << '\n';
return 0;
} | #include <bits/stdc++.h>
#define debug(x) cerr << #x << ": " << x << '\n';
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = (int)1e9;
const int MOD = (int)1e9 + 7;
// fatorial.cpp depend on this.
#ifndef MOD_INT
#define MOD_INT
template <int mod> struct ModInt {
private:
int x;
public:
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
template <typename T> operator T() const { return (T)x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using mint = ModInt<MOD>;
#endif
int main(void) {
int N, M;
cin >> N >> M;
vector<bool> available(N + 2, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
available[a] = false;
}
vector<mint> vec(N + 2, 0);
vec[0] = 1;
for (int i = 0; i < N; i++) {
if (available[i + 1])
vec[i + 1] += vec[i];
if (available[i + 2])
vec[i + 2] += vec[i];
}
cout << vec[N] << '\n';
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,784 | 826,785 | u660834360 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> x(n + 1, true);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
x.at(a) = false;
}
vector<long long> v(n + 1);
v.at(0) = 1;
if (x.at(1))
v.at(1) = 1;
else
v.at(1) = 0;
for (int i = 2; i < n + 1; i++) {
if (x.at(i))
v.at(i) = v.at(i - 1) + v.at(i - 2);
else
v.at(i) = 0;
v.at(i) % 1000000007;
}
cout << v.at(n) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> x(n + 1, true);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
x.at(a) = false;
}
vector<long long> v(n + 1);
v.at(0) = 1;
if (x.at(1))
v.at(1) = 1;
else
v.at(1) = 0;
for (int i = 2; i < n + 1; i++) {
if (x.at(i))
v.at(i) = v.at(i - 1) + v.at(i - 2);
else
v.at(i) = 0;
v.at(i) %= 1000000007;
}
cout << v.at(n) << endl;
}
| [
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change"
] | 826,788 | 826,789 | u422633119 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> boroken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
boroken[a] = true;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (boroken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]);
}
cout << dp[0] % mod << endl;
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> boroken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
boroken[a] = true;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (boroken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| [
"assignment.change",
"expression.operation.binary.remove"
] | 826,809 | 826,810 | u927804708 | cpp |
p03013 | #include <iostream>
#include <vector>
typedef long long ll;
const ll mod = 1e9 + 7;
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
signed main() {
int n, m;
cin >> n >> m;
vector<int> broken(n);
rep(i, n) {
int a;
cin >> a;
broken[a] = 1; // 1 ~= true
}
vector<int> dp(n + 2);
dp[n] = 1;
for (int i = n - 1; i >= 0; --i) {
if (broken[i]) {
dp[i] = 0;
continue;
} else {
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
}
cout << dp[0] << endl;
return 0;
}
| #include <iostream>
#include <vector>
typedef long long ll;
const ll mod = 1e9 + 7;
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
signed main() {
int n, m;
cin >> n >> m;
vector<int> broken(n);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1; // 1 ~= true
}
vector<int> dp(n + 2);
dp[n] = 1;
for (int i = n - 1; i >= 0; --i) {
if (broken[i]) {
dp[i] = 0;
continue;
} else {
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
}
cout << dp[0] << endl;
return 0;
}
| [] | 826,817 | 826,818 | u539199630 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
/*
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
*/
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
long long GCD(long long a, long long b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) { return a * b / GCD(a, b); }
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
const int INF = 1001001001;
const long long LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7; // 10^9
const double EPS = 1e-9;
const int dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
//#define int long long
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
signed main() {
// cin
int n, m;
cin >> n >> m;
// dp table & inisialize
vector<int> dp(n + 1, 0);
vector<bool> issafe(n + 1, true);
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
issafe[a] = false;
}
// inisial condition
dp[0] = 1;
if (issafe[1])
dp[1] = 1;
// loop
for (int i = 2; i <= n; ++i) {
if (issafe[i - 1])
dp[i] += dp[i - 1];
if (issafe[i - 2])
dp[i] += dp[i - 2];
dp[n] %= MOD;
}
// cout
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
/*
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
*/
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
long long GCD(long long a, long long b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) { return a * b / GCD(a, b); }
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
const int INF = 1001001001;
const long long LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7; // 10^9
const double EPS = 1e-9;
const int dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
//#define int long long
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
signed main() {
// cin
int n, m;
cin >> n >> m;
// dp table & inisialize
vector<int> dp(n + 1, 0);
vector<bool> issafe(n + 1, true);
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
issafe[a] = false;
}
// inisial condition
dp[0] = 1;
if (issafe[1])
dp[1] = 1;
// loop
for (int i = 2; i <= n; ++i) {
if (issafe[i - 1])
dp[i] += dp[i - 1];
if (issafe[i - 2])
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
// cout
cout << dp[n] << endl;
return 0;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 826,830 | 826,831 | u509680664 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
/*
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
*/
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
long long GCD(long long a, long long b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) { return a * b / GCD(a, b); }
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
const int INF = 1001001001;
const long long LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7; // 10^9
const double EPS = 1e-9;
const int dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
//#define int long long
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
signed main() {
// cin
int n, m;
cin >> n >> m;
// dp table & inisialize
vector<int> dp(n + 1, 0);
vector<bool> issafe(n + 1, true);
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
issafe[a] = false;
}
// inisial condition
dp[0] = 1;
if (issafe[1])
dp[1] = 1;
// loop
for (int i = 2; i <= n; ++i) {
if (issafe[n - 1])
dp[i] += dp[i - 1];
if (issafe[n - 2])
dp[i] += dp[i - 2];
dp[n] %= MOD;
}
// cout
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
/* #pragma */
/*
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
*/
/*alias*/
#define F first
#define S second
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define itn int
/*template*/
template <class T> inline bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool amin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
/* func */
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
long long GCD(long long a, long long b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) { return a * b / GCD(a, b); }
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
/*struct*/
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaaaaaa;
/* const */
const int INF = 1001001001;
const long long LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7; // 10^9
const double EPS = 1e-9;
const int dx[] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
// const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
// Counterclockwise from the 6o'clock direction
// Take the x-axis downward and the y-axis right
//#define int long long
// g++ -std=c++14 -Wall --pedantic-errors -o template template.cpp
// g++ -std=c++14 -Wall --pedantic-errors template.cpp
// chcp 65001
/*global*/
signed main() {
// cin
int n, m;
cin >> n >> m;
// dp table & inisialize
vector<int> dp(n + 1, 0);
vector<bool> issafe(n + 1, true);
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
issafe[a] = false;
}
// inisial condition
dp[0] = 1;
if (issafe[1])
dp[1] = 1;
// loop
for (int i = 2; i <= n; ++i) {
if (issafe[i - 1])
dp[i] += dp[i - 1];
if (issafe[i - 2])
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
// cout
cout << dp[n] << endl;
return 0;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.variable.change"
] | 826,832 | 826,831 | u509680664 | cpp |
p03013 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define INF 1e18
#define int long long
signed main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define INF 1e18
#define int long long
signed main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| [
"assignment.change"
] | 826,840 | 826,841 | u032189172 | cpp |
p03013 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define INF 1e18
#define int long long
signed main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i++) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define INF 1e18
#define int long long
signed main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| [
"assignment.change"
] | 826,842 | 826,841 | u032189172 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 1);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,857 | 826,858 | u640827947 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
lli mod = 1000000007;
int main() {
lli n, m;
cin >> n >> m;
lli temp;
set<lli> forbidden;
for (lli i = 0; i < m; i++) {
cin >> temp;
forbidden.insert(temp - 1);
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
vector<lli> dp(n, 0);
if (forbidden.find(n - 1) == forbidden.end()) {
dp[n - 1] = 1;
}
if (forbidden.find(n - 2) == forbidden.end()) {
dp[n - 2] = 1;
}
for (lli i = n - 3; i >= 0; i--) {
if (forbidden.find(i) == forbidden.end()) {
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
}
cout << dp[0] + dp[1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
lli mod = 1000000007;
int main() {
lli n, m;
cin >> n >> m;
lli temp;
set<lli> forbidden;
for (lli i = 0; i < m; i++) {
cin >> temp;
forbidden.insert(temp - 1);
}
if (n == 1) {
cout << 1 << endl;
return 0;
}
vector<lli> dp(n, 0);
if (forbidden.find(n - 1) == forbidden.end()) {
dp[n - 1] = 1;
}
if (forbidden.find(n - 2) == forbidden.end()) {
dp[n - 2] = 1;
}
for (lli i = n - 3; i >= 0; i--) {
if (forbidden.find(i) == forbidden.end()) {
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
}
cout << (dp[0] + dp[1]) % mod << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 826,859 | 826,860 | u354354727 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <vector>
int n, m;
long long ans = 0;
std::vector<int> brokenList(1, 0);
int main() {
std::cin >> n >> m;
for (int idx = 0; idx < m; ++idx) {
int num;
std::cin >> num;
brokenList.push_back(num);
}
std::sort(brokenList.begin(), brokenList.end());
int bIdx = 0;
std::vector<int> cntList(n + 1, 0);
cntList[0] = 1;
for (int now = 0; now < n; ++now) {
for (; bIdx < m && brokenList[bIdx] < now; ++bIdx)
;
if (brokenList[bIdx] == now) {
continue;
}
cntList[now + 1] += cntList[now];
cntList[now + 1] %= 1000000007;
if (now < n - 1) {
cntList[now + 2] += cntList[now];
cntList[now + 2] %= 1000000007;
}
}
std::cout << cntList[n] << std::endl;
} | #include <algorithm>
#include <iostream>
#include <vector>
int n, m;
long long ans = 0;
std::vector<int> brokenList(1, -1);
int main() {
std::cin >> n >> m;
for (int idx = 0; idx < m; ++idx) {
int num;
std::cin >> num;
brokenList.push_back(num);
}
std::sort(brokenList.begin(), brokenList.end());
int bIdx = 0;
std::vector<int> cntList(n + 1, 0);
cntList[0] = 1;
for (int now = 0; now < n; ++now) {
for (; bIdx < m && brokenList[bIdx] < now; ++bIdx)
;
if (brokenList[bIdx] == now) {
continue;
}
cntList[now + 1] += cntList[now];
cntList[now + 1] %= 1000000007;
if (now < n - 1) {
cntList[now + 2] += cntList[now];
cntList[now + 2] %= 1000000007;
}
}
std::cout << cntList[n] << std::endl;
}
| [
"literal.number.change",
"call.arguments.change"
] | 826,873 | 826,874 | u934073187 | cpp |
p03013 | #include "bits/stdc++.h"
using namespace std;
#define ASC(vec) vec.begin(), vec.end() // 昇順ソート 例：sort(ASC(vec));
#define DESC(vec) vec.rbegin(), vec.rend() // 降順ソート 例:sort(DESC(vec));
#define rep(i, n) for (i = 0; i < n; i++)
#define Rep(i, n) for (i = 1; i < n; i++)
#define Ans(s) cout << s << endl;
const int inf = (int)1e9 + 7;
const long long INF = 1LL << 60;
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 GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
typedef long long ll;
// 4,8方向に探索する際に用いる配列
// int dx[4] = { 0, 0, 1, -1 };
// int dy[4] = { 1, -1, 0, 0 };
// int dx[8] = { 1, 0, -1, 0, 1, -1, -1, 1 };
// int dy[8] = { 0, 1, 0, -1, 1, 1, -1, -1 };
constexpr auto MAX = 100010;
int mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<bool> isBroken(n + 1, false);
for (int i = 0; i < m; i++) {
int val;
cin >> val;
isBroken[val] = true;
}
vector<ll> dp(n + 1);
dp[0] = 1;
if (!isBroken[1])
dp[1] = 1;
for (int i = 2; i <= n; i++) {
if (!isBroken[i - 1])
dp[i] += dp[i - 1];
if (!isBroken[i - 2])
dp[i] += dp[i - 2];
dp[n] %= mod;
}
cout << dp[n] << endl;
} | #include "bits/stdc++.h"
using namespace std;
#define ASC(vec) vec.begin(), vec.end() // 昇順ソート 例：sort(ASC(vec));
#define DESC(vec) vec.rbegin(), vec.rend() // 降順ソート 例:sort(DESC(vec));
#define rep(i, n) for (i = 0; i < n; i++)
#define Rep(i, n) for (i = 1; i < n; i++)
#define Ans(s) cout << s << endl;
const int inf = (int)1e9 + 7;
const long long INF = 1LL << 60;
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 GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
typedef long long ll;
// 4,8方向に探索する際に用いる配列
// int dx[4] = { 0, 0, 1, -1 };
// int dy[4] = { 1, -1, 0, 0 };
// int dx[8] = { 1, 0, -1, 0, 1, -1, -1, 1 };
// int dy[8] = { 0, 1, 0, -1, 1, 1, -1, -1 };
constexpr auto MAX = 100010;
int mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<bool> isBroken(n + 1, false);
for (int i = 0; i < m; i++) {
int val;
cin >> val;
isBroken[val] = true;
}
vector<ll> dp(n + 1);
dp[0] = 1;
if (!isBroken[1])
dp[1] = 1;
for (int i = 2; i <= n; i++) {
if (!isBroken[i - 1])
dp[i] += dp[i - 1];
if (!isBroken[i - 2])
dp[i] += dp[i - 2];
dp[i] %= mod;
}
cout << dp[n] << endl;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 826,880 | 826,881 | u666683460 | cpp |
p03013 | #include <iostream>
using namespace std;
const int maxN = 100000;
int N, M;
bool isBroken[maxN + 1];
int dp[maxN + 1];
int rec(int dan) {
if (dan == N) {
return 1;
}
if (dan > N)
return 0;
int res = 0;
if (!isBroken[dan + 1]) {
int c;
if (dp[dan + 1] != -1) {
c = dp[dan + 1];
} else {
c = rec(dan + 1);
dp[dan + 1] = c;
}
res += c % 1000000007;
}
if (!isBroken[dan + 2]) {
int c;
if (dp[dan + 2] != -1) {
c = dp[dan + 2];
} else {
c = rec(dan + 2);
dp[dan + 2] = c;
}
res += c % 1000000007;
}
return res;
}
int main() {
cin >> N >> M;
for (int i = 0; i < N + 1; ++i) {
isBroken[i] = false;
dp[i] = -1;
}
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
isBroken[a] = true;
}
cout << rec(0) << endl;
return 0;
} | #include <iostream>
using namespace std;
const int maxN = 100000;
int N, M;
bool isBroken[maxN + 1];
int dp[maxN + 1];
int rec(int dan) {
if (dan == N) {
return 1;
}
if (dan > N)
return 0;
int res = 0;
if (!isBroken[dan + 1]) {
int c;
if (dp[dan + 1] != -1) {
c = dp[dan + 1];
} else {
c = rec(dan + 1);
dp[dan + 1] = c;
}
res += c % 1000000007;
}
if (!isBroken[dan + 2]) {
int c;
if (dp[dan + 2] != -1) {
c = dp[dan + 2];
} else {
c = rec(dan + 2);
dp[dan + 2] = c;
}
res += c % 1000000007;
}
res = res % 1000000007;
return res;
}
int main() {
cin >> N >> M;
for (int i = 0; i < N + 1; ++i) {
isBroken[i] = false;
dp[i] = -1;
}
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
isBroken[a] = true;
}
cout << rec(0) << endl;
return 0;
} | [
"assignment.add"
] | 826,900 | 826,901 | u657541767 | cpp |
p03013 | #include <iostream>
using namespace std;
#define MOD 1000000000 + 7
int N, M;
long long A[10 + 10];
long long dp[10 + 10];
int main(void) {
cin >> N >> M;
for (int i = 0; i < M; i++) {
long long temp;
cin >> temp;
A[temp] = 1;
}
dp[0] = 1;
for (int n = 1; n <= N; n++) {
if (A[n] == 1) {
continue;
}
dp[n] = dp[n - 1];
if (2 <= n) {
dp[n] += dp[n - 2];
}
dp[n] %= MOD;
}
cout << dp[N] << endl;
return 0;
}
| #include <iostream>
using namespace std;
#define MOD 1000000000 + 7
int N, M;
long long A[100000 + 10];
long long dp[100000 + 10];
int main(void) {
cin >> N >> M;
for (int i = 0; i < M; i++) {
long long temp;
cin >> temp;
A[temp] = 1;
}
dp[0] = 1;
for (int n = 1; n <= N; n++) {
if (A[n] == 1) {
continue;
}
dp[n] = dp[n - 1];
if (2 <= n) {
dp[n] += dp[n - 2];
}
dp[n] %= MOD;
}
cout << dp[N] << endl;
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change"
] | 826,904 | 826,905 | u614314290 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> broken(N + 1);
for (int i = 0; i < N; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(N + 2);
const int mod = 1000000007;
dp[N] = 1;
for (int j = N - 1; j >= 0; j--) {
if (broken[j])
dp[j] = 0;
else
dp[j] = (dp[j + 1] + dp[j + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> broken(N + 1);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(N + 2);
const int mod = 1e9 + 7;
dp[N] = 1;
for (int j = N - 1; j >= 0; j--) {
if (broken[j])
dp[j] = 0;
else
dp[j] = (dp[j + 1] + dp[j + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"literal.number.change"
] | 826,910 | 826,911 | u464527162 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> broken(N + 1);
for (int i = 0; i < N; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(N + 2);
const int mod = 1e9 + 7;
dp[N] = 1;
for (int j = N - 1; j >= 0; j--) {
if (broken[j])
dp[j] = 0;
else
dp[j] = (dp[j + 1] + dp[j + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> broken(N + 1);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(N + 2);
const int mod = 1e9 + 7;
dp[N] = 1;
for (int j = N - 1; j >= 0; j--) {
if (broken[j])
dp[j] = 0;
else
dp[j] = (dp[j + 1] + dp[j + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 826,912 | 826,911 | u464527162 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> broken(N + 1);
for (int i = 0; i < N; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(N + 2);
const long long mod = 1e9 + 7;
dp[N] = 1;
for (int j = N - 1; j >= 0; j--) {
if (broken[j])
dp[j] = 0;
else
dp[j] = dp[j + 1] + dp[j + 2] % mod;
}
cout << dp[0] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> broken(N + 1);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(N + 2);
const int mod = 1e9 + 7;
dp[N] = 1;
for (int j = N - 1; j >= 0; j--) {
if (broken[j])
dp[j] = 0;
else
dp[j] = (dp[j + 1] + dp[j + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change"
] | 826,913 | 826,911 | u464527162 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> broken(N + 1);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(N + 2);
const long long mod = 1e9 + 7;
dp[N] = 1;
for (int j = N - 1; j >= 0; j--) {
if (broken[j])
dp[j] = 0;
else
dp[j] = dp[j + 1] + dp[j + 2] % mod;
}
cout << dp[0] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> broken(N + 1);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(N + 2);
const int mod = 1e9 + 7;
dp[N] = 1;
for (int j = N - 1; j >= 0; j--) {
if (broken[j])
dp[j] = 0;
else
dp[j] = (dp[j + 1] + dp[j + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change"
] | 826,914 | 826,911 | u464527162 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> broken(N + 1);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(N + 2);
const long long mod = 1e9 + 7;
dp[0] = 1;
for (int j = N - 1; j >= 0; j--) {
if (broken[j])
dp[j] = 0;
else
dp[j] = dp[j + 1] + dp[j + 2] % mod;
}
cout << dp[0] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> broken(N + 1);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(N + 2);
const int mod = 1e9 + 7;
dp[N] = 1;
for (int j = N - 1; j >= 0; j--) {
if (broken[j])
dp[j] = 0;
else
dp[j] = (dp[j + 1] + dp[j + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change",
"assignment.variable.change",
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change"
] | 826,915 | 826,911 | u464527162 | cpp |
p03013 | #include <cstring>
#include <fstream>
#include <iostream>
#include <vector>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
ll N, M, res;
cin >> N >> M;
ll dp[N + 1];
std::memset(dp, 0, sizeof dp);
bool dan[N + 1];
std::memset(dan, true, sizeof dan);
ll tmp;
REP(i, M) {
cin >> tmp;
dan[tmp] = false;
}
dp[0] = 1; // 1通り
if (dan[1] == true)
dp[1] = 1; // 1段目が壊れてなければ1通り
for (ll i = 2; i <= N; i++) {
if (dan[i] == true) {
dp[i] += dp[i - 1];
dp[i] += dp[i - 2];
}
// else dp[i] = 0;
}
// 1000000007
dp[N] = dp[N] % 1000000007;
cout << dp[N] << endl;
return 0;
}
| #include <cstring>
#include <fstream>
#include <iostream>
#include <vector>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
ll N, M, res;
cin >> N >> M;
ll dp[N + 1];
std::memset(dp, 0, sizeof dp);
bool dan[N + 1];
std::memset(dan, true, sizeof dan);
ll tmp;
REP(i, M) {
cin >> tmp;
dan[tmp] = false;
}
dp[0] = 1; // 1通り
if (dan[1] == true)
dp[1] = 1; // 1段目が壊れてなければ1通り
for (ll i = 2; i <= N; i++) {
if (dan[i] == true) {
dp[i] += dp[i - 1];
dp[i] += dp[i - 2];
}
// else dp[i] = 0;
dp[i] = dp[i] % 1000000007;
}
// 1000000007
cout << dp[N] << endl;
return 0;
}
| [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"expression.operation.binary.change"
] | 826,931 | 826,932 | u485731913 | cpp |
p03013 | #include <cstring>
#include <fstream>
#include <iostream>
#include <vector>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
ll N, M, res;
cin >> N >> M;
ll dp[N + 1];
std::memset(dp, 0, sizeof dp);
bool dan[M + 1];
std::memset(dan, true, sizeof dan);
ll tmp;
REP(i, M) {
cin >> tmp;
dan[tmp] = false;
}
dp[0] = 1; // 1通り
if (dan[1] == true)
dp[1] = 1; // 1段目が壊れてなければ1通り
for (ll i = 2; i <= N; i++) {
// i は i-1 と i-2 を組み合わせたもの
//なぜdan[i]が壊れていたら、とできないのか →
if (dan[i - 1] == true)
dp[i] += dp[i - 1]; // i-1が壊れていたらなし
if (dan[i - 2] == true)
dp[i] += dp[i - 2]; // i-2が壊れていたらなし
// else dp[i] = 0;
dp[N] = dp[N] % 1000000007;
}
// 1000000007
// dp[N] = dp[N] % 1000000007;
cout << dp[N] << endl;
return 0;
}
| #include <cstring>
#include <fstream>
#include <iostream>
#include <vector>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
ll N, M, res;
cin >> N >> M;
ll dp[N + 1];
std::memset(dp, 0, sizeof dp);
bool dan[N + 1];
std::memset(dan, true, sizeof dan);
ll tmp;
REP(i, M) {
cin >> tmp;
dan[tmp] = false;
}
dp[0] = 1; // 1通り
if (dan[1] == true)
dp[1] = 1; // 1段目が壊れてなければ1通り
for (ll i = 2; i <= N; i++) {
// i は i-1 と i-2 を組み合わせたもの
//なぜdan[i]が壊れていたら、とできないのか →
if (dan[i - 1] == true)
dp[i] += dp[i - 1]; // i-1が壊れていたらなし
if (dan[i - 2] == true)
dp[i] += dp[i - 2]; // i-2が壊れていたらなし
// else dp[i] = 0;
dp[i] = dp[i] % 1000000007;
}
// 1000000007
// dp[N] = dp[N] % 1000000007;
cout << dp[N] << endl;
return 0;
}
| [
"identifier.change",
"expression.operation.binary.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"assignment.value.change"
] | 826,933 | 826,934 | u485731913 | cpp |
p03013 | #include <cstring>
#include <fstream>
#include <iostream>
#include <vector>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
ll N, M, res;
cin >> N >> M;
ll dp[N + 1];
std::memset(dp, 0, sizeof dp);
bool dan[M + 1];
std::memset(dan, true, sizeof dan);
ll tmp;
REP(i, M) {
cin >> tmp;
dan[tmp] = false;
}
dp[0] = 1; // 1通り
if (dan[1] == true)
dp[1] = 1; // 1段目が壊れてなければ1通り
for (ll i = 2; i <= N; i++) {
// i は i-1 と i-2 を組み合わせたもの
//なぜdan[i]が壊れていたら、とできないのか →
if (dan[i - 1] == true)
dp[i] += dp[i - 1]; // i-1が壊れていたらなし
if (dan[i - 2] == true)
dp[i] += dp[i - 2]; // i-2が壊れていたらなし
// else dp[i] = 0;
}
// 1000000007
dp[N] = dp[N] % 1000000007;
cout << dp[N] << endl;
return 0;
}
| #include <cstring>
#include <fstream>
#include <iostream>
#include <vector>
#define REP(i, n) for (long long i = 0; i < (n); i++)
#define ll long long
using namespace std;
int main() {
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
ll N, M, res;
cin >> N >> M;
ll dp[N + 1];
std::memset(dp, 0, sizeof dp);
bool dan[N + 1];
std::memset(dan, true, sizeof dan);
ll tmp;
REP(i, M) {
cin >> tmp;
dan[tmp] = false;
}
dp[0] = 1; // 1通り
if (dan[1] == true)
dp[1] = 1; // 1段目が壊れてなければ1通り
for (ll i = 2; i <= N; i++) {
// i は i-1 と i-2 を組み合わせたもの
//なぜdan[i]が壊れていたら、とできないのか →
if (dan[i - 1] == true)
dp[i] += dp[i - 1]; // i-1が壊れていたらなし
if (dan[i - 2] == true)
dp[i] += dp[i - 2]; // i-2が壊れていたらなし
// else dp[i] = 0;
dp[i] = dp[i] % 1000000007;
}
// 1000000007
// dp[N] = dp[N] % 1000000007;
cout << dp[N] << endl;
return 0;
}
| [
"identifier.change",
"expression.operation.binary.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"assignment.value.change"
] | 826,935 | 826,934 | u485731913 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
/*const int INF = 50;
typedef pair<int,int> P;
char field[52][52];
int d[51][51];
int r,c;
int sx,sy;
int gx,gy;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int bfs(){
queue<P> que;
for(int i=0;i<r;i++){
for(int j=0;j<c;j++){
d[i+1][j+1] = INF;
}
}
que.push(P(sy,sx));
d[sy][sx]=0;
while(que.size()){
P p=que.front();
que.pop();
if(p.second==gx&&p.first==gy) break;
for(int i=0;i<4;i++){
int nx=p.second+dx[i];
int ny=p.first+dy[i];
if(1<=nx&&nx<=c&&1<=ny&&ny<=r&&field[ny][nx]!='#'&&d[ny][nx]==INF){
que.push(P(ny,nx));
d[ny][nx] = d[p.first][p.second] + 1;
}
}
}
return d[gy][gx];
}
*/
int main() {
int n, m;
cin >> n >> m;
vector<bool> b;
b.assign(n + 1, true);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
b[a] = false;
}
vector<int> dp(n + 1, 0);
dp[0] = 1;
if (b[1])
dp[1] = 1;
for (int i = 2; i < n + 1; i++) {
if (b[i - 1])
dp[i] += dp[i - 1];
if (b[i - 2])
dp[i] += dp[i - 2];
dp[i] %= 100000007;
}
cout << dp[n] << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
/*const int INF = 50;
typedef pair<int,int> P;
char field[52][52];
int d[51][51];
int r,c;
int sx,sy;
int gx,gy;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int bfs(){
queue<P> que;
for(int i=0;i<r;i++){
for(int j=0;j<c;j++){
d[i+1][j+1] = INF;
}
}
que.push(P(sy,sx));
d[sy][sx]=0;
while(que.size()){
P p=que.front();
que.pop();
if(p.second==gx&&p.first==gy) break;
for(int i=0;i<4;i++){
int nx=p.second+dx[i];
int ny=p.first+dy[i];
if(1<=nx&&nx<=c&&1<=ny&&ny<=r&&field[ny][nx]!='#'&&d[ny][nx]==INF){
que.push(P(ny,nx));
d[ny][nx] = d[p.first][p.second] + 1;
}
}
}
return d[gy][gx];
}
*/
int main() {
int n, m;
cin >> n >> m;
vector<bool> b;
b.assign(n + 1, true);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
b[a] = false;
}
vector<int> dp(n + 1, 0);
dp[0] = 1;
if (b[1])
dp[1] = 1;
for (int i = 2; i < n + 1; i++) {
if (b[i - 1])
dp[i] += dp[i - 1];
if (b[i - 2])
dp[i] += dp[i - 2];
dp[i] %= 1000000007;
}
cout << dp[n] << endl;
return 0;
}
| [
"literal.number.change",
"assignment.value.change"
] | 826,939 | 826,940 | u622585907 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
/*const int INF = 50;
typedef pair<int,int> P;
char field[52][52];
int d[51][51];
int r,c;
int sx,sy;
int gx,gy;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int bfs(){
queue<P> que;
for(int i=0;i<r;i++){
for(int j=0;j<c;j++){
d[i+1][j+1] = INF;
}
}
que.push(P(sy,sx));
d[sy][sx]=0;
while(que.size()){
P p=que.front();
que.pop();
if(p.second==gx&&p.first==gy) break;
for(int i=0;i<4;i++){
int nx=p.second+dx[i];
int ny=p.first+dy[i];
if(1<=nx&&nx<=c&&1<=ny&&ny<=r&&field[ny][nx]!='#'&&d[ny][nx]==INF){
que.push(P(ny,nx));
d[ny][nx] = d[p.first][p.second] + 1;
}
}
}
return d[gy][gx];
}
*/
int main() {
int n, m;
cin >> n >> m;
vector<bool> b;
b.assign(n + 1, true);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
b[a] = false;
}
vector<int> dp(n + 1, 0);
dp[0] = 1;
if (b[1])
dp[1] = 1;
for (int i = 0; i < n + 1; i++) {
if (b[i - 1])
dp[i] += dp[i - 1];
if (b[i - 2])
dp[i] += dp[i - 2];
dp[i] %= 100000007;
}
cout << dp[n] << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
/*const int INF = 50;
typedef pair<int,int> P;
char field[52][52];
int d[51][51];
int r,c;
int sx,sy;
int gx,gy;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int bfs(){
queue<P> que;
for(int i=0;i<r;i++){
for(int j=0;j<c;j++){
d[i+1][j+1] = INF;
}
}
que.push(P(sy,sx));
d[sy][sx]=0;
while(que.size()){
P p=que.front();
que.pop();
if(p.second==gx&&p.first==gy) break;
for(int i=0;i<4;i++){
int nx=p.second+dx[i];
int ny=p.first+dy[i];
if(1<=nx&&nx<=c&&1<=ny&&ny<=r&&field[ny][nx]!='#'&&d[ny][nx]==INF){
que.push(P(ny,nx));
d[ny][nx] = d[p.first][p.second] + 1;
}
}
}
return d[gy][gx];
}
*/
int main() {
int n, m;
cin >> n >> m;
vector<bool> b;
b.assign(n + 1, true);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
b[a] = false;
}
vector<int> dp(n + 1, 0);
dp[0] = 1;
if (b[1])
dp[1] = 1;
for (int i = 2; i < n + 1; i++) {
if (b[i - 1])
dp[i] += dp[i - 1];
if (b[i - 2])
dp[i] += dp[i - 2];
dp[i] %= 1000000007;
}
cout << dp[n] << endl;
return 0;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"assignment.value.change"
] | 826,941 | 826,940 | u622585907 | cpp |
p03013 | // {{{
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
// }}}
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
static constexpr int mod = (int)1e9 + 7;
static constexpr int inf = 100100100;
static constexpr ll linf = 1e18;
static constexpr double eps = 1e-9;
static constexpr double pi = 3.14159265359;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rrep(i, n) for (ll i = n; i >= 0; --i)
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define pb push_back
#define ist insert
#define fst first
#define snd second
// {{{
template <typename T> struct modint {
static_assert(std::is_integral<T>::value, "T must be integral");
modint(T value = 0, T mod = (T)1e9 + 7) : value(value % mod), mod(mod) {}
modint operator+(const modint &rhs) const { return modint(*this) += rhs; }
modint operator-(const modint &rhs) const { return modint(*this) -= rhs; }
modint operator*(const modint &rhs) const { return modint(*this) *= rhs; }
modint operator/(const modint &rhs) const { return modint(*this) /= rhs; }
modint &operator+=(const modint &rhs) {
value += rhs.value;
if (value >= mod) {
value -= mod;
}
return *this;
}
modint &operator-=(const modint &rhs) {
if (value < rhs.value) {
value += mod;
}
value -= rhs.value;
return *this;
}
modint &operator*=(const modint &rhs) {
value = value * rhs.value % mod;
return *this;
}
modint &operator/=(const modint &rhs) {
modint tmp = rhs;
T exp = mod - 2;
while (exp) {
if (exp % 2) {
*this *= tmp;
}
tmp *= tmp;
exp /= 2;
}
return *this;
}
bool operator==(const modint &rhs) const { return value == rhs.value; }
bool operator!=(const modint &rhs) const { return !(*this == rhs); }
bool operator>(const modint &rhs) const { return value > rhs.value; }
bool operator<(const modint &rhs) const { return value < rhs.value; }
bool operator>=(const modint &rhs) const { return !(*this < rhs); }
bool operator<=(const modint &rhs) const { return !(*this > rhs); }
friend ostream &operator<<(ostream &out, const modint &m) {
out << m.value;
return out;
}
friend istream &operator>>(istream &in, modint &m) {
in >> m.value;
m.value %= m.mod;
return in;
}
T value;
T mod;
};
// }}}
modint<ll> dp[100005];
int main() {
// cin.tie(0);
// ios_base::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
set<ll> A;
rep(i, M) {
ll a;
cin >> a;
A.ist(a);
}
modint<ll> ans(0);
dp[0] = 1;
if (1 < N && !A.count(1)) {
dp[1] = 1;
}
for (ll i = 2; i <= N; ++i) {
if (A.count(i))
continue;
dp[i] = dp[i - 1] + dp[i - 2];
}
cout << dp[N] << endl;
}
| // {{{
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
// }}}
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
static constexpr int mod = (int)1e9 + 7;
static constexpr int inf = 100100100;
static constexpr ll linf = 1e18;
static constexpr double eps = 1e-9;
static constexpr double pi = 3.14159265359;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define rrep(i, n) for (ll i = n; i >= 0; --i)
#define all(c) begin(c), end(c)
#define rall(c) rbegin(c), rend(c)
#define pb push_back
#define ist insert
#define fst first
#define snd second
// {{{
template <typename T> struct modint {
static_assert(std::is_integral<T>::value, "T must be integral");
modint(T value = 0, T mod = (T)1e9 + 7) : value(value % mod), mod(mod) {}
modint operator+(const modint &rhs) const { return modint(*this) += rhs; }
modint operator-(const modint &rhs) const { return modint(*this) -= rhs; }
modint operator*(const modint &rhs) const { return modint(*this) *= rhs; }
modint operator/(const modint &rhs) const { return modint(*this) /= rhs; }
modint &operator+=(const modint &rhs) {
value += rhs.value;
if (value >= mod) {
value -= mod;
}
return *this;
}
modint &operator-=(const modint &rhs) {
if (value < rhs.value) {
value += mod;
}
value -= rhs.value;
return *this;
}
modint &operator*=(const modint &rhs) {
value = value * rhs.value % mod;
return *this;
}
modint &operator/=(const modint &rhs) {
modint tmp = rhs;
T exp = mod - 2;
while (exp) {
if (exp % 2) {
*this *= tmp;
}
tmp *= tmp;
exp /= 2;
}
return *this;
}
bool operator==(const modint &rhs) const { return value == rhs.value; }
bool operator!=(const modint &rhs) const { return !(*this == rhs); }
bool operator>(const modint &rhs) const { return value > rhs.value; }
bool operator<(const modint &rhs) const { return value < rhs.value; }
bool operator>=(const modint &rhs) const { return !(*this < rhs); }
bool operator<=(const modint &rhs) const { return !(*this > rhs); }
friend ostream &operator<<(ostream &out, const modint &m) {
out << m.value;
return out;
}
friend istream &operator>>(istream &in, modint &m) {
in >> m.value;
m.value %= m.mod;
return in;
}
T value;
T mod;
};
// }}}
modint<ll> dp[100005];
int main() {
// cin.tie(0);
// ios_base::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
set<ll> A;
rep(i, M) {
ll a;
cin >> a;
A.ist(a);
}
modint<ll> ans(0);
dp[0] = 1;
if (!A.count(1)) {
dp[1] = 1;
}
for (ll i = 2; i <= N; ++i) {
if (A.count(i))
continue;
dp[i] = dp[i - 1] + dp[i - 2];
}
cout << dp[N] << endl;
}
| [
"expression.operation.binary.remove"
] | 826,955 | 826,956 | u186294233 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
const long long MAX = 1000000007;
int main() {
long long n, m;
cin >> n >> m;
long long allspace[n + 1];
long long a[n];
long long x;
for (long long i = 0; i < n; i++) {
a[i] = 0;
}
for (long long i = 0; i < m; i++) {
cin >> x;
a[x - 1]++;
}
allspace[0] = 1;
allspace[1] = 1;
for (long long i = 2; i <= n; i++) {
allspace[i] = allspace[i - 1] + allspace[i - 2];
}
long long last = 1;
long long mul = 1;
for (long long i = 0; i < n; i++) {
// cout << mul << endl;;
if (!a[i]) {
// cout << 'a' << a[i] << endl;
last++;
} else {
// cout << 'b' << a[i] << endl;
if (last) {
mul *= allspace[last - 1];
mul %= MAX;
last = 0;
} else {
mul = 0;
break;
}
}
}
mul *= allspace[last - 1];
mul %= MAX;
cout << mul;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
const long long MAX = 1000000007;
int main() {
long long n, m;
cin >> n >> m;
long long allspace[n + 1];
long long a[n];
long long x;
for (long long i = 0; i < n; i++) {
a[i] = 0;
}
for (long long i = 0; i < m; i++) {
cin >> x;
a[x - 1]++;
}
allspace[0] = 1;
allspace[1] = 1;
for (long long i = 2; i <= n; i++) {
allspace[i] = (allspace[i - 1] + allspace[i - 2]) % MAX;
}
long long last = 1;
long long mul = 1;
for (long long i = 0; i < n; i++) {
// cout << mul << endl;;
if (!a[i]) {
// cout << 'a' << a[i] << endl;
last++;
} else {
// cout << 'b' << a[i] << endl;
if (last) {
mul *= allspace[last - 1];
mul %= MAX;
last = 0;
} else {
mul = 0;
break;
}
}
}
mul *= allspace[last - 1];
mul %= MAX;
cout << mul;
}
| [
"assignment.change"
] | 826,975 | 826,976 | u276796245 | cpp |
p03013 | #define _CRT_SECURE_NO_WARNINGS
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n, m, a[(int)1e+5] = {}, ans = 0, ans_1 = 1, ans_2 = 1, t, t2;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d", &t);
a[t] = 1;
}
for (int i = 2; i <= n; i++) {
if (a[i - 1]) {
ans = ans_2;
if (a[i - 2]) {
ans = 0;
break;
}
} else if (a[i - 2]) {
ans = ans_1;
} else {
ans = (ans_1 + ans_2) % 1000000007;
}
ans_2 = ans_1;
ans_1 = ans;
}
printf("%d\n", ans);
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n, m, a[(int)1e+5] = {}, ans = 1, ans_1 = 1, ans_2 = 1, t;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d", &t);
a[t] = 1;
}
for (int i = 2; i <= n; i++) {
if (a[i - 1]) {
ans = ans_2;
if (a[i - 2]) {
ans = 0;
break;
}
} else if (a[i - 2]) {
ans = ans_1;
} else {
ans = (ans_1 + ans_2) % 1000000007;
}
ans_2 = ans_1;
ans_1 = ans;
}
printf("%d\n", ans);
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"variable_declaration.remove"
] | 826,986 | 826,987 | u858766837 | cpp |
p03013 | #include <algorithm>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("file.1", "r", stdin);
int n, m;
cin >> n >> m;
vector<ll> a(n + 1, 0);
vector<ll> f(n + 1, 0);
int i, j;
for (i = 0; i < m; i++) {
int ai;
cin >> ai;
a[ai] = 1;
}
for (i = 1; i < n; i++) {
if (a[i] == 1 && a[i + 1] == 1) {
cout << 0 << endl;
return 0;
}
}
f[0] = 1;
f[1] = 1;
for (i = 2; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2];
}
// for (i = 1; i <= n; i++) {
// cout << a[i] << " ";
// }
// cout << endl;
// for (i = 1; i <= n; i++) {
// cout << f[i] << " ";
// }
// cout << endl;
ll ans = 1;
ll cnt = 1;
for (i = 1; i <= n; i++) {
if (a[i] == 1) {
// cout << "C:" << cnt << endl;
ans = ans * f[cnt - 1] % MOD;
cnt = 0;
} else {
cnt++;
}
}
if (cnt > 0) {
// cout << "C:" << cnt << endl;
ans = ans * f[cnt - 1] % MOD;
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// freopen("file.1", "r", stdin);
int n, m;
cin >> n >> m;
vector<ll> a(n + 1, 0);
vector<ll> f(n + 1, 0);
int i, j;
for (i = 0; i < m; i++) {
int ai;
cin >> ai;
a[ai] = 1;
}
for (i = 1; i < n; i++) {
if (a[i] == 1 && a[i + 1] == 1) {
cout << 0 << endl;
return 0;
}
}
f[0] = 1;
f[1] = 1;
for (i = 2; i <= n; i++) {
f[i] = (f[i - 1] + f[i - 2]) % MOD;
}
// for (i = 1; i <= n; i++) {
// cout << a[i] << " ";
// }
// cout << endl;
// for (i = 1; i <= n; i++) {
// cout << f[i] << " ";
// }
// cout << endl;
ll ans = 1;
ll cnt = 1;
for (i = 1; i <= n; i++) {
if (a[i] == 1) {
// cout << "C:" << cnt << endl;
ans = ans * f[cnt - 1] % MOD;
cnt = 0;
} else {
cnt++;
}
}
if (cnt > 0) {
// cout << "C:" << cnt << endl;
// cout << "F:" << f[cnt - 2] << endl;
ans = ans * f[cnt - 1] % MOD;
}
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 827,011 | 827,012 | u147305315 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
ll a[n + 1];
int temp;
for (int i = 0; i < n + 1; i++) {
a[i] = -1;
}
for (int i = 0; i < m; i++) {
cin >> temp;
a[temp] = 0;
}
a[0] = 1;
if (a[1] != 0)
a[1] = 1;
// if(a[2]!=0)a[2]=a[1]+1;
// for(int i=0;i<n+1;i++){
// cout << a[i] << endl;
// }
for (int i = 0; i < n - 1; i++) {
if (a[i + 2] == -1)
a[i + 2] = a[i + 1] + a[i];
}
ll ans = a[n] % 1000000007;
cout << ans << endl;
// for(int i=0;i<n+1;i++){
// cout << a[i] ;
// }
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m;
cin >> n >> m;
ll a[n + 1];
int temp;
for (int i = 0; i < n + 1; i++) {
a[i] = -1;
}
for (int i = 0; i < m; i++) {
cin >> temp;
a[temp] = 0;
}
a[0] = 1;
if (a[1] != 0)
a[1] = 1;
// if(a[2]!=0)a[2]=a[1]+1;
// for(int i=0;i<n+1;i++){
// cout << a[i] << endl;
// }
for (int i = 0; i < n - 1; i++) {
if (a[i + 2] == -1)
a[i + 2] = (a[i + 1] + a[i]) % 1000000007;
}
ll ans = a[n] % 1000000007;
cout << ans << endl;
// for(int i=0;i<n+1;i++){
// cout << a[i] ;
// }
return 0;
}
| [
"assignment.change"
] | 827,013 | 827,014 | u639032323 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
const long int mod = 1e9 + 7;
long long int n, m, a;
cin >> n >> m;
long long int dp[n + 1];
vector<bool> bl(n, true);
for (long int i = 0; i < m; i++) {
cin >> a;
bl[a] = false;
}
dp[0] = 1;
dp[1] = 1;
for (long int i = 0; i < n - 1; i++) {
dp[i + 2] = dp[i] * bl[i] + dp[i + 1] * bl[i + 1];
dp[i + 2] *= bl[i + 2];
}
cout << dp[n] % mod << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
const long int mod = 1e9 + 7;
long long int n, m, a;
cin >> n >> m;
long long int dp[n + 1];
vector<bool> bl(n, true);
for (long int i = 0; i < m; i++) {
cin >> a;
bl[a] = false;
}
dp[0] = 1;
dp[1] = 1;
for (long int i = 0; i < n - 1; i++) {
dp[i + 2] = (dp[i] * bl[i] + dp[i + 1] * bl[i + 1]) % mod;
dp[i + 2] *= bl[i + 2];
}
cout << dp[n] % mod << endl;
return 0;
} | [
"assignment.change"
] | 827,099 | 827,100 | u528388170 | cpp |
p03013 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long
// const int INF = 1e8;
typedef pair<int, int> P;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
queue<P> que;
int main() {
int n;
cin >> n;
int m;
cin >> m;
bool a[n];
for (int i = 0; i < n; i++)
a[i] = true;
for (int i = 0; i < m; i++) {
int ai;
cin >> ai;
a[ai - 1] = false;
}
long long b[n];
b[0] = 1;
b[1] = 2;
if (a[0] == false)
b[0] = 0;
b[1] = 1;
if (a[1] == false)
b[1] = 0;
for (int i = 2; i < n; i++) {
if (a[i] == true) {
b[i] = (b[i - 1] + b[i - 2]) % 1000000007;
} else {
b[i] = 0;
}
}
cout << b[n - 1] << endl;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long
// const int INF = 1e8;
typedef pair<int, int> P;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
queue<P> que;
int main() {
int n;
cin >> n;
int m;
cin >> m;
bool a[n];
for (int i = 0; i < n; i++)
a[i] = true;
for (int i = 0; i < m; i++) {
int ai;
cin >> ai;
a[ai - 1] = false;
}
long long b[n];
b[0] = 1;
b[1] = 2;
if (a[0] == false) {
b[0] = 0;
b[1] = 1;
}
if (a[1] == false) {
b[1] = 0;
}
for (int i = 2; i < n; i++) {
if (a[i] == true) {
b[i] = (b[i - 1] + b[i - 2]) % 1000000007;
} else {
b[i] = 0;
}
}
cout << b[n - 1] << endl;
} | [] | 827,103 | 827,104 | u974214237 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
long long n, m;
long long a[100010];
int main() {
cin >> n >> m;
a[0] = 1;
for (long long i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = -1;
}
for (long long i = 1; i <= n; i++) {
if (a[i] != -1) {
if (a[i - 1] != -1)
a[i] += a[i - 1];
if (a[i - 2] != -1)
a[i] += a[i - 2];
}
}
if (a[n] == -1)
cout << 0;
else
cout << a[n] % 1000000007;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
long long n, m;
long long a[100010];
int main() {
cin >> n >> m;
a[0] = 1;
for (long long i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = -1;
}
for (long long i = 1; i <= n; i++) {
if (a[i] != -1) {
if (a[i - 1] != -1)
a[i] += a[i - 1] % 1000000007;
if (a[i - 2] != -1)
a[i] += a[i - 2] % 1000000007;
}
}
if (a[n] == -1)
cout << 0;
else
cout << a[n] % 1000000007;
return 0;
} | [
"assignment.change"
] | 827,116 | 827,117 | u077698875 | cpp |
p03013 | #include <stdio.h>
int n, m, a[100001], d[100001], t;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d", &t);
a[t - 1] = 1;
}
if (a[0]) {
putchar('0');
return 0;
}
d[0] = 1;
if (!a[1])
d[1] = 1;
for (int i = 2; i <= n; i++)
if (!a[i])
d[i] = (d[i - 1] + d[i - 2]) % 1000000007;
printf("%d", d[n]);
return 0;
} | #include <stdio.h>
int n, m, a[100001], d[100001], t;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d", &t);
a[t] = 1;
}
if (a[0]) {
putchar('0');
return 0;
}
d[0] = 1;
if (!a[1])
d[1] = 1;
for (int i = 2; i <= n; i++)
if (!a[i])
d[i] = (d[i - 1] + d[i - 2]) % 1000000007;
printf("%d", d[n]);
return 0;
} | [
"expression.operation.binary.remove"
] | 827,131 | 827,132 | u073586914 | cpp |
p03013 | #include <stdio.h>
int n, m, a[100001], d[100001], t;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d", &t);
a[t - 1] = 1;
}
if (a[0]) {
putchar('0');
return 0;
}
d[0] = 1;
if (!a[1])
d[1] = 1;
for (int i = 2; i <= n; i++)
if (!a[i])
d[i] = d[i - 1] + d[i - 2];
printf("%d", d[n]);
return 0;
} | #include <stdio.h>
int n, m, a[100001], d[100001], t;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d", &t);
a[t] = 1;
}
if (a[0]) {
putchar('0');
return 0;
}
d[0] = 1;
if (!a[1])
d[1] = 1;
for (int i = 2; i <= n; i++)
if (!a[i])
d[i] = (d[i - 1] + d[i - 2]) % 1000000007;
printf("%d", d[n]);
return 0;
} | [
"expression.operation.binary.remove",
"assignment.change"
] | 827,133 | 827,132 | u073586914 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
const int b = 1e9 + 7;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<ll> dp(N + 10, 0); //余裕持たせる
vector<bool> flag(N + 10, true); //これも余裕を持たせる
for (ll i = 0; i < M; i++) {
ll a;
cin >> a;
flag[a] = false;
}
//壊れている階段の箇所はfalse;で flag dpともに1-indexed管理
flag[0] = 1;
if (flag[1] == true) {
dp[1] = 1;
}
for (ll i = 2; i < N + 10; i++) {
if (flag[i] == true) {
dp[i] = (dp[i - 1] + dp[i - 2]) % b;
}
}
cout << dp[N] << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
const int b = 1e9 + 7;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<ll> dp(N + 10, 0); //余裕持たせる
vector<bool> flag(N + 10, true); //これも余裕を持たせる
for (ll i = 0; i < M; i++) {
ll a;
cin >> a;
flag[a] = false;
}
//壊れている階段の箇所はfalse;で flag dpともに1-indexed管理
dp[0] = 1;
if (flag[1] == true) {
dp[1] = 1;
}
for (ll i = 2; i < N + 10; i++) {
if (flag[i] == true) {
dp[i] = (dp[i - 1] + dp[i - 2]) % b;
}
}
cout << dp[N] << endl;
return 0;
} | [
"assignment.variable.change",
"identifier.change"
] | 827,138 | 827,139 | u904123392 | cpp |
p03013 | #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long int ll;
#define repi(i, a, b) for (ll i = a; i < b; i++)
#define rep(i, a) repi(i, 0, a)
#define rrep(i, a) for (ll i = a - 1; i >= 0; i--)
#define MOD 1000000007
int main() {
ll N, M;
cin >> N >> M;
ll broken[N] = {}, dp[N] = {};
rep(i, M) {
ll a;
cin >> a;
broken[a - 1] = 1;
}
rep(i, N) {
if (broken[i])
continue;
if (i == 0)
dp[i] = 1;
else if (i == 1) {
dp[i] = dp[i] + 1;
} else
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
cout << dp[N - 1] << endl;
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long int ll;
#define repi(i, a, b) for (ll i = a; i < b; i++)
#define rep(i, a) repi(i, 0, a)
#define rrep(i, a) for (ll i = a - 1; i >= 0; i--)
#define MOD 1000000007
int main() {
ll N, M;
cin >> N >> M;
ll broken[N] = {}, dp[N] = {};
rep(i, M) {
ll a;
cin >> a;
broken[a - 1] = 1;
}
rep(i, N) {
if (broken[i])
continue;
if (i == 0)
dp[i] = 1;
else if (i == 1) {
dp[i] = dp[i - 1] + 1;
} else
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
cout << dp[N - 1] << endl;
return 0;
}
| [
"assignment.change"
] | 827,143 | 827,144 | u336721073 | cpp |
p03013 | #include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <iostream>
#include <unordered_set>
#include <vector>
using namespace std;
int main(int, char **) {
int N, M;
cin >> N >> M;
unordered_set<int> a;
for (int i = 0; i < M; ++i) {
int tmp;
cin >> tmp;
a.insert(tmp);
}
vector<unsigned long> stairs(N);
stairs[0] = a.find(1) == a.end() ? 1 : 0;
stairs[1] = a.find(2) == a.end() ? stairs[0] + 1 : 0;
for (int i = 2; i < N; ++i) {
stairs[i] = a.find(i + 1) == a.end() ? stairs[i - 2] + stairs[i - 1] : 0;
}
cout << stairs[N - 1] % 1000000007 << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <iostream>
#include <unordered_set>
#include <vector>
using namespace std;
int main(int, char **) {
int N, M;
cin >> N >> M;
unordered_set<int> a;
for (int i = 0; i < M; ++i) {
int tmp;
cin >> tmp;
a.insert(tmp);
}
vector<unsigned long> stairs(N);
stairs[0] = a.find(1) == a.end() ? 1 : 0;
stairs[1] = a.find(2) == a.end() ? stairs[0] + 1 : 0;
for (int i = 2; i < N; ++i) {
stairs[i] = a.find(i + 1) == a.end()
? ((stairs[i - 2] + stairs[i - 1]) % 1000000007)
: 0;
}
cout << stairs[N - 1] % 1000000007 << endl;
return 0;
}
| [] | 827,177 | 827,178 | u298497862 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define ld long double
#define vec vector<ll>
#define ms multiset<ll>
#define f(i, x, n) for (int i = x; i < n; i++)
#define int long long
#define mod 1000000007
#define endl "\n"
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int bk[1000000], fr[1000000];
int32_t main() {
fastio();
int n, m;
cin >> n >> m;
int a[m];
f(i, 0, m) {
cin >> a[i];
bk[a[i]] = 1;
}
int fg = 0;
f(i, 1, n) {
if (a[i] == a[i - 1] + 1)
fg = 1;
}
if (fg == 1) {
cout << 0;
return 0;
}
fr[0] = 1;
for (int i = 0; i <= n - 1; i++) {
if (bk[i] == 1)
continue;
if (bk[i + 1] == 0)
fr[i + 1] = (fr[i + 1] + fr[i]) % mod;
if (bk[i + 2] == 0)
fr[i + 2] = (fr[i + 2] + fr[i]) % mod;
}
cout << fr[n];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define ld long double
#define vec vector<ll>
#define ms multiset<ll>
#define f(i, x, n) for (int i = x; i < n; i++)
#define int long long
#define mod 1000000007
#define endl "\n"
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int bk[1000000], fr[1000000];
int32_t main() {
fastio();
int n, m;
cin >> n >> m;
int a[m];
f(i, 0, m) {
cin >> a[i];
bk[a[i]] = 1;
}
int fg = 0;
f(i, 1, m) {
if (a[i] == a[i - 1] + 1)
fg = 1;
}
if (fg == 1) {
cout << 0;
return 0;
}
fr[0] = 1;
for (int i = 0; i <= n - 1; i++) {
if (bk[i] == 1)
continue;
if (bk[i + 1] == 0)
fr[i + 1] = (fr[i + 1] + fr[i]) % mod;
if (bk[i + 2] == 0)
fr[i + 2] = (fr[i + 2] + fr[i]) % mod;
}
cout << fr[n];
} | [
"identifier.change",
"call.arguments.change"
] | 827,207 | 827,208 | u966690395 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll MOD = (1e+9) + 7;
int main() {
int n, m, a;
cin >> n >> m;
vector<bool> br(m);
vector<ll> dp(n + 1, 0);
for (int i = 0; i < m; i++) {
cin >> a;
br[a] = true;
}
dp[0] = 1;
for (int i = 0; i < n; i++) {
if (i + 1 <= n && !br[i + 1])
dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
if (i + 2 <= n && !br[i + 2])
dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll MOD = (1e+9) + 7;
int main() {
int n, m, a;
cin >> n >> m;
vector<bool> br(n + 1, false);
vector<ll> dp(n + 1, 0);
for (int i = 0; i < m; i++) {
cin >> a;
br[a] = true;
}
dp[0] = 1;
for (int i = 0; i < n; i++) {
if (i + 1 <= n && !br[i + 1])
dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
if (i + 2 <= n && !br[i + 2])
dp[i + 2] = (dp[i + 2] + dp[i]) % MOD;
}
cout << dp[n] << endl;
} | [
"call.arguments.add"
] | 827,232 | 827,233 | u798086274 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
const int md = 1e9 + 7;
int main(void) {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
vector<bool> a(n, false);
for (int i = 0; i < k; i++) {
int x;
cin >> x;
a[x] = true;
}
long long x = 1, y = 0, z;
if (!a[1])
y++;
for (int i = 2; i <= n; i++) {
z = (x + y) % md;
if (a[i])
z = 0;
x = y;
y = z;
}
cout << z;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int md = 1e9 + 7;
int main(void) {
ios_base::sync_with_stdio(0);
int n, k;
cin >> n >> k;
vector<bool> a(n, false);
for (int i = 0; i < k; i++) {
int x;
cin >> x;
a[x] = true;
}
long long x = 1, y = 0, z = 1;
if (!a[1])
y++;
for (int i = 2; i <= n; i++) {
z = (x + y) % md;
if (a[i])
z = 0;
x = y;
y = z;
}
cout << z;
return 0;
}
| [
"variable_declaration.value.change"
] | 827,234 | 827,235 | u192159607 | cpp |
p03013 | #include <algorithm>
#include <stdio.h>
#include <string>
#include <vector>
int main() {
int N, M;
scanf("%d %d", &N, &M);
int *b = new int[N + 1];
for (int i = 0; i < N + 1; i++) {
b[i] = 1;
}
for (int i = 0; i < M; i++) {
int a;
scanf("%d", &a);
b[a] = 0;
}
long long *n = new long long[N + 1];
n[0] = 1;
n[1] = b[1];
for (int i = 2; i < N + 1; i++) {
n[i] = b[i] * (n[i - 1] + n[i - 2]);
}
int res = n[N] % 1000000007;
printf("%d", res);
}
| #include <algorithm>
#include <stdio.h>
#include <string>
#include <vector>
int main() {
int N, M;
scanf("%d %d", &N, &M);
int *b = new int[N + 1];
for (int i = 0; i < N + 1; i++) {
b[i] = 1;
}
for (int i = 0; i < M; i++) {
int a;
scanf("%d", &a);
b[a] = 0;
}
long long *n = new long long[N + 1];
n[0] = 1;
n[1] = b[1];
for (int i = 2; i < N + 1; i++) {
n[i] = (b[i] * (n[i - 1] + n[i - 2])) % 1000000007;
}
int res = n[N] % 1000000007;
printf("%d", res);
}
| [
"assignment.change"
] | 827,238 | 827,239 | u617987447 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e6 + 7;
const int maxm = 2e6 + 7;
const ll mod = 1e9 + 7;
int n, m, ar[maxn];
int l[maxn], r[maxn];
int main() {
set<int> s;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
s.insert(x);
}
ar[0] = 1;
for (int i = 1; i <= n; i++) {
if (s.count(i))
continue;
if (i - 1 >= 0 && s.count(i - 1) == 0)
ar[i] += ar[i - 1];
if (i - 2 >= 0 && s.count(i - 2) == 0)
ar[i] += ar[i - 2];
ar[i] %= mod;
}
printf("%d\n", ar[n]);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e6 + 7;
const int maxm = 2e6 + 7;
const ll mod = 1e9 + 7;
int n, m, ar[maxn];
int l[maxn], r[maxn];
int main() {
set<int> s;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
s.insert(x);
}
ar[0] = 1;
for (int i = 1; i <= n; i++) {
if (s.count(i))
continue;
if (i - 1 >= 0 && s.count(i - 1) == 0)
ar[i] += ar[i - 1];
if (i - 2 >= 0 && s.count(i - 2) == 0)
ar[i] += ar[i - 2];
ar[i] %= mod;
}
printf("%d\n", ar[n]);
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 827,247 | 827,248 | u662513110 | cpp |
p03013 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
//#define MODE 1
#ifdef MODE
#define DEB(X) cout << #X << ": " << X << " ";
#define END cout << endl;
#else
#define DEB(X) \
{}
#define END \
{}
#endif
typedef long long ll;
#define int ll
#define uset unordered_set
#define umap unordered_map
typedef std::pair<int, int> P;
struct edge {
int to, cost;
};
const int INF = 100000000000000000;
const int INF2 = 9223372036854775807;
const int MOD = 1000000007;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define min(X, Y) (((int)(X) < (int)(Y)) ? (X) : (Y))
#define max(X, Y) (((int)(X) > (int)(Y)) ? (X) : (Y))
#define MAX(X, Y) (*max_element(X, Y))
#define MIN(X, Y) (*min_element(X, Y))
#define NP(X, Y) next_permutation(X, Y)
#define setp(X, Y) cout << fixed << setprecision(Y) << X;
int ceil2(int a, int b) {
if (a % b == 0) {
return a / b;
} else {
return a / b + 1;
}
}
int pow2(int a, int b) {
int r = 1;
for (int i = 1; i <= b; i++) {
r *= a;
}
return r;
}
int Log2(int a) {
int t = 0;
while (1) {
if (a == 0 || a == 1) {
break;
}
a /= 2;
t++;
}
return t;
}
int N, M;
int A[100010];
int dp[100010];
set<int> U;
int DP(int a) {
if (dp[a] != -1)
return dp[a];
if (U.find(a) != U.end()) {
return 0;
}
if (a > N - 1) {
return 0;
}
if (a == N - 1) {
return 1;
}
return dp[a] = (DP(a + 1) + DP(a + 2)) % MOD;
}
signed main() {
cin >> N >> M;
REP(i, M) {
cin >> A[i];
U.insert(A[i] - 1);
}
REP(i, 100010) { dp[i] = -1; }
int ans = DP(0) + DP(1);
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
//#define MODE 1
#ifdef MODE
#define DEB(X) cout << #X << ": " << X << " ";
#define END cout << endl;
#else
#define DEB(X) \
{}
#define END \
{}
#endif
typedef long long ll;
#define int ll
#define uset unordered_set
#define umap unordered_map
typedef std::pair<int, int> P;
struct edge {
int to, cost;
};
const int INF = 100000000000000000;
const int INF2 = 9223372036854775807;
const int MOD = 1000000007;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define min(X, Y) (((int)(X) < (int)(Y)) ? (X) : (Y))
#define max(X, Y) (((int)(X) > (int)(Y)) ? (X) : (Y))
#define MAX(X, Y) (*max_element(X, Y))
#define MIN(X, Y) (*min_element(X, Y))
#define NP(X, Y) next_permutation(X, Y)
#define setp(X, Y) cout << fixed << setprecision(Y) << X;
int ceil2(int a, int b) {
if (a % b == 0) {
return a / b;
} else {
return a / b + 1;
}
}
int pow2(int a, int b) {
int r = 1;
for (int i = 1; i <= b; i++) {
r *= a;
}
return r;
}
int Log2(int a) {
int t = 0;
while (1) {
if (a == 0 || a == 1) {
break;
}
a /= 2;
t++;
}
return t;
}
int N, M;
int A[100010];
int dp[100010];
set<int> U;
int DP(int a) {
if (dp[a] != -1)
return dp[a];
if (U.find(a) != U.end()) {
return 0;
}
if (a > N - 1) {
return 0;
}
if (a == N - 1) {
return 1;
}
return dp[a] = (DP(a + 1) + DP(a + 2)) % MOD;
}
signed main() {
cin >> N >> M;
REP(i, M) {
cin >> A[i];
U.insert(A[i] - 1);
}
REP(i, 100010) { dp[i] = -1; }
int ans = (DP(0) + DP(1)) % MOD;
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 827,249 | 827,250 | u848736574 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, MOD = 998244353;
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
typedef long long ll;
int u, v, p, d, n, tc, q, k, l, r, c, m, b[N], cnt, curr, a[N], ans;
ll calc[N];
bool sum[N], bad[N];
char s[N];
bool ok(int x) { return (x >= 0 && !bad[x]); }
int main() {
scanf("%d %d", &n, &m);
for (int i = 0, x; i < m; i++) {
scanf("%d", &x);
bad[x] = 1;
}
calc[0] = 1;
for (int i = 1; i <= n; i++) {
if (ok(i - 1)) {
calc[i] += calc[i - 1];
calc[i] %= MOD;
}
if (ok(i - 2)) {
calc[i] += calc[i - 2];
calc[i] %= MOD;
}
}
printf("%lld\n", calc[n]);
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, MOD = 1e9 + 7;
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
typedef long long ll;
int u, v, p, d, n, tc, q, k, l, r, c, m, b[N], cnt, curr, a[N], ans;
ll calc[N];
bool sum[N], bad[N];
char s[N];
bool ok(int x) { return (x >= 0 && !bad[x]); }
int main() {
scanf("%d %d", &n, &m);
for (int i = 0, x; i < m; i++) {
scanf("%d", &x);
bad[x] = 1;
}
calc[0] = 1;
for (int i = 1; i <= n; i++) {
if (ok(i - 1)) {
calc[i] += calc[i - 1];
calc[i] %= MOD;
}
if (ok(i - 2)) {
calc[i] += calc[i - 2];
calc[i] %= MOD;
}
}
printf("%lld\n", calc[n]);
} | [
"literal.number.change"
] | 827,256 | 827,257 | u318875010 | cpp |
p03013 | #include <bits/stdc++.h>
#define LL long long
#define INF 0x7FFFFFFF
#define mod 1000000007
using namespace std;
int dp[100000 + 5];
int vis[100000 + 5];
int main() {
int n, nu, m;
cin >> n >> m;
memset(vis, 0, sizeof vis);
for (int i = 0; i < m; ++i) {
cin >> nu;
vis[nu] = 1;
}
dp[0] = 1;
dp[1] = 1;
for (int i = 2; i <= n; ++i) {
if (vis[i]) {
dp[i] = 0;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % mod;
}
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
#define LL long long
#define INF 0x7FFFFFFF
#define mod 1000000007
using namespace std;
int dp[100000 + 5];
int vis[100000 + 5];
int main() {
int n, nu, m;
cin >> n >> m;
memset(vis, 0, sizeof vis);
for (int i = 0; i < m; ++i) {
cin >> nu;
vis[nu] = 1;
}
dp[0] = 1;
dp[1] = !vis[1];
for (int i = 2; i <= n; ++i) {
if (vis[i]) {
dp[i] = 0;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % mod;
}
}
cout << dp[n] << endl;
return 0;
} | [] | 827,258 | 827,259 | u368384385 | cpp |
p03013 | #include <bits/stdc++.h>
#define LL long long
#define INF 0x7FFFFFFF
#define mod 1000000007
using namespace std;
int dp[100000 + 5];
int vis[100000 + 5];
int main() {
int n, nu, m;
cin >> n >> m;
memset(vis, 0, sizeof vis);
for (int i = 0; i < m; ++i) {
cin >> nu;
vis[nu] = 1;
}
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; ++i) {
if (vis[i]) {
dp[i] = 0;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % mod;
}
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
#define LL long long
#define INF 0x7FFFFFFF
#define mod 1000000007
using namespace std;
int dp[100000 + 5];
int vis[100000 + 5];
int main() {
int n, nu, m;
cin >> n >> m;
memset(vis, 0, sizeof vis);
for (int i = 0; i < m; ++i) {
cin >> nu;
vis[nu] = 1;
}
dp[0] = 1;
dp[1] = !vis[1];
for (int i = 2; i <= n; ++i) {
if (vis[i]) {
dp[i] = 0;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % mod;
}
}
cout << dp[n] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 827,260 | 827,259 | u368384385 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long i64;
#define MOD 1000000007
int main(void) {
i64 n, m;
cin >> n >> m;
vector<bool> a(m, false);
vector<i64> dp(n + 1, 0);
for (i64 i = 0; i < m; i++) {
i64 x;
cin >> x;
a[x] = true;
}
dp[0] = 1;
for (i64 i = 1; i <= n; i++) {
if (!a[i - 1]) {
dp[i] += dp[i - 1];
dp[i] %= MOD;
}
if (i != 1 && !a[i - 2]) {
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long i64;
#define MOD 1000000007
int main(void) {
i64 n, m;
cin >> n >> m;
vector<bool> a(n, false);
vector<i64> dp(n + 1, 0);
for (i64 i = 0; i < m; i++) {
i64 x;
cin >> x;
a[x] = true;
}
dp[0] = 1;
for (i64 i = 1; i <= n; i++) {
if (!a[i - 1]) {
dp[i] += dp[i - 1];
dp[i] %= MOD;
}
if (i != 1 && !a[i - 2]) {
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
}
cout << dp[n] << endl;
} | [] | 827,274 | 827,275 | u477678256 | cpp |
p03013 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
//#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
long long MOD =
1000000000 + 7; // ;//1000000000 + 7 998244353 924844033 1000000000 + 9;
constexpr long long INF = numeric_limits<LL>::max();
constexpr long long DINF = 1000000000000;
const double PI = acos(-1);
#define fir first
#define sec second
#define thi third
#define debug(x) cerr << #x << ": " << x << '\n'
typedef pair<LL, LL> Pll;
typedef pair<double, double> Dll;
typedef pair<LL, pair<LL, LL>> Ppll;
typedef pair<LL, pair<LL, bitset<100001>>> Pbll;
typedef pair<LL, pair<LL, vector<LL>>> Pvll;
typedef pair<LL, LL> Vec2;
struct Tll {
LL first, second, third;
};
struct Fll {
LL first, second, third, fourth;
};
typedef pair<LL, Tll> Ptll;
#define rep(i, rept) for (LL i = 0; i < rept; i++)
#define Rrep(i, mf) for (LL i = mf - 1; i >= 0; i--)
void YN(bool f) {
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void yn(bool f) {
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
struct Edge {
LL to, cost;
};
struct edge {
LL from, to, cost;
};
vector<vector<Edge>> g;
vector<edge> ed;
vector<Pll> pv;
map<LL, LL> ma;
set<LL> st;
int di[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
LL n, m, k, p, q, w, h, s, t, ans, cnt, sum, a[210000], dp[210000];
string str;
bool f[110000];
// char c;
int main() {
cin >> n >> m;
rep(i, m) {
cin >> a[i];
f[a[i]] = 1;
}
dp[0] = 1;
rep(i, n + 1) {
if (f[i] == 0)
dp[i + 1] += dp[i];
if (f[i + 1] == 0)
dp[i + 2] += dp[i];
dp[i + 1] %= MOD;
dp[i + 2] %= MOD;
}
cout << dp[n + 1] << endl;
return 0;
} | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
//#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
long long MOD =
1000000000 + 7; // ;//1000000000 + 7 998244353 924844033 1000000000 + 9;
constexpr long long INF = numeric_limits<LL>::max();
constexpr long long DINF = 1000000000000;
const double PI = acos(-1);
#define fir first
#define sec second
#define thi third
#define debug(x) cerr << #x << ": " << x << '\n'
typedef pair<LL, LL> Pll;
typedef pair<double, double> Dll;
typedef pair<LL, pair<LL, LL>> Ppll;
typedef pair<LL, pair<LL, bitset<100001>>> Pbll;
typedef pair<LL, pair<LL, vector<LL>>> Pvll;
typedef pair<LL, LL> Vec2;
struct Tll {
LL first, second, third;
};
struct Fll {
LL first, second, third, fourth;
};
typedef pair<LL, Tll> Ptll;
#define rep(i, rept) for (LL i = 0; i < rept; i++)
#define Rrep(i, mf) for (LL i = mf - 1; i >= 0; i--)
void YN(bool f) {
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void yn(bool f) {
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
struct Edge {
LL to, cost;
};
struct edge {
LL from, to, cost;
};
vector<vector<Edge>> g;
vector<edge> ed;
vector<Pll> pv;
map<LL, LL> ma;
set<LL> st;
int di[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
LL n, m, k, p, q, w, h, s, t, ans, cnt, sum, a[210000], dp[210000];
string str;
bool f[110000];
// char c;
int main() {
cin >> n >> m;
rep(i, m) {
cin >> a[i];
f[a[i] - 1] = 1;
}
dp[0] = 1;
rep(i, n + 1) {
if (f[i] == 0)
dp[i + 1] += dp[i];
if (f[i + 1] == 0)
dp[i + 2] += dp[i];
dp[i + 1] %= MOD;
dp[i + 2] %= MOD;
}
cout << dp[n] << endl;
return 0;
}
| [
"assignment.change",
"expression.operation.binary.remove"
] | 827,276 | 827,277 | u202928696 | cpp |
p03014 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
const int M = 1e7;
int si[] = {-1, 0, 1, 0};
int sj[] = {0, -1, 0, 1};
int main() {
int h, w;
cin >> h >> w;
vector<string> s(h);
rep(i, h) cin >> s[i];
vector<vector<int>> l(h, vector<int>(w, 0)), r(h, vector<int>(w, 0));
vector<vector<int>> t(h, vector<int>(w, 0)), b(h, vector<int>(w, 0));
rep(i, h) {
int c = 0;
rep(j, w) {
if (s[i][j] == '#') {
l[i][j] = 0;
c = 0;
} else {
l[i][j] = c;
c++;
}
}
}
rep(i, h) {
int c = 0;
rep(j, w) {
if (s[i][w - j - 1] == '#') {
r[i][w - j - 1] = 0;
c = 0;
} else {
r[i][w - j - 1] = c;
c++;
}
}
}
rep(j, w) {
int c = 0;
rep(i, h) {
if (s[i][j] == '#') {
t[i][j] = 0;
c = 0;
} else {
t[i][j] = c;
c++;
}
}
}
rep(j, w) {
int c = 0;
rep(i, h) {
if (b[h - i - 1][j] == '#') {
b[h - i - 1][j] = 0;
c = 0;
} else {
b[h - i - 1][j] = c;
c++;
}
}
}
int ans = 0;
rep(i, h) rep(j, w) {
if (s[i][j] != '#')
ans = max(ans, t[i][j] + b[i][j] + l[i][j] + r[i][j] + 1);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
const int M = 1e7;
int si[] = {-1, 0, 1, 0};
int sj[] = {0, -1, 0, 1};
int main() {
int h, w;
cin >> h >> w;
vector<string> s(h);
rep(i, h) cin >> s[i];
vector<vector<int>> l(h, vector<int>(w, 0)), r(h, vector<int>(w, 0));
vector<vector<int>> t(h, vector<int>(w, 0)), b(h, vector<int>(w, 0));
rep(i, h) {
int c = 0;
rep(j, w) {
if (s[i][j] == '#') {
l[i][j] = 0;
c = 0;
} else {
l[i][j] = c;
c++;
}
}
}
rep(i, h) {
int c = 0;
rep(j, w) {
if (s[i][w - j - 1] == '#') {
r[i][w - j - 1] = 0;
c = 0;
} else {
r[i][w - j - 1] = c;
c++;
}
}
}
rep(j, w) {
int c = 0;
rep(i, h) {
if (s[i][j] == '#') {
t[i][j] = 0;
c = 0;
} else {
t[i][j] = c;
c++;
}
}
}
rep(j, w) {
int c = 0;
rep(i, h) {
if (s[h - i - 1][j] == '#') {
b[h - i - 1][j] = 0;
c = 0;
} else {
b[h - i - 1][j] = c;
c++;
}
}
}
int ans = 0;
rep(i, h) rep(j, w) {
if (s[i][j] != '#')
ans = max(ans, t[i][j] + b[i][j] + l[i][j] + r[i][j] + 1);
}
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 827,282 | 827,283 | u106342872 | cpp |
p03014 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
const int M = 1e7;
int si[] = {-1, 0, 1, 0};
int sj[] = {0, -1, 0, 1};
int main() {
int h, w;
cin >> h >> w;
vector<string> s(h);
rep(i, h) cin >> s[i];
vector<vector<int>> l(h, vector<int>(w, 0)), r(h, vector<int>(w, 0));
vector<vector<int>> t(h, vector<int>(w, 0)), b(h, vector<int>(w, 0));
rep(i, h) {
int c = 0;
rep(j, w) {
if (s[i][j] == '#') {
l[i][j] = 0;
c = 0;
} else {
l[i][j] = c;
c++;
}
}
}
rep(i, h) {
int c = 0;
rep(j, w) {
if (s[i][w - j - 1] == '#') {
r[i][w - j - 1] = 0;
c = 0;
} else {
r[i][w - j - 1] = c;
c++;
}
}
}
rep(j, w) {
int c = 0;
rep(i, h) {
if (s[i][j] == '#') {
t[i][j] = 0;
c = 0;
} else {
t[i][j] = c;
c++;
}
}
}
rep(j, w) {
int c = 0;
rep(i, h) {
if (b[h - i - 1][j] == '#') {
b[h - i - 1][j] = 0;
c = 0;
} else {
b[h - i - 1][j] = c;
c++;
}
}
}
int ans = 0;
rep(i, h) rep(j, w) {
if (s[i][j] != '#')
ans = max(ans, t[i][j] + b[i][j] + l[i][j] + r[i][j]);
}
cout << ans + 1 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
const int M = 1e7;
int si[] = {-1, 0, 1, 0};
int sj[] = {0, -1, 0, 1};
int main() {
int h, w;
cin >> h >> w;
vector<string> s(h);
rep(i, h) cin >> s[i];
vector<vector<int>> l(h, vector<int>(w, 0)), r(h, vector<int>(w, 0));
vector<vector<int>> t(h, vector<int>(w, 0)), b(h, vector<int>(w, 0));
rep(i, h) {
int c = 0;
rep(j, w) {
if (s[i][j] == '#') {
l[i][j] = 0;
c = 0;
} else {
l[i][j] = c;
c++;
}
}
}
rep(i, h) {
int c = 0;
rep(j, w) {
if (s[i][w - j - 1] == '#') {
r[i][w - j - 1] = 0;
c = 0;
} else {
r[i][w - j - 1] = c;
c++;
}
}
}
rep(j, w) {
int c = 0;
rep(i, h) {
if (s[i][j] == '#') {
t[i][j] = 0;
c = 0;
} else {
t[i][j] = c;
c++;
}
}
}
rep(j, w) {
int c = 0;
rep(i, h) {
if (s[h - i - 1][j] == '#') {
b[h - i - 1][j] = 0;
c = 0;
} else {
b[h - i - 1][j] = c;
c++;
}
}
}
int ans = 0;
rep(i, h) rep(j, w) {
if (s[i][j] != '#')
ans = max(ans, t[i][j] + b[i][j] + l[i][j] + r[i][j] + 1);
}
cout << ans << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change",
"assignment.change",
"expression.operation.binary.remove"
] | 827,285 | 827,283 | u106342872 | cpp |
p03014 | #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.12f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e18;
const ll MAX_N = 1010101;
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
ll dx[8] = {1, -1, 0, 0, 1, 1, -1, -1};
ll dy[8] = {0, 0, 1, -1, 1, -1, 1, -1};
char c[2010][2010];
ll sum[2010][2010];
ll sum2[2010][2010];
// long longしか使わない
//素数は1より大きい
// lower_boundは指定したkey以上の要素の一番左のイテレータをかえす
// upper_boundは指定したkeyより大きい要素の一番左のイテレータをかえす
int main() {
ll h, w;
cin >> h >> w;
rep(i, h) {
rep(j, w) { cin >> c[i][j]; }
}
rep(i, h) {
vector<ll> done(w);
rep(j, w) {
if (c[i][j] == '#')
continue;
if (done[j])
continue;
ll l = 0;
while (l + j < w) {
if (c[i][l + j] == '#')
break;
l++;
}
rep(k, l) {
sum[i][j + k] += l;
done[j + k] = 1;
}
}
}
rep(j, w) {
vector<ll> done(h);
rep(i, h) {
if (c[i][j] == '#')
continue;
if (done[i])
continue;
ll l = 0;
while (l + i < h) {
if (c[i + l][j] == '#')
break;
l++;
}
rep(k, l) {
sum[i + k][j] += l;
done[i + k] = 1;
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) { ans = max(ans, sum[i][j]); }
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exout(x) printf("%.12f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e18;
const ll MAX_N = 1010101;
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
ll dx[8] = {1, -1, 0, 0, 1, 1, -1, -1};
ll dy[8] = {0, 0, 1, -1, 1, -1, 1, -1};
char c[2010][2010];
ll sum[2010][2010];
ll sum2[2010][2010];
// long longしか使わない
//素数は1より大きい
// lower_boundは指定したkey以上の要素の一番左のイテレータをかえす
// upper_boundは指定したkeyより大きい要素の一番左のイテレータをかえす
int main() {
ll h, w;
cin >> h >> w;
rep(i, h) {
rep(j, w) { cin >> c[i][j]; }
}
rep(i, h) {
vector<ll> done(w);
rep(j, w) {
if (c[i][j] == '#')
continue;
if (done[j])
continue;
ll l = 0;
while (l + j < w) {
if (c[i][l + j] == '#')
break;
l++;
}
rep(k, l) {
sum[i][j + k] += l;
done[j + k] = 1;
}
}
}
rep(j, w) {
vector<ll> done(h);
rep(i, h) {
if (c[i][j] == '#')
continue;
if (done[i])
continue;
ll l = 0;
while (l + i < h) {
if (c[i + l][j] == '#')
break;
l++;
}
rep(k, l) {
sum[i + k][j] += l;
done[i + k] = 1;
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) { ans = max(ans, sum[i][j] - 1); }
}
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 827,288 | 827,289 | u631558039 | cpp |
p03014 | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll MOD = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 5010;
// max=({});
//条件式が真ならwhileの中身を回し続ける
// printf("%d\n", ans);
// pairの入力
// vector<pair<ll, ll>>work(n);
// rep(i, n) {
// ll a, b;
// cin >> a >> b;
// work[i] = make_pair(a, b);
// for(auto p:mp)(mapの探索)
// printf("%.10f\n",なんちゃら)
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
ll dp[101010];
// union-find木について
ll par[101010];
ll rank2[101010];
void init(ll n) {
rep(i, n) {
par[i] = i;
rank2[i] = 0;
}
}
ll find(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank2[x] < rank2[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank2[x] == rank2[y]) {
rank2[x]++;
}
}
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
char c[2010][2010];
bool flag[2010][2010];
ll cnt[2010][2010];
// long longしか使わない
//素数は1より大きい
int main() {
ll h, w;
cin >> h >> w;
rep(i, h) {
rep(j, w) { cin >> c[i][j]; }
}
rep(i, h) {
vector<ll> done(w);
rep(j, w) {
if (c[i][j] == '#')
continue;
if (done[j])
continue;
ll l = 0;
while (j + l < w) {
if (c[i][j + l] == '#')
break;
++l;
}
rep(k, l) {
cnt[i][j + k] += l;
done[j + k] = l;
}
}
}
rep(j, w) {
vector<ll> done(h);
rep(i, h) {
if (c[j][i] == '#')
continue;
if (done[i])
continue;
ll l = 0;
while (i + l < h) {
if (c[i + l][j] == '#')
break;
++l;
}
rep(k, l) {
cnt[i + k][j] += l;
done[i + k] = l;
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) { ans = max(ans, cnt[i][j] - 1); }
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll MOD = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 5010;
// max=({});
//条件式が真ならwhileの中身を回し続ける
// printf("%d\n", ans);
// pairの入力
// vector<pair<ll, ll>>work(n);
// rep(i, n) {
// ll a, b;
// cin >> a >> b;
// work[i] = make_pair(a, b);
// for(auto p:mp)(mapの探索)
// printf("%.10f\n",なんちゃら)
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
ll dp[101010];
// union-find木について
ll par[101010];
ll rank2[101010];
void init(ll n) {
rep(i, n) {
par[i] = i;
rank2[i] = 0;
}
}
ll find(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank2[x] < rank2[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank2[x] == rank2[y]) {
rank2[x]++;
}
}
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
char c[2010][2010];
bool flag[2010][2010];
ll cnt[2010][2010];
// long longしか使わない
//素数は1より大きい
int main() {
ll h, w;
cin >> h >> w;
rep(i, h) {
rep(j, w) { cin >> c[i][j]; }
}
rep(i, h) {
vector<ll> done(w);
rep(j, w) {
if (c[i][j] == '#')
continue;
if (done[j])
continue;
ll l = 0;
while (j + l < w) {
if (c[i][j + l] == '#')
break;
++l;
}
rep(k, l) {
cnt[i][j + k] += l;
done[j + k] = l;
}
}
}
rep(j, w) {
vector<ll> done(h);
rep(i, h) {
if (c[i][j] == '#')
continue;
if (done[i])
continue;
ll l = 0;
while (i + l < h) {
if (c[i + l][j] == '#')
break;
++l;
}
rep(k, l) {
cnt[i + k][j] += l;
done[i + k] = l;
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) { ans = max(ans, cnt[i][j] - 1); }
}
cout << ans << endl;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 827,290 | 827,291 | u631558039 | cpp |
p03014 | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll MOD = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 5010;
// max=({});
//条件式が真ならwhileの中身を回し続ける
// printf("%d\n", ans);
// pairの入力
// vector<pair<ll, ll>>work(n);
// rep(i, n) {
// ll a, b;
// cin >> a >> b;
// work[i] = make_pair(a, b);
// for(auto p:mp)(mapの探索)
// printf("%.10f\n",なんちゃら)
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
ll dp[101010];
// union-find木について
ll par[101010];
ll rank2[101010];
void init(ll n) {
rep(i, n) {
par[i] = i;
rank2[i] = 0;
}
}
ll find(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank2[x] < rank2[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank2[x] == rank2[y]) {
rank2[x]++;
}
}
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
char c[2010][2010];
bool flag[2010][2010];
ll cnt[2010][2010];
// long longしか使わない
//素数は1より大きい
int main() {
ll h, w;
cin >> h >> w;
rep(i, h) {
rep(j, w) { cin >> c[i][j]; }
}
rep(i, h) {
vector<ll> done(w);
rep(j, w) {
if (c[i][j] == '#')
continue;
if (done[j])
continue;
ll l = 0;
while (j + l < w) {
if (c[i][j + l] == '#')
break;
++l;
}
rep(k, l) {
cnt[i][j + k] += l;
done[j + k] = l;
}
}
}
rep(j, w) {
vector<ll> done(h);
rep(i, h) {
if (c[j][i] == '#')
continue;
if (done[i])
continue;
ll l = 0;
while (i + l < h) {
if (c[i + 1][j] == '#')
break;
++l;
}
rep(k, l) {
cnt[i + k][j] += l;
done[i + k] = l;
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) { ans = max(ans, cnt[i][j] - 1); }
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll MOD = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 5010;
// max=({});
//条件式が真ならwhileの中身を回し続ける
// printf("%d\n", ans);
// pairの入力
// vector<pair<ll, ll>>work(n);
// rep(i, n) {
// ll a, b;
// cin >> a >> b;
// work[i] = make_pair(a, b);
// for(auto p:mp)(mapの探索)
// printf("%.10f\n",なんちゃら)
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
ll dp[101010];
// union-find木について
ll par[101010];
ll rank2[101010];
void init(ll n) {
rep(i, n) {
par[i] = i;
rank2[i] = 0;
}
}
ll find(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank2[x] < rank2[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank2[x] == rank2[y]) {
rank2[x]++;
}
}
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
char c[2010][2010];
bool flag[2010][2010];
ll cnt[2010][2010];
// long longしか使わない
//素数は1より大きい
int main() {
ll h, w;
cin >> h >> w;
rep(i, h) {
rep(j, w) { cin >> c[i][j]; }
}
rep(i, h) {
vector<ll> done(w);
rep(j, w) {
if (c[i][j] == '#')
continue;
if (done[j])
continue;
ll l = 0;
while (j + l < w) {
if (c[i][j + l] == '#')
break;
++l;
}
rep(k, l) {
cnt[i][j + k] += l;
done[j + k] = l;
}
}
}
rep(j, w) {
vector<ll> done(h);
rep(i, h) {
if (c[i][j] == '#')
continue;
if (done[i])
continue;
ll l = 0;
while (i + l < h) {
if (c[i + l][j] == '#')
break;
++l;
}
rep(k, l) {
cnt[i + k][j] += l;
done[i + k] = l;
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) { ans = max(ans, cnt[i][j] - 1); }
}
cout << ans << endl;
} | [
"identifier.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"identifier.replace.add",
"literal.replace.remove"
] | 827,292 | 827,291 | u631558039 | cpp |
p03014 | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll MOD = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 5010;
// max=({});
//条件式が真ならwhileの中身を回し続ける
// printf("%d\n", ans);
// pairの入力
// vector<pair<ll, ll>>work(n);
// rep(i, n) {
// ll a, b;
// cin >> a >> b;
// work[i] = make_pair(a, b);
// for(auto p:mp)(mapの探索)
// printf("%.10f\n",なんちゃら)
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
ll dp[101010];
// union-find木について
ll par[101010];
ll rank2[101010];
void init(ll n) {
rep(i, n) {
par[i] = i;
rank2[i] = 0;
}
}
ll find(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank2[x] < rank2[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank2[x] == rank2[y]) {
rank2[x]++;
}
}
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
char c[2010][2010];
bool flag[2010][2010];
ll cnt[2010][2010];
// long longしか使わない
//素数は1より大きい
int main() {
ll h, w;
cin >> h >> w;
rep(i, h) {
rep(j, w) { cin >> c[i][j]; }
}
rep(i, h) {
vector<ll> done(w);
rep(j, w) {
if (c[i][j] == '#')
continue;
if (done[j])
continue;
ll l = 0;
while (j + l < w) {
if (c[i][j + 1] == '#')
break;
++l;
}
rep(k, l) {
cnt[i][j + k] += l;
done[j + k] = l;
}
}
}
rep(j, w) {
vector<ll> done(h);
rep(i, h) {
if (c[j][i] == '#')
continue;
if (done[i])
continue;
ll l = 0;
while (i + l < h) {
if (c[i + 1][j] == '#')
break;
++l;
}
rep(k, l) {
cnt[i + k][j] += l;
done[i + k] += l;
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) { ans = max(ans, cnt[i][j] - 1); }
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll MOD = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 5010;
// max=({});
//条件式が真ならwhileの中身を回し続ける
// printf("%d\n", ans);
// pairの入力
// vector<pair<ll, ll>>work(n);
// rep(i, n) {
// ll a, b;
// cin >> a >> b;
// work[i] = make_pair(a, b);
// for(auto p:mp)(mapの探索)
// printf("%.10f\n",なんちゃら)
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
ll dp[101010];
// union-find木について
ll par[101010];
ll rank2[101010];
void init(ll n) {
rep(i, n) {
par[i] = i;
rank2[i] = 0;
}
}
ll find(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank2[x] < rank2[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank2[x] == rank2[y]) {
rank2[x]++;
}
}
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
char c[2010][2010];
bool flag[2010][2010];
ll cnt[2010][2010];
// long longしか使わない
//素数は1より大きい
int main() {
ll h, w;
cin >> h >> w;
rep(i, h) {
rep(j, w) { cin >> c[i][j]; }
}
rep(i, h) {
vector<ll> done(w);
rep(j, w) {
if (c[i][j] == '#')
continue;
if (done[j])
continue;
ll l = 0;
while (j + l < w) {
if (c[i][j + l] == '#')
break;
++l;
}
rep(k, l) {
cnt[i][j + k] += l;
done[j + k] = l;
}
}
}
rep(j, w) {
vector<ll> done(h);
rep(i, h) {
if (c[i][j] == '#')
continue;
if (done[i])
continue;
ll l = 0;
while (i + l < h) {
if (c[i + l][j] == '#')
break;
++l;
}
rep(k, l) {
cnt[i + k][j] += l;
done[i + k] = l;
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) { ans = max(ans, cnt[i][j] - 1); }
}
cout << ans << endl;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"identifier.change",
"assignment.value.change"
] | 827,293 | 827,291 | u631558039 | cpp |
p03014 | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll MOD = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 5010;
// max=({});
//条件式が真ならwhileの中身を回し続ける
// printf("%d\n", ans);
// pairの入力
// vector<pair<ll, ll>>work(n);
// rep(i, n) {
// ll a, b;
// cin >> a >> b;
// work[i] = make_pair(a, b);
// for(auto p:mp)(mapの探索)
// printf("%.10f\n",なんちゃら)
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
ll dp[101010];
// union-find木について
ll par[101010];
ll rank2[101010];
void init(ll n) {
rep(i, n) {
par[i] = i;
rank2[i] = 0;
}
}
ll find(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank2[x] < rank2[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank2[x] == rank2[y]) {
rank2[x]++;
}
}
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
char c[2010][2010];
bool flag[2010][2010];
ll cnt[2010][2010];
// long longしか使わない
//素数は1より大きい
int main() {
ll h, w;
cin >> h >> w;
rep(i, h) {
rep(j, w) { cin >> c[i][j]; }
}
rep(i, h) {
vector<ll> done(w);
rep(j, w) {
if (c[i][j] == '#')
continue;
if (done[j])
continue;
ll l = 0;
while (j + l < w) {
if (c[i][j + 1] == '#')
break;
++l;
}
rep(k, l) {
cnt[i][j + k] += l;
done[j + k] = l;
}
}
}
rep(j, w) {
vector<ll> done(h);
rep(i, h) {
if (c[j][i] == '#')
continue;
if (done[i])
continue;
ll l = 0;
while (i + l < h) {
if (c[i + 1][j] == '#')
break;
++l;
}
rep(k, l) {
cnt[i + k][j] += l;
done[i + k] = l;
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) { ans = max(ans, cnt[i][j] - 1); }
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll MOD = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 5010;
// max=({});
//条件式が真ならwhileの中身を回し続ける
// printf("%d\n", ans);
// pairの入力
// vector<pair<ll, ll>>work(n);
// rep(i, n) {
// ll a, b;
// cin >> a >> b;
// work[i] = make_pair(a, b);
// for(auto p:mp)(mapの探索)
// printf("%.10f\n",なんちゃら)
//最大公約数
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)
return 0;
return (x / gcd(x, y) * y);
}
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll dx[4] = {0, 0, -1, 1};
ll dy[4] = {-1, 1, 0, 0};
ll dp[101010];
// union-find木について
ll par[101010];
ll rank2[101010];
void init(ll n) {
rep(i, n) {
par[i] = i;
rank2[i] = 0;
}
}
ll find(ll x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank2[x] < rank2[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank2[x] == rank2[y]) {
rank2[x]++;
}
}
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
char c[2010][2010];
bool flag[2010][2010];
ll cnt[2010][2010];
// long longしか使わない
//素数は1より大きい
int main() {
ll h, w;
cin >> h >> w;
rep(i, h) {
rep(j, w) { cin >> c[i][j]; }
}
rep(i, h) {
vector<ll> done(w);
rep(j, w) {
if (c[i][j] == '#')
continue;
if (done[j])
continue;
ll l = 0;
while (j + l < w) {
if (c[i][j + l] == '#')
break;
++l;
}
rep(k, l) {
cnt[i][j + k] += l;
done[j + k] = l;
}
}
}
rep(j, w) {
vector<ll> done(h);
rep(i, h) {
if (c[i][j] == '#')
continue;
if (done[i])
continue;
ll l = 0;
while (i + l < h) {
if (c[i + l][j] == '#')
break;
++l;
}
rep(k, l) {
cnt[i + k][j] += l;
done[i + k] = l;
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) { ans = max(ans, cnt[i][j] - 1); }
}
cout << ans << endl;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"identifier.change"
] | 827,294 | 827,291 | u631558039 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
#define all(v) v.begin(), v.end()
#define reps(__i, a, b) for (int __i = a; i < b; i++)
#define rep(__i, n) reps(__i, 0, n)
const ll INF = (1ll << 60);
const ll MOD = (ll)1e9 + 7;
signed main() {
int n, m;
int a[100000];
cin >> n >> m;
for (int i = 0; i < m; i++)
cin >> a[i];
set<int> s;
for (int i = 0; i < m; i++)
s.insert(a[i]);
int dp[100001] = {1, 1};
for (int i = 2; i <= n; i++)
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
// for (int i = 0; i <= n; i++)
// cout << dp[i] << " ";
// cout << endl;
int pr = INF;
bool f = true;
vector<int> v;
// {0, n};
for (auto itr = s.begin(); itr != s.end(); itr++) {
v.push_back(*itr);
if (*itr - pr == 1)
f = false;
pr = *itr;
}
sort(all(v));
unsigned long long ret = 1;
if (!f) {
cout << 0 << endl;
return 0;
} else {
if (v.size() == 0)
ret = dp[n];
else if (v.size() == 1)
ret = (dp[v[0] - 0 - 1] * dp[n - v[0] - 1]) % MOD;
else {
// cout << v[0] - 1 << endl;
// cout << n - v[v.size() - 1] - 1 << endl;
ret = (ret * dp[v[0] - 0 - 1]) % MOD;
ret = (ret * dp[n - v[v.size() - 1] - 1]) % MOD;
for (int i = 1; i < v.size() - 1; i++) {
// cout << v[i] - v[i - 1] - 2 << endl;
ret = (ret * dp[v[i] - v[i - 1] - 2]) % MOD;
}
}
}
cout << ret << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
#define all(v) v.begin(), v.end()
#define reps(__i, a, b) for (int __i = a; i < b; i++)
#define rep(__i, n) reps(__i, 0, n)
const ll INF = (1ll << 60);
const ll MOD = (ll)1e9 + 7;
signed main() {
int n, m;
int a[100000];
cin >> n >> m;
for (int i = 0; i < m; i++)
cin >> a[i];
set<int> s;
for (int i = 0; i < m; i++)
s.insert(a[i]);
int dp[100001] = {1, 1};
for (int i = 2; i <= n; i++)
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
// for (int i = 0; i <= n; i++)
// cout << dp[i] << " ";
// cout << endl;
int pr = INF;
bool f = true;
vector<int> v;
// {0, n};
for (auto itr = s.begin(); itr != s.end(); itr++) {
v.push_back(*itr);
if (*itr - pr == 1)
f = false;
pr = *itr;
}
sort(all(v));
unsigned long long ret = 1;
if (!f) {
cout << 0 << endl;
return 0;
} else {
if (v.size() == 0)
ret = dp[n];
else if (v.size() == 1)
ret = (dp[v[0] - 0 - 1] * dp[n - v[0] - 1]) % MOD;
else {
// cout << v[0] - 1 << endl;
// cout << n - v[v.size() - 1] - 1 << endl;
ret = (ret * dp[v[0] - 0 - 1]) % MOD;
ret = (ret * dp[n - v[v.size() - 1] - 1]) % MOD;
for (int i = 1; i < v.size(); i++) {
// cout << v[i] - v[i - 1] - 2 << endl;
ret = (ret * dp[v[i] - v[i - 1] - 2]) % MOD;
}
}
}
cout << ret << endl;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 827,316 | 827,317 | u218759384 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i++) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
| [] | 827,335 | 827,336 | u457283867 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.