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 <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int N, M;
vector<bool> issafe;
int main() {
cin >> N >> M;
issafe.assign(N + 1, true);
for (int i = 0; i < N; ++i) {
int a;
cin >> a;
issafe[a] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
if (issafe[1])
dp[1] = 1;
for (int n = 2; n <= N; n++) {
if (issafe[n - 1])
dp[n] += dp[n - 1];
if (issafe[n - 2])
dp[n] += dp[n - 2];
dp[n] %= MOD;
}
cout << dp[N] << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int N, M;
vector<bool> issafe;
int main() {
cin >> N >> M;
issafe.assign(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
issafe[a] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
if (issafe[1])
dp[1] = 1;
for (int n = 2; n <= N; n++) {
if (issafe[n - 1])
dp[n] += dp[n - 1];
if (issafe[n - 2])
dp[n] += dp[n - 2];
dp[n] %= MOD;
}
cout << dp[N] << endl;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 825,591 | 825,592 | u731665172 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repk(i, k, n) for (int i = k; i < n; i++)
#define all(vec) vec.begin(), vec.end()
#define ll long long
#define debug(x) cout << "debug: " << x << endl;
const int MOD = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<bool> is_safe(n + 1, true);
int k;
rep(i, n) cin >> k, is_safe[k] = false;
vector<ll> dp(n + 1, 0);
dp[0] = 1;
if (is_safe[1])
dp[1] = 1;
repk(i, 2, n + 1) {
if (is_safe[i - 1])
dp[i] += dp[i - 1];
if (is_safe[i - 2])
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
cout << dp[n] << endl;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repk(i, k, n) for (int i = k; i < n; i++)
#define all(vec) vec.begin(), vec.end()
#define ll long long
#define debug(x) cout << "debug: " << x << endl;
const int MOD = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<bool> is_safe(n + 1, true);
int k;
rep(i, m) cin >> k, is_safe[k] = false;
vector<int> dp(n + 1, 0);
dp[0] = 1;
if (is_safe[1])
dp[1] = 1;
repk(i, 2, n + 1) {
if (is_safe[i - 1])
dp[i] += dp[i - 1];
if (is_safe[i - 2])
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
cout << dp[n] << endl;
} | [
"identifier.change",
"call.arguments.change"
] | 825,603 | 825,604 | u296160120 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repk(i, k, n) for (int i = k; i < n; i++)
#define all(vec) vec.begin(), vec.end()
#define ll long long
#define debug(x) cout << "debug: " << x << endl;
const int MOD = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<bool> is_safe(n + 1, true);
int k;
rep(i, n) cin >> k, is_safe[k] = false;
vector<ll> dp(n + 1, 0);
dp[0] = 1;
if (is_safe[1])
dp[1] = 1;
repk(i, 2, n + 1) {
if (is_safe[i - 1])
dp[i] += dp[i - 1];
if (is_safe[i - 2])
dp[i] += dp[i - 2];
dp[n] %= MOD;
}
cout << dp[n] << endl;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repk(i, k, n) for (int i = k; i < n; i++)
#define all(vec) vec.begin(), vec.end()
#define ll long long
#define debug(x) cout << "debug: " << x << endl;
const int MOD = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<bool> is_safe(n + 1, true);
int k;
rep(i, m) cin >> k, is_safe[k] = false;
vector<int> dp(n + 1, 0);
dp[0] = 1;
if (is_safe[1])
dp[1] = 1;
repk(i, 2, n + 1) {
if (is_safe[i - 1])
dp[i] += dp[i - 1];
if (is_safe[i - 2])
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
cout << dp[n] << endl;
} | [
"identifier.change",
"call.arguments.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 825,605 | 825,604 | u296160120 | cpp |
p03013 | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
//#include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
// using Bint = mp::cpp_int;
const ll MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<int> S(N + 5, 0);
vector<bool> B(N + 5, true);
S[0] = 1;
for (int i = 0; i < M; i++) {
int t;
cin >> t;
B[t] = false;
}
for (int i = 0; i < N; i++) {
if (B[i + 1]) {
S[i + 1] = (S[i + 1] + S[i]) % MOD;
}
if (B[i + 1]) {
S[i + 2] = (S[i + 2] + S[i]) % MOD;
}
}
cout << S[N] << endl;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
//#include <boost/multiprecision/cpp_int.hpp>
// namespace mp = boost::multiprecision;
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
// using Bint = mp::cpp_int;
const ll MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<int> S(N + 5, 0);
vector<bool> B(N + 5, true);
S[0] = 1;
for (int i = 0; i < M; i++) {
int t;
cin >> t;
B[t] = false;
}
for (int i = 0; i < N; i++) {
if (B[i + 1]) {
S[i + 1] = (S[i + 1] + S[i]) % MOD;
}
if (B[i + 2]) {
S[i + 2] = (S[i + 2] + S[i]) % MOD;
}
}
cout << S[N] << endl;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 825,606 | 825,607 | u723550619 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
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] = 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 <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
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;
} else {
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
}
cout << dp[0] << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 825,611 | 825,612 | u726957641 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int MOD = 1000000007;
int n, m;
int main() {
cin >> n >> m;
// cout << var(n) << endl;
vector<int> ok(n + 1, 1);
for (int i = 0; i < m; i++) {
int p;
cin >> p;
ok[p] = 0;
}
/*
for(int i=0;i<=n;i++){
cout << "ok" << i << "段目" << ok[i] << endl;
}
*/
vector<int> dp(n + 1, 0);
dp[0] = 1;
dp[1] = dp[0] * ok[1];
for (int i = 0; i < n; i++) {
dp[i + 2] = (dp[i + 1] * ok[i + 2] + dp[i] * ok[i + 2]) % MOD;
}
/*
for(int i=0;i<n+1;i++){
cout << i << "段目まで=" << dp[i] << endl;
}
*/
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int MOD = 1000000007;
int n, m;
int main() {
cin >> n >> m;
// cout << var(n) << endl;
vector<int> ok(100050, 1);
for (int i = 0; i < m; i++) {
int p;
cin >> p;
ok[p] = 0;
}
vector<int> dp(100050, 0);
dp[0] = 1;
dp[1] = dp[0] * ok[1];
for (int i = 0; i < n; i++) {
dp[i + 2] = (dp[i + 1] * ok[i + 2] + dp[i] * ok[i + 2]) % MOD;
}
cout << dp[n] << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 825,615 | 825,614 | u619382421 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int MOD = 1000000007;
int n, m;
int main() {
cin >> n >> m;
// cout << var(n) << endl;
vector<int> ok(n + 1, 1);
for (int i = 0; i < m; i++) {
int p;
cin >> p;
ok[p] = 0;
}
/*
for(int i=0;i<=n;i++){
cout << "ok" << i << "段目" << ok[i] << endl;
}
*/
vector<int> dp(n + 1, 0);
dp[0] = 1;
dp[1] = dp[0] * ok[1];
for (int i = 0; i < n; i++) {
dp[i + 2] = (dp[i + 1] * ok[i + 2] + dp[i] * ok[i + 2]) % MOD;
}
/*
for(int i=0;i<n+1;i++){
cout << i << "段目まで=" << dp[i] << endl;
}
*/
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int MOD = 1000000007;
int n, m;
int main() {
cin >> n >> m;
// cout << var(n) << endl;
vector<int> ok(100050, 1);
for (int i = 0; i < m; i++) {
int p;
cin >> p;
ok[p] = 0;
}
vector<int> dp(100050, 0);
dp[0] = 1;
dp[1] = dp[0] * ok[1];
for (int i = 0; i < n; i++) {
dp[i + 2] = (dp[i + 1] * ok[i + 2] + dp[i] * ok[i + 2]) % MOD;
}
cout << dp[n] << endl;
} | [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 825,616 | 825,614 | u619382421 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long int a[n + 1];
for (int i = 0; i < n + 1; i++)
a[i] = 1;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = 0;
if (a[x - 1] == 0 || a[x + 1] == 0)
return cout << "0", 0;
}
for (int i = n - 2; i >= 0; i--) {
if (a[i] == 1)
a[i] = (a[i + 1] + a[i + 2]);
}
cout << a[0] % 1000000007;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long int a[n + 1];
for (int i = 0; i < n + 1; i++)
a[i] = 1;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = 0;
if (a[x - 1] == 0 || a[x + 1] == 0)
return cout << "0", 0;
}
for (int i = n - 2; i >= 0; i--) {
if (a[i] == 1)
a[i] = (a[i + 1] + a[i + 2]) % 1000000007;
}
cout << a[0];
return 0;
} | [
"assignment.change",
"expression.operation.binary.remove"
] | 825,634 | 825,635 | u313970998 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n + 1];
for (int i = 0; i < n + 1; i++)
a[i] = 1;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = 0;
if (a[x - 1] == 0 || a[x + 1] == 0)
return cout << "0", 0;
}
for (int i = n - 2; i >= 0; i--) {
if (a[i] == 1)
a[i] = (a[i + 1] + a[i + 2]);
}
cout << a[0];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long int a[n + 1];
for (int i = 0; i < n + 1; i++)
a[i] = 1;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = 0;
if (a[x - 1] == 0 || a[x + 1] == 0)
return cout << "0", 0;
}
for (int i = n - 2; i >= 0; i--) {
if (a[i] == 1)
a[i] = (a[i + 1] + a[i + 2]) % 1000000007;
}
cout << a[0];
return 0;
} | [
"assignment.change"
] | 825,636 | 825,635 | u313970998 | cpp |
p03013 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pp;
const int INF = 1e9;
const int MOD = 1000000007;
const double pi = 3.141592653589793238;
ll gcd(ll a, ll b) { return __gcd(a, b); } //最大公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } //最大公倍数
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int N, M;
cin >> N >> M;
vector<bool> h(N, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
h.at(a) = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
if (h.at(1))
dp[1] = 1;
for (int i = 2; i <= N; i++) {
if (h.at(i - 1))
dp[i] += dp[i - 1];
if (h.at(i - 2))
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
cout << dp[N] << endl;
return 0;
}
| #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pp;
const int INF = 1e9;
const int MOD = 1000000007;
const double pi = 3.141592653589793238;
ll gcd(ll a, ll b) { return __gcd(a, b); } //最大公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } //最大公倍数
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int N, M;
cin >> N >> M;
vector<bool> h(N + 1, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
h.at(a) = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
if (h.at(1))
dp[1] = 1;
for (int i = 2; i <= N; i++) {
if (h.at(i - 1))
dp[i] += dp[i - 1];
if (h.at(i - 2))
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
cout << dp[N] << endl;
return 0;
}
| [
"assignment.change"
] | 825,656 | 825,657 | u251236092 | cpp |
p03013 | #include <algorithm>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
// #include<bits/stdc++.h>
using namespace std;
#define ll long long
constexpr long long int INFLL = 1001001001001001LL;
constexpr int INFI = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<int> a(N, 0);
for (int i = 0; i < M; i++) {
int A;
cin >> A;
a[A] = 1;
}
vector<int> dp(N);
dp[0] = 1;
if (a[1] != 0) {
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];
}
dp[i] %= INFI;
if (dp[i] == 0 && dp[i - 1] == 0) {
cout << 0 << endl;
return 0;
}
}
cout << dp[N] << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <vector>
// #include<bits/stdc++.h>
using namespace std;
#define ll long long
constexpr long long int INFLL = 1001001001001001LL;
constexpr int INFI = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<int> a(N, 0);
for (int i = 0; i < M; i++) {
int A;
cin >> A;
a[A] = 1;
}
vector<int> dp(N + 1);
dp[0] = 1;
if (a[1] != 0) {
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];
}
dp[i] %= INFI;
if (dp[i] == 0 && dp[i - 1] == 0) {
cout << 0 << endl;
return 0;
}
}
cout << dp[N] << endl;
return 0;
}
| [
"assignment.change"
] | 825,663 | 825,664 | u550014122 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
long long n;
cin >> n;
vector<long long> k(n + 1, 1);
vector<int> u(n + 1, 0);
int m;
cin >> m;
rep(i, m) {
int a;
cin >> a;
u[a] = 1;
}
if (u[1] == 1)
k[1] = 0;
rep(i, n - 1) {
if (u[i + 2] == 1) {
k[i + 2] == 0;
continue;
}
k[i + 2] = (k[i] + k[i + 1]) % 1000000007;
}
cout << k[n] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
long long n;
cin >> n;
vector<long long> k(n + 1, 1);
vector<int> u(n + 1, 0);
int m;
cin >> m;
rep(i, m) {
int a;
cin >> a;
u[a] = 1;
}
if (u[1] == 1)
k[1] = 0;
rep(i, n - 1) {
if (u[i + 2] == 1) {
k[i + 2] = 0;
continue;
}
k[i + 2] = (k[i] + k[i + 1]) % 1000000007;
}
cout << k[n] << endl;
}
| [
"expression.operation.compare.replace.remove",
"assignment.replace.add",
"misc.typo"
] | 825,690 | 825,691 | u525560003 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(var, begin, end) for (int var = (begin); var <= (end); var++)
#define RFOR(var, begin, end) for (int var = (begin); var >= (end); var--)
#define REP(var, length) FOR(var, 0, length - 1)
#define RREP(var, length) RFOR(var, length - 1, 0)
#define EACH(value, var) for (auto value : var)
#define SORT(var) sort(var.begin(), var.end())
#define REVERSE(var) reverse(var.begin(), var.end())
#define RSORT(var) \
SORT(var); \
REVERSE(var)
#define OPTIMIZE_STDIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.precision(10); \
cout << fixed
#define endl '\n'
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const ll LINF = 1e18;
struct mint {
ll x;
mint() : x(0) {}
mint(ll x) : x((x % MOD + MOD) % MOD) {}
mint &operator+=(const mint &r) {
if ((x += r.x) >= MOD) {
x -= MOD;
}
return *this;
}
mint &operator-=(const mint &r) {
if ((x -= r.x) < 0) {
x += MOD;
}
return *this;
}
mint &operator*=(const mint &r) {
if ((x *= r.x) > MOD) {
x %= MOD;
}
return *this;
}
mint &operator++() {
if ((++x) >= MOD) {
x -= MOD;
}
return *this;
}
mint operator++(int) {
mint ret = x;
if ((++x) >= MOD) {
x -= MOD;
}
return ret;
}
mint &operator--() {
if ((--x) < 0) {
x += MOD;
}
return *this;
}
mint operator--(int) {
mint ret = x;
if ((--x) < 0) {
x += MOD;
}
return ret;
}
mint operator+(const mint &r) {
mint ret;
return ret = x + r.x;
}
mint operator-(const mint &r) {
mint ret;
return ret = x - r.x;
}
mint operator*(const mint &r) {
mint ret;
return ret = x * r.x;
}
mint operator-() { return mint() - *this; }
bool operator<(const mint &a) { return x < a.x; }
bool operator>(const mint &a) { return x > a.x; }
bool operator<=(const mint &a) { return x <= a.x; }
bool operator>=(const mint &a) { return x >= a.x; }
bool operator==(const mint &a) { return x == a.x; }
bool operator!=(const mint &a) { return x != a.x; }
};
ostream &operator<<(ostream &os, const mint &r) {
os << r.x;
return os;
}
ostream &operator>>(ostream &os, const mint &r) {
os >> r.x;
return os;
}
mint dp[100005];
void solve(istream &cin, ostream &cout) {
int n, m;
cin >> n >> m;
map<int, int> d;
REP(i, n) {
int a;
cin >> a;
if (!d.count(a))
d[a] = 1;
}
REP(i, 100005) dp[i] = 0;
dp[0] = 1;
dp[1] = 1;
FOR(i, 2, n) {
if (d.count(i))
continue;
if (!d.count(i - 1))
dp[i] += dp[i - 1];
if (!d.count(i - 2))
dp[i] += dp[i - 2];
}
mint ans = dp[n];
cout << ans << endl;
}
#ifndef TEST
int main() {
OPTIMIZE_STDIO;
solve(cin, cout);
}
#endif
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(var, begin, end) for (int var = (begin); var <= (end); var++)
#define RFOR(var, begin, end) for (int var = (begin); var >= (end); var--)
#define REP(var, length) FOR(var, 0, length - 1)
#define RREP(var, length) RFOR(var, length - 1, 0)
#define EACH(value, var) for (auto value : var)
#define SORT(var) sort(var.begin(), var.end())
#define REVERSE(var) reverse(var.begin(), var.end())
#define RSORT(var) \
SORT(var); \
REVERSE(var)
#define OPTIMIZE_STDIO \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.precision(10); \
cout << fixed
#define endl '\n'
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const ll LINF = 1e18;
struct mint {
ll x;
mint() : x(0) {}
mint(ll x) : x((x % MOD + MOD) % MOD) {}
mint &operator+=(const mint &r) {
if ((x += r.x) >= MOD) {
x -= MOD;
}
return *this;
}
mint &operator-=(const mint &r) {
if ((x -= r.x) < 0) {
x += MOD;
}
return *this;
}
mint &operator*=(const mint &r) {
if ((x *= r.x) > MOD) {
x %= MOD;
}
return *this;
}
mint &operator++() {
if ((++x) >= MOD) {
x -= MOD;
}
return *this;
}
mint operator++(int) {
mint ret = x;
if ((++x) >= MOD) {
x -= MOD;
}
return ret;
}
mint &operator--() {
if ((--x) < 0) {
x += MOD;
}
return *this;
}
mint operator--(int) {
mint ret = x;
if ((--x) < 0) {
x += MOD;
}
return ret;
}
mint operator+(const mint &r) {
mint ret;
return ret = x + r.x;
}
mint operator-(const mint &r) {
mint ret;
return ret = x - r.x;
}
mint operator*(const mint &r) {
mint ret;
return ret = x * r.x;
}
mint operator-() { return mint() - *this; }
bool operator<(const mint &a) { return x < a.x; }
bool operator>(const mint &a) { return x > a.x; }
bool operator<=(const mint &a) { return x <= a.x; }
bool operator>=(const mint &a) { return x >= a.x; }
bool operator==(const mint &a) { return x == a.x; }
bool operator!=(const mint &a) { return x != a.x; }
};
ostream &operator<<(ostream &os, const mint &r) {
os << r.x;
return os;
}
ostream &operator>>(ostream &os, const mint &r) {
os >> r.x;
return os;
}
mint dp[100005];
void solve(istream &cin, ostream &cout) {
int n, m;
cin >> n >> m;
map<int, int> d;
REP(i, m) {
int a;
cin >> a;
if (!d.count(a))
d[a] = 1;
}
REP(i, 100005) dp[i] = 0;
dp[0] = 1;
dp[1] = 1;
FOR(i, 2, n) {
if (d.count(i))
continue;
if (!d.count(i - 1))
dp[i] += dp[i - 1];
if (!d.count(i - 2))
dp[i] += dp[i - 2];
}
mint ans = dp[n];
cout << ans << endl;
}
#ifndef TEST
int main() {
OPTIMIZE_STDIO;
solve(cin, cout);
}
#endif
| [] | 825,709 | 825,710 | u068177169 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, l, r) for (ll i = (l); i < (r); i++)
#define repp(i, l, r, k) for (ll i = (l); i < (r); i += (k))
#define INF ((1LL << 62) - (1LL << 31))
#define MOD 1000000007
int main() {
int n, m;
cin >> n >> m;
bool ch[n];
rep(i, 0, n) ch[i] = true;
rep(i, 0, m) {
int a;
cin >> a;
ch[a] = false;
}
ll dp[100010] = {};
dp[0] = 1;
if (ch[1])
dp[1] = 1;
rep(i, 2, n + 1) {
if (ch[i]) {
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
}
cout << dp[n] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, l, r) for (ll i = (l); i < (r); i++)
#define repp(i, l, r, k) for (ll i = (l); i < (r); i += (k))
#define INF ((1LL << 62) - (1LL << 31))
#define MOD 1000000007
int main() {
int n, m;
cin >> n >> m;
bool ch[n + 1];
rep(i, 0, n + 1) ch[i] = true;
rep(i, 0, m) {
int a;
cin >> a;
ch[a] = false;
}
ll dp[100010] = {};
dp[0] = 1;
if (ch[1])
dp[1] = 1;
rep(i, 2, n + 1) {
if (ch[i]) {
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
}
cout << dp[n] << endl;
}
| [
"assignment.change"
] | 825,713 | 825,714 | u200060866 | 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 = 1e9 + 7;
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, 0);
const int mod = 1e9 + 7;
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;
} | [
"call.arguments.add"
] | 825,719 | 825,720 | u764860452 | 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 = 1e9 + 7;
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 = 1e9 + 7;
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;
} | [] | 825,719 | 825,721 | u764860452 | cpp |
p03013 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < int(n); ++i)
using namespace std;
template <class A> void pr(A a) { cout << a << endl; }
template <class A, class B> void pr(A a, B b) {
cout << a << " ";
p(b);
}
template <class A, class B, class C> void pr(A a, B b, C c) {
cout << a << " ";
p(b, c);
}
template <class A, class B, class C, class D> void pr(A a, B b, C c, D d) {
cout << a << " ";
p(b, c, d);
}
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
int INF = numeric_limits<int>::max();
// for(int j=0;j<N;++j) {}
int main(void) {
int N, M;
cin >> N >> M;
int a[N + 10] = {0};
int n;
REP(i, M) {
cin >> n;
a[n] = 1;
}
ll dp[100010];
dp[0] = 1;
dp[1] = 1;
for (int j = 0; j < N + 1; ++j) {
if (a[j]) {
dp[j] = 0;
} else if (j == 0 || j == 1) {
dp[j] = 1;
} else {
dp[j] = dp[j - 1] + dp[j - 2];
}
}
pr(dp[N] % 1000000007);
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < int(n); ++i)
using namespace std;
template <class A> void pr(A a) { cout << a << endl; }
template <class A, class B> void pr(A a, B b) {
cout << a << " ";
p(b);
}
template <class A, class B, class C> void pr(A a, B b, C c) {
cout << a << " ";
p(b, c);
}
template <class A, class B, class C, class D> void pr(A a, B b, C c, D d) {
cout << a << " ";
p(b, c, d);
}
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
int INF = numeric_limits<int>::max();
// for(int j=0;j<N;++j) {}
int main(void) {
int N, M;
cin >> N >> M;
int a[N + 10] = {0};
int n;
REP(i, M) {
cin >> n;
a[n] = 1;
}
ll dp[100010];
dp[0] = 1;
dp[1] = 1;
for (int j = 0; j < N + 1; ++j) {
if (a[j]) {
dp[j] = 0;
} else if (j == 0 || j == 1) {
dp[j] = 1;
} else {
dp[j] = (dp[j - 1] + dp[j - 2]) % 1000000007;
}
}
pr(dp[N] % 1000000007);
return 0;
}
| [
"assignment.change"
] | 825,722 | 825,723 | u041781161 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define vi vector<int>
#define vivi vector<vi>
const int INF = int(1e9);
typedef long long int ll;
/* -- template -- */
ll memo[100000];
ll dfs(int x) {
if (x < 0)
return 0;
if (x == 0)
return 1;
if (memo[x] == 0)
memo[x] = dfs(x - 1) + dfs(x - 2);
return memo[x];
}
int main() {
int N, M;
cin >> N >> M;
bool stair[N + 1];
rep(i, N + 1) stair[i] = true;
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
stair[a] = false;
}
ll ans = 1;
int count = 0;
for (int i = 0; i < N + 1; ++i) {
if (stair[i] == false) {
ans = (ans * dfs(count - 1)) % 1000000007;
count = 0;
} else {
count += 1;
}
}
ans = (ans * dfs(count - 1)) % 1000000007;
cout << ans;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define vi vector<int>
#define vivi vector<vi>
const int INF = int(1e9);
typedef long long int ll;
/* -- template -- */
ll memo[100000];
ll dfs(int x) {
if (x < 0)
return 0;
if (x == 0)
return 1;
if (memo[x] == 0)
memo[x] = (dfs(x - 1) + dfs(x - 2)) % 1000000007;
return memo[x];
}
int main() {
int N, M;
cin >> N >> M;
bool stair[N + 1];
rep(i, N + 1) stair[i] = true;
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
stair[a] = false;
}
ll ans = 1;
int count = 0;
for (int i = 0; i < N + 1; ++i) {
if (stair[i] == false) {
ans = (ans * dfs(count - 1)) % 1000000007;
count = 0;
} else {
count += 1;
}
}
ans = (ans * dfs(count - 1)) % 1000000007;
cout << ans;
}
| [
"assignment.change"
] | 825,732 | 825,733 | u275488634 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define vi vector<int>
#define vivi vector<vi>
const int INF = int(1e9);
typedef long long int ll;
/* -- template -- */
int memo[100000];
ll dfs(int x) {
if (x < 0)
return 0;
if (x == 0)
return 1;
if (memo[x] == 0)
memo[x] = dfs(x - 1) + dfs(x - 2);
return memo[x];
}
int main() {
int N, M;
cin >> N >> M;
bool stair[N + 1];
rep(i, N + 1) stair[i] = true;
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
stair[a] = false;
}
ll ans = 1;
int count = 0;
for (int i = 0; i < N + 1; ++i) {
if (stair[i] == false) {
ans = (ans * dfs(count - 1)) % 1000000007;
count = 0;
} else {
count += 1;
}
}
ans = (ans * dfs(count - 1)) % 1000000007;
cout << ans;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define vi vector<int>
#define vivi vector<vi>
const int INF = int(1e9);
typedef long long int ll;
/* -- template -- */
ll memo[100000];
ll dfs(int x) {
if (x < 0)
return 0;
if (x == 0)
return 1;
if (memo[x] == 0)
memo[x] = (dfs(x - 1) + dfs(x - 2)) % 1000000007;
return memo[x];
}
int main() {
int N, M;
cin >> N >> M;
bool stair[N + 1];
rep(i, N + 1) stair[i] = true;
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
stair[a] = false;
}
ll ans = 1;
int count = 0;
for (int i = 0; i < N + 1; ++i) {
if (stair[i] == false) {
ans = (ans * dfs(count - 1)) % 1000000007;
count = 0;
} else {
count += 1;
}
}
ans = (ans * dfs(count - 1)) % 1000000007;
cout << ans;
}
| [
"variable_declaration.type.change",
"assignment.change"
] | 825,734 | 825,733 | u275488634 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n, m;
cin >> n >> m;
ll arr[n + 10] = {0}, arr1[n] = {0};
arr1[0] = 1;
for (ll i = 0; i < m; ++i) {
ll tmp;
cin >> tmp;
arr[tmp] = -1;
}
for (ll i = 0; i < n; ++i) {
if (arr[i] == arr[i + 1] && arr[i] == -1) {
cout << 0;
return 0;
}
}
if (arr[1] == '-1')
arr1[1] = 1;
for (ll i = 2; i <= n; ++i) {
if (arr[i] != -1) {
arr1[i] =
(arr1[i - 1] % 1000000007 + arr1[i - 2] % 1000000007) % 1000000007;
}
}
cout << arr1[n];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll n, m;
cin >> n >> m;
ll arr[n + 10] = {0}, arr1[n] = {0};
arr1[0] = 1;
for (ll i = 0; i < m; ++i) {
ll tmp;
cin >> tmp;
arr[tmp] = -1;
}
for (ll i = 0; i < n; ++i) {
if (arr[i] == arr[i + 1] && arr[i] == -1) {
cout << 0;
return 0;
}
}
if (arr[1] != -1)
arr1[1] = 1;
for (ll i = 2; i <= n; ++i) {
if (arr[i] != -1) {
arr1[i] =
(arr1[i - 1] % 1000000007 + arr1[i - 2] % 1000000007) % 1000000007;
}
}
cout << arr1[n];
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 825,744 | 825,745 | u027630431 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> dp(N + 1, true);
int tmp;
for (int i = 0; i < M; ++i) {
cin >> tmp;
dp[tmp] = false;
}
for (int i = 3; i <= N; ++i) {
if (dp[i] == false)
continue;
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= 1000000007;
}
cout << dp[N] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<int> dp(N + 1, true);
int tmp;
for (int i = 0; i < M; ++i) {
cin >> tmp;
dp[tmp] = false;
}
for (int i = 2; i <= N; ++i) {
if (dp[i] == false)
continue;
dp[i] = dp[i - 1] + 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",
"expression.off_by_one"
] | 825,748 | 825,749 | u635358463 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <class _T> inline bool chmax(_T &a, _T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class _T> inline bool chmin(_T &a, _T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
const long long mod = 1000000007;
int main(void) {
int n;
cin >> n;
int m;
cin >> m;
ll a[m], dp[n + 1];
rep(i, n + 1) dp[i] = 0;
rep(i, m) {
cin >> a[i];
dp[a[i]] = INF;
}
dp[0] = 1;
for (int i = 1; i < n + 1; i++) {
if (dp[i] == INF)
continue;
if (dp[i - 1] != INF)
dp[i] += dp[i - 1];
if (i > 1 && dp[i - 2] != INF)
dp[i] += dp[i - 2];
// cout << "dp[" <<i <<"]=" << dp[i] << endl;
}
cout << dp[n] % mod << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <class _T> inline bool chmax(_T &a, _T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class _T> inline bool chmin(_T &a, _T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
const long long mod = 1000000007;
int main(void) {
int n;
cin >> n;
int m;
cin >> m;
ll a[m], dp[n + 1];
rep(i, n + 1) dp[i] = 0;
rep(i, m) {
cin >> a[i];
dp[a[i]] = INF;
}
dp[0] = 1;
for (int i = 1; i < n + 1; i++) {
if (dp[i] == INF)
continue;
if (dp[i - 1] != INF)
dp[i] += dp[i - 1] % mod;
if (i > 1 && dp[i - 2] != INF)
dp[i] += dp[i - 2] % mod;
// cout << "dp[" <<i <<"]=" << dp[i] << endl;
}
cout << dp[n] % mod << endl;
return 0;
}
| [
"assignment.change"
] | 825,754 | 825,755 | u807394250 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define INF 1000000000
#define LLINF 2000000000000000
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define LOOP(i, N) for (int i = 0; i < N; i++)
#define LOOP1(i, N) for (int i = 1; i <= N; i++)
typedef pair<int, int> P;
typedef pair<int, pair<int, int>> PP;
#define int long long
signed main() {
int n, m;
bool disable[100006] = {};
int cnt[100006] = {};
cin >> n >> m;
LOOP(i, m) {
int a;
cin >> a;
disable[a] = true;
}
cnt[1] = !disable[1];
cnt[2] = (!disable[2]) ? 0 : 1 + cnt[1];
FOR(i, 3, n + 1) {
if (disable[i] == false) {
cnt[i] = cnt[i - 1] + cnt[i - 2];
cnt[i] %= 1000000007;
}
}
cout << cnt[n] << endl;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define INF 1000000000
#define LLINF 2000000000000000
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define LOOP(i, N) for (int i = 0; i < N; i++)
#define LOOP1(i, N) for (int i = 1; i <= N; i++)
typedef pair<int, int> P;
typedef pair<int, pair<int, int>> PP;
#define int long long
signed main() {
int n, m;
bool disable[100006] = {};
int cnt[100006] = {};
cin >> n >> m;
LOOP(i, m) {
int a;
cin >> a;
disable[a] = true;
}
cnt[1] = !disable[1];
cnt[2] = ((!disable[2]) ? 1 + cnt[1] : 0);
FOR(i, 3, n + 1) {
if (disable[i] == false) {
cnt[i] = cnt[i - 1] + cnt[i - 2];
cnt[i] %= 1000000007;
}
}
cout << cnt[n] << endl;
}
| [] | 825,758 | 825,759 | u118951811 | cpp |
p03013 | #include <float.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#define NUM 100001
int step(int n, int i, int m, int *ans) {
if (i == -1)
return 0;
else if (i == 0)
return 1;
else if (ans[i] != -1)
return ans[i];
else
return ans[i] =
(step(n, i - 1, m, ans) + step(n, i - 2, m, ans)) % 1000000007;
}
int main() {
int n, m, ans[NUM], a;
scanf("%d%d\n", &n, &m);
for (int i = 0; i < n; i++) {
ans[i] = -1;
}
for (int i = 0; i < m; i++) {
scanf("%d", &a);
ans[a] = 0;
}
printf("%d\n", step(n, n, m, ans));
return 0;
} | #include <float.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#define NUM 100001
int step(int n, int i, int m, int *ans) {
if (i == -1)
return 0;
else if (i == 0)
return 1;
else if (ans[i] != -1)
return ans[i];
else
return ans[i] =
(step(n, i - 1, m, ans) + step(n, i - 2, m, ans)) % 1000000007;
}
int main() {
int n, m, ans[NUM], a;
scanf("%d%d\n", &n, &m);
for (int i = 0; i < n + 1; i++) {
ans[i] = -1;
}
for (int i = 0; i < m; i++) {
scanf("%d", &a);
ans[a] = 0;
}
printf("%d\n", step(n, n, m, ans));
return 0;
} | [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 825,762 | 825,761 | u870205469 | cpp |
p03013 | #include <bits/stdc++.h>
#include <cstdio>
#include <iostream>
#include <list> //list<???> a; a.push_back ,insert(追加したい要素),a.sort(),参照できない
#include <set>
#include <string>
#include <vector> //vector<???> a; a.push_back,sort(a.begin(),a.end());a[i]
//配列 int a[N];a[i]=追加したい要素;sort(a,a+N);a[i]
using namespace std;
typedef long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<int> oks(N + 1, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
oks[a] = false;
}
vector<int> dp(N + 1);
dp[N] = 1;
for (int i = N - 1; 0 <= i; i--) {
if (oks[i]) {
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
} else {
dp[i] = 0;
}
}
cout << dp[0] << endl;
return 0;
} | #include <bits/stdc++.h>
#include <cstdio>
#include <iostream>
#include <list> //list<???> a; a.push_back ,insert(追加したい要素),a.sort(),参照できない
#include <set>
#include <string>
#include <vector> //vector<???> a; a.push_back,sort(a.begin(),a.end());a[i]
//配列 int a[N];a[i]=追加したい要素;sort(a,a+N);a[i]
using namespace std;
typedef long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<int> oks(N + 1, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
oks[a] = false;
}
vector<int> dp(N + 2);
dp[N] = 1;
for (int i = N - 1; 0 <= i; i--) {
if (oks[i]) {
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
} else {
dp[i] = 0;
}
}
cout << dp[0] << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 825,763 | 825,764 | u235376569 | cpp |
p03013 | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <vector>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<bool> a(n, true);
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] == false;
}
vector<unsigned long long int> dp(n + 1, 0);
dp[0] = 1;
for (int now = 0; now < n; now++) {
for (int next = now + 1; next <= min(n, now + 2); next++) {
if (a[next] == true) {
dp[next] += dp[now];
dp[next] %= 1000000007;
}
}
}
cout << dp[n] << endl;
return;
}
int main() {
solve();
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <vector>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<bool> a(n, true);
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = false;
}
vector<unsigned long long int> dp(n + 1, 0);
dp[0] = 1;
for (int now = 0; now < n; now++) {
for (int next = now + 1; next <= min(n, now + 2); next++) {
if (a[next] == true) {
dp[next] += dp[now];
dp[next] %= 1000000007;
}
}
}
cout << dp[n] << endl;
return;
}
int main() {
solve();
return 0;
}
| [
"expression.operation.compare.replace.remove",
"assignment.replace.add",
"misc.typo"
] | 825,768 | 825,769 | u489302942 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long k;
bool ng[n + 1];
for (long long i = 0; i < n; i++) {
ng[i] = false;
}
for (long long i = 0; i < m; i++) {
cin >> k;
ng[k] = true;
}
long long ans[n + 1];
ans[0] = 0;
ans[1] = 1;
ans[2] = 2;
if (ng[1]) {
ans[1] = 0;
ans[2] = 1;
}
if (ng[2]) {
ans[2] = 0;
}
for (long long i = 1; i < n; i++) {
ans[i] %= 1000000007;
ans[i + 1] %= 1000000007;
ans[i + 2] = ans[i + 1] + ans[i];
if (ng[i])
ans[i + 2] -= ans[i];
if (ng[i + 1])
ans[i + 2] -= ans[i + 1];
ans[i + 2] %= 1000000007;
}
cout << ans[n];
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
long long k;
bool ng[n + 1];
for (long long i = 0; i < n + 1; i++) {
ng[i] = false;
}
for (long long i = 0; i < m; i++) {
cin >> k;
ng[k] = true;
}
long long ans[n + 1];
ans[0] = 0;
ans[1] = 1;
ans[2] = 2;
if (ng[1]) {
ans[1] = 0;
ans[2] = 1;
}
if (ng[2]) {
ans[2] = 0;
}
for (long long i = 1; i < n; i++) {
ans[i] %= 1000000007;
ans[i + 1] %= 1000000007;
ans[i + 2] = ans[i + 1] + ans[i];
if (ng[i])
ans[i + 2] -= ans[i];
if (ng[i + 1])
ans[i + 2] -= ans[i + 1];
ans[i + 2] %= 1000000007;
}
cout << ans[n];
}
| [
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 825,776 | 825,777 | u371051907 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
const int MOD = 1000000007;
int N, M;
cin >> N >> M;
vector<int> dp(N + 1);
vector<bool> ko(N + 1, false);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
ko[a] = true;
}
dp[0] = 1;
if (ko[1])
dp[1] = 0;
else
dp[0] = 1;
if (N > 1) {
for (int i = 2; i <= N; i++) {
if (ko[i])
dp[i] = 0;
else
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
}
cout << dp[N] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
const int MOD = 1000000007;
int N, M;
cin >> N >> M;
vector<int> dp(N + 1);
vector<bool> ko(N + 1, false);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
ko[a] = true;
}
dp[0] = 1;
if (ko[1])
dp[1] = 0;
else
dp[1] = 1;
if (N > 1) {
for (int i = 2; i <= N; i++) {
if (ko[i])
dp[i] = 0;
else
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
}
cout << dp[N] << endl;
return 0;
} | [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 825,781 | 825,782 | u814663076 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vc = vector<char>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using vll = vector<long long>;
using vpii = vector<pair<int, int>>;
using vvi = vector<vector<int>>;
using vvc = vector<vector<char>>;
using vvs = vector<vector<string>>;
using vvb = vector<vector<bool>>;
using pii = pair<int, int>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, n) for (int i = 1; i <= (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rreps(i, n) for (int i = (int)(n); i > 0; i--)
#define FOR(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
#define RFOR(i, a, b) for (int i = (int)(a); i >= (int)(b); i--)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define call(x) (x).cbegin(), (x).cend()
#define MAX(x) *max_element(all(x))
#define MIN(x) *min_element(all(x))
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 (b < a) {
a = b;
return 1;
}
return 0;
}
const int INF = INT_MAX;
const int MOD = 1000000007;
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int main() {
int N, M;
cin >> N >> M;
vb a(M + 1, false);
rep(i, M) {
int x;
cin >> x;
a[x] = true;
}
vll dp(N + 1);
dp[0] = 1;
if (a[1]) {
dp[1] = 0;
} else {
dp[1] = 1;
}
FOR(i, 2, N) {
if (a[i]) {
dp[i] = 0;
} else {
dp[i] = dp[i - 2] + dp[i - 1];
dp[i] %= MOD;
}
}
cout << dp[N] << endl;
}
// 0段目からi段目までの行き方の総数
// func(i) = func(i-1) + func(i-2)
// func(0) = 1, func(1) = 1
// i段目が行き止まりの時func(i) = 0
// int func(int i, vector<int> &a, vector<int> &memo) {
// if (a[i] == 1) return 0;
// if (i == 0 || i == 1) return 1;
// if (memo[i] != -1) return memo[i];
// memo[i] = (func(i-1, a, memo) + func(i-2, a, memo))%MOD;
// return memo[i];
// }
// int main() {
// int n, m; cin >> n >> m;
// vector<int> a(n+1, 0);
// rep(i,m){
// int x; cin >> x;
// a[x] = 1;
// }
// vector<int> memo(n+1, -1);
// int ans = func(n, a, memo);
// cout << ans << endl;
// }
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vc = vector<char>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using vll = vector<long long>;
using vpii = vector<pair<int, int>>;
using vvi = vector<vector<int>>;
using vvc = vector<vector<char>>;
using vvs = vector<vector<string>>;
using vvb = vector<vector<bool>>;
using pii = pair<int, int>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, n) for (int i = 1; i <= (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rreps(i, n) for (int i = (int)(n); i > 0; i--)
#define FOR(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
#define RFOR(i, a, b) for (int i = (int)(a); i >= (int)(b); i--)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define call(x) (x).cbegin(), (x).cend()
#define MAX(x) *max_element(all(x))
#define MIN(x) *min_element(all(x))
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 (b < a) {
a = b;
return 1;
}
return 0;
}
const int INF = INT_MAX;
const int MOD = 1000000007;
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int main() {
int N, M;
cin >> N >> M;
vb broken(N + 1, false);
rep(i, M) {
int x;
cin >> x;
broken[x] = true;
}
vll dp(N + 1);
dp[0] = 1;
if (broken[1]) {
dp[1] = 0;
} else {
dp[1] = 1;
}
FOR(i, 2, N) {
if (broken[i]) {
dp[i] = 0;
} else {
dp[i] = dp[i - 2] + dp[i - 1];
dp[i] %= MOD;
}
}
cout << dp[N] << endl;
} | [
"variable_declaration.name.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.variable.change",
"control_flow.branch.if.condition.change"
] | 825,786 | 825,787 | u009414205 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rrep(i, a, b) for (int i = (int)(a); i >= (int)(b); --i)
#define fore(i, a) for (auto &i : a)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define isin(i, a, b) ((a) <= (i) && (i) < (b))
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define fi first
#define se second
#define pb push_back
#define sz(a) (int)(a).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
using ll = long long;
using unit = unsigned;
using ull = unsigned long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vp = vector<P>;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
template <class T> void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> void POSS(T condition) {
if (condition)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
}
template <class T> void Poss(T condition) {
if (condition)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> T gcd(T a, T b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
constexpr double eps = 1e-10;
constexpr int inf = INT_MAX / 2;
constexpr ll infl = 1LL << 60;
void _main() {
constexpr ll MOD = 1'000'000'007;
int N, M;
cin >> N >> M;
v(bool) broken(M + 1);
rep(i, 0, M) {
int a;
cin >> a;
broken[a] = true;
}
vi dp(N + 2);
dp[N] = 1;
rrep(i, N - 1, 0) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % MOD;
}
cout << dp[0] << endl;
} | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rrep(i, a, b) for (int i = (int)(a); i >= (int)(b); --i)
#define fore(i, a) for (auto &i : a)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define isin(i, a, b) ((a) <= (i) && (i) < (b))
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define fi first
#define se second
#define pb push_back
#define sz(a) (int)(a).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
using ll = long long;
using unit = unsigned;
using ull = unsigned long long;
using P = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vp = vector<P>;
void _main();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
_main();
}
template <class T> void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> void POSS(T condition) {
if (condition)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
}
template <class T> void Poss(T condition) {
if (condition)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class T> T gcd(T a, T b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
constexpr double eps = 1e-10;
constexpr int inf = INT_MAX / 2;
constexpr ll infl = 1LL << 60;
void _main() {
constexpr ll MOD = 1'000'000'007;
int N, M;
cin >> N >> M;
v(bool) broken(N + 1);
rep(i, 0, M) {
int a;
cin >> a;
broken[a] = true;
}
vi dp(N + 2);
dp[N] = 1;
rrep(i, N - 1, 0) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % MOD;
}
cout << dp[0] << endl;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 825,809 | 825,810 | u430494842 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
#define mod (1000000007)
void solve() {
int n, m;
cin >> n >> m;
vector<bool> a(n, 0);
REP(i, m) {
int x;
cin >> x;
a[x] = 1;
}
int dp[n];
dp[0] = 1;
dp[1] = a[1] ? 0 : 1;
rep(i, 2, n)(dp[i] = a[i] ? 0 : dp[i - 1] + dp[i - 2]) %= mod;
cout << dp[n - 1] << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
#define mod (1000000007)
void solve() {
int n, m;
cin >> n >> m;
n++;
vector<bool> a(n, 0);
REP(i, m) {
int x;
cin >> x;
a[x] = 1;
}
int dp[n];
dp[0] = 1;
dp[1] = a[1] ? 0 : 1;
rep(i, 2, n)(dp[i] = a[i] ? 0 : dp[i - 1] + dp[i - 2]) %= mod;
cout << dp[n - 1] << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | [
"expression.unary.arithmetic.add"
] | 825,811 | 825,812 | u973991908 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define SORT(c) sort((c).begin(), (c).end())
#define MOD 1000000007
// S.size() 配列名.Length()
using namespace std;
typedef unsigned long long ll;
int main(void) {
int n, m;
cin >> n >> m;
vector<bool> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(n + 2);
dp[n] = 1;
for (int i = n - 1; i >= 0; --i) {
if (broken[i])
dp[i] = 0;
else
dp[i] = dp[i + 1] + dp[i + 2];
}
cout << dp[0] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define SORT(c) sort((c).begin(), (c).end())
#define MOD 1000000007 // S.size() 配列名.Length()
using namespace std;
typedef unsigned long long ll;
int main(void) {
int n, m;
cin >> n >> m;
vector<bool> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(n + 2);
dp[n] = 1;
for (int i = n - 1; i >= 0; --i) {
if (broken[i])
dp[i] = 0;
else
dp[i] = (dp[i + 1] + dp[i + 2]) % MOD;
}
cout << dp[0] << endl;
return 0;
}
| [
"assignment.change"
] | 825,817 | 825,818 | u174509352 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<ll> n(N);
vector<bool> m(N + 5);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
m.at(a) = true;
}
for (int i = 0; i < N; i++) {
if (i == 0) {
if (m.at(1))
n.at(0) = 0;
else
n.at(0) = 1;
} else if (i == 1) {
if (m.at(2))
n.at(1) = 1;
else
n.at(1) = n.at(0) + 1;
} else {
if (m.at(i + 1))
n.at(i) = 0;
else {
n.at(i) = n.at(i - 1) + n.at(i - 2);
n.at(i) %= 1000000007;
}
}
}
cout << n.at(N - 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<ll> n(N);
vector<bool> m(N + 5);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
m.at(a) = true;
}
for (int i = 0; i < N; i++) {
if (i == 0) {
if (m.at(1))
n.at(0) = 0;
else
n.at(0) = 1;
} else if (i == 1) {
if (m.at(2))
n.at(1) = 0;
else
n.at(1) = n.at(0) + 1;
} else {
if (m.at(i + 1))
n.at(i) = 0;
else {
n.at(i) = n.at(i - 1) + n.at(i - 2);
n.at(i) %= 1000000007;
}
}
}
cout << n.at(N - 1) << endl;
} | [
"literal.number.change",
"assignment.value.change"
] | 825,824 | 825,825 | u842939260 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define PRINT(item) cout << (item) << endl;
#define PRINT_VEC(V) \
for (auto v : (V)) \
cout << v << ' ';
const int MOD = 1000000007;
/* cout << fixed << setprecision(10) << decimal << endl; */
int main() {
/* code */
int N, M;
cin >> N >> M;
vector<bool> isSafe(N + 1, true);
REP(i, M) {
int a;
cin >> a;
isSafe[a] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 0;
if (isSafe[1])
dp[1] = 1;
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 << dp[N] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define PRINT(item) cout << (item) << endl;
#define PRINT_VEC(V) \
for (auto v : (V)) \
cout << v << ' ';
const int MOD = 1000000007;
/* cout << fixed << setprecision(10) << decimal << endl; */
int main() {
/* code */
int N, M;
cin >> N >> M;
vector<bool> isSafe(N + 1, true);
REP(i, M) {
int a;
cin >> a;
isSafe[a] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
if (isSafe[1])
dp[1] = 1;
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 << dp[N] << endl;
return 0;
} | [
"literal.number.change",
"assignment.value.change"
] | 825,830 | 825,831 | u223960644 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<int> oks(N + 1, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
oks[a] = false;
}
vector<long long int> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; now < min(N, now + 2); next++) {
if (oks[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<int> oks(N + 1, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
oks[a] = false;
}
vector<long long 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 (oks[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 825,842 | 825,843 | u745267317 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<int> oks(N + 1, true);
for (int i = 0; i < M; i++) {
int a = 0;
cin >> a;
oks[a] = false;
}
vector<long long int> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; now < min(N, now + 2); next++) {
if (oks[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<int> oks(N + 1, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
oks[a] = false;
}
vector<long long 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 (oks[next]) {
dp[next] += dp[now];
dp[next] %= mod;
}
}
}
cout << dp[N] << endl;
return 0;
} | [
"control_flow.loop.for.condition.change"
] | 825,844 | 825,843 | u745267317 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
typedef long long ll;
#define vint vector<int>
#define vstring vector<string>
int main() {
ll a, b;
cin >> a >> b;
vector<ll> A(a);
vint B(a);
rep(i, b) {
int c;
cin >> c;
B[c - 1] = 1;
} // Bのi番目が1の時i+1段目の床が抜けている
// Aのi番目がi+1段目までの総数を示している
for (int i = 0; i < a; i++) {
if (i == 0) {
if (B[i] == 0)
A[i] = 1;
else
A[i] = 0;
} else if (i == 1) {
if (B[i] == 0)
A[i] = A[i - 1] + 1;
else
A[i] = 0;
} else {
if (B[i] == 0)
A[i] = A[i - 1] + A[i - 2];
else
A[i] = 0;
}
}
cout << A[a - 1] % 1000000007 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
typedef long long ll;
#define vint vector<int>
#define vstring vector<string>
int main() {
ll a, b;
cin >> a >> b;
vector<ll> A(a);
vint B(a);
rep(i, b) {
int c;
cin >> c;
B[c - 1] = 1;
} // Bのi番目が1の時i+1段目の床が抜けている
// Aのi番目がi+1段目までの総数を示している
for (int i = 0; i < a; i++) {
if (i == 0) {
if (B[i] == 0)
A[i] = 1;
else
A[i] = 0;
} else if (i == 1) {
if (B[i] == 0)
A[i] = A[i - 1] + 1;
else
A[i] = 0;
} else {
if (B[i] == 0)
A[i] = (A[i - 1] + A[i - 2]) % 1000000007;
else
A[i] = 0;
}
}
cout << A[a - 1] % 1000000007 << endl;
} | [
"assignment.change"
] | 825,845 | 825,846 | u613960672 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
typedef long long ll;
#define vint vector<int>
#define vstring vector<string>
int main() {
ll a, b;
cin >> a >> b;
vector<ll> A(a);
vint B(a);
rep(i, b) {
int c;
cin >> c;
B[c - 1] = 1;
}
for (int i = 0; i < a; i++) {
if (i == 0) {
if (B[i] == 0)
A[i] = 1;
else
A[i] = 0;
} else if (i == 0) {
if (B[i] == 0)
A[i] = A[i - 1] + 1;
else
A[i] = 0;
} else {
if (B[i] == 0)
A[i] = A[i - 1] + A[i - 2];
else
A[i] = 0;
}
}
cout << A[a - 1] % 1000000007 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
typedef long long ll;
#define vint vector<int>
#define vstring vector<string>
int main() {
ll a, b;
cin >> a >> b;
vector<ll> A(a);
vint B(a);
rep(i, b) {
int c;
cin >> c;
B[c - 1] = 1;
} // Bのi番目が1の時i+1段目の床が抜けている
// Aのi番目がi+1段目までの総数を示している
for (int i = 0; i < a; i++) {
if (i == 0) {
if (B[i] == 0)
A[i] = 1;
else
A[i] = 0;
} else if (i == 1) {
if (B[i] == 0)
A[i] = A[i - 1] + 1;
else
A[i] = 0;
} else {
if (B[i] == 0)
A[i] = (A[i - 1] + A[i - 2]) % 1000000007;
else
A[i] = 0;
}
}
cout << A[a - 1] % 1000000007 << endl;
} | [
"literal.number.change",
"control_flow.branch.if.condition.change",
"assignment.change"
] | 825,847 | 825,846 | u613960672 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
typedef long long ll;
#define vint vector<int>
#define vstring vector<string>
int main() {
ll a, b;
cin >> a >> b;
vector<ll> A(a);
vint B(a);
rep(i, b) {
int c;
cin >> c;
B[c - 1] = 1;
}
for (int i = 0; i < a; i++) {
if (i == 0) {
if (B[i] == 0)
A[i] = 1;
else
A[i] = 0;
} else if (i == 1) {
if (B[i] == 0)
A[i] = A[i - 1] + 1;
else
A[i] = 0;
} else {
if (B[i] == 0) {
A[i] = A[i - 1] + A[i - 2];
} else
A[i] = 0;
}
}
cout << A[a - 1] % 1000000007 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n; i++)
typedef long long ll;
#define vint vector<int>
#define vstring vector<string>
int main() {
ll a, b;
cin >> a >> b;
vector<ll> A(a);
vint B(a);
rep(i, b) {
int c;
cin >> c;
B[c - 1] = 1;
} // Bのi番目が1の時i+1段目の床が抜けている
// Aのi番目がi+1段目までの総数を示している
for (int i = 0; i < a; i++) {
if (i == 0) {
if (B[i] == 0)
A[i] = 1;
else
A[i] = 0;
} else if (i == 1) {
if (B[i] == 0)
A[i] = A[i - 1] + 1;
else
A[i] = 0;
} else {
if (B[i] == 0)
A[i] = (A[i - 1] + A[i - 2]) % 1000000007;
else
A[i] = 0;
}
}
cout << A[a - 1] % 1000000007 << endl;
} | [
"assignment.change"
] | 825,848 | 825,846 | u613960672 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
const long long MOD = (long long)1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
for (int i = 0; i < M; ++i) {
int tmp;
cin >> tmp;
ok[tmp] = false;
}
vector<long long> dp(N + 1, 0);
dp[0] = 1;
for (int i = 1; i <= N; ++i) {
if (!ok[i])
continue;
else if (i == 1)
dp[i] = 1;
dp[i] = (dp[i - 2] + dp[i - 1]) % MOD;
}
cout << dp[N] << endl;
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
const long long MOD = (long long)1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> ok(N + 1, true);
for (int i = 0; i < M; ++i) {
int tmp;
cin >> tmp;
ok[tmp] = false;
}
vector<long long> dp(N + 1, 0);
dp[0] = 1;
for (int i = 1; i <= N; ++i) {
if (!ok[i])
continue;
else if (i == 1)
dp[i] = 1;
else
dp[i] = (dp[i - 2] + dp[i - 1]) % MOD;
}
cout << dp[N] << endl;
return 0;
}
| [
"control_flow.branch.else_if.replace.remove",
"control_flow.branch.if.replace.add"
] | 825,851 | 825,852 | u854831509 | cpp |
p03013 | #include <bits/stdc++.h>
#include <map>
#include <math.h>
#include <unordered_map>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define lper(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9;
const ll INF = 4e18;
const ll dy[4] = {1, 0, -1, 0};
const ll dx[4] = {0, -1, 0, 1};
int main() {
ll N;
ll M;
cin >> N >> M;
vl vec(M);
rep(i, N + 1) {
ll a;
cin >> a;
vec.at(a) = 1;
}
ll dp[N + 1];
dp[0] = 1;
if (vec.at(1) == 1) {
dp[1] = 0;
} else if (vec.at(1) != 1) {
dp[1] = 1;
}
repl(i, 2, N + 1) {
if (vec.at(i)) {
dp[i] = 0;
continue;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
}
cout << dp[N] << endl;
}
| #include <bits/stdc++.h>
#include <map>
#include <math.h>
#include <unordered_map>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define lper(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9;
const ll INF = 4e18;
const ll dy[4] = {1, 0, -1, 0};
const ll dx[4] = {0, -1, 0, 1};
int main() {
ll N;
ll M;
cin >> N >> M;
vl vec(N + 1);
rep(i, M) {
ll a;
cin >> a;
vec.at(a) = 1;
}
ll dp[N + 1];
dp[0] = 1;
if (vec.at(1) == 1) {
dp[1] = 0;
} else if (vec.at(1) != 1) {
dp[1] = 1;
}
repl(i, 2, N + 1) {
if (vec.at(i)) {
dp[i] = 0;
continue;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
}
cout << dp[N] << endl;
}
| [
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 825,859 | 825,860 | u978260507 | cpp |
p03013 | #include <algorithm>
#include <cmath> //abs()かfabs()で少数絶対値
#include <cstdlib> //abs()で整数絶対値
#include <iomanip> //stw(数字)で空白による桁揃え
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<bool> oks(M, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
oks[a] = false;
}
vector<long> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(now + 2, N); next++) {
if (oks[next] == true) {
dp[next] += dp[now];
dp[next] %= 1000000007;
}
}
}
cout << dp[N] << endl;
return 0;
} | #include <algorithm>
#include <cmath> //abs()かfabs()で少数絶対値
#include <cstdlib> //abs()で整数絶対値
#include <iomanip> //stw(数字)で空白による桁揃え
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(void) {
int N, M;
cin >> N >> M;
vector<bool> oks(N + 1, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
oks[a] = false;
}
vector<long> dp(N + 1);
dp[0] = 1;
for (int now = 0; now < N; now++) {
for (int next = now + 1; next <= min(now + 2, N); next++) {
if (oks[next] == true) {
dp[next] += dp[now];
dp[next] %= 1000000007;
}
}
}
cout << dp[N] << endl;
return 0;
} | [
"assignment.change"
] | 825,876 | 825,877 | u022890424 | cpp |
p03013 |
// C - Typical Stairs
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
const int MOD = 1e9 + 7;
ll dp[100001];
int main() {
int N, M;
cin >> N >> M;
int a;
for (int i = 0; i < M; i++) {
cin >> a;
dp[a] = -1;
}
dp[0] = 1;
if (dp[a] == -1) {
dp[1] = 0;
} else {
dp[1] = 1;
}
for (int i = 2; i <= N; i++) {
if (dp[i] == -1) {
dp[i] = 0;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
}
cout << dp[N] << endl;
return 0;
} |
// C - Typical Stairs
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
const int MOD = 1e9 + 7;
ll dp[100001];
int main() {
int N, M;
cin >> N >> M;
int a;
for (int i = 0; i < M; i++) {
cin >> a;
dp[a] = -1;
}
dp[0] = 1;
if (dp[1] == -1) {
dp[1] = 0;
} else {
dp[1] = 1;
}
for (int i = 2; i <= N; i++) {
if (dp[i] == -1) {
dp[i] = 0;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
}
cout << dp[N] << endl;
return 0;
} | [
"identifier.replace.remove",
"literal.replace.add",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 825,897 | 825,898 | u790272146 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
int dfs(vector<int> &a, int N, int i) {
int res;
if (i > N || a[i] == 0)
return 0;
if (i == N)
return 1;
if (a[i] != -1)
return a[i];
res = dfs(a, N, i + 1) % mod + dfs(a, N, i + 2) % mod;
return a[i] = res;
}
int main() {
int N, M;
cin >> N >> M;
vector<int> a(N + 1, -1);
for (int i = 0; i < M; i++) {
int b;
cin >> b;
a[b] = 0;
}
cout << dfs(a, N, 0) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
int dfs(vector<int> &a, int N, int i) {
int res;
if (i > N || a[i] == 0)
return 0;
if (i == N)
return 1;
if (a[i] != -1)
return a[i];
res = (dfs(a, N, i + 1) % mod + dfs(a, N, i + 2) % mod) % mod;
return a[i] = res;
}
int main() {
int N, M;
cin >> N >> M;
vector<int> a(N + 1, -1);
for (int i = 0; i < M; i++) {
int b;
cin >> b;
a[b] = 0;
}
cout << dfs(a, N, 0) << endl;
} | [
"assignment.change"
] | 825,905 | 825,906 | u743714647 | cpp |
p03013 | #include <bits/stdc++.h>
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] = 1;
}
vector<int> dp(n + 2);
dp[n] = 1;
int x = 1000000007;
for (int i = n - 1; i >= 0; i--) {
if (broken[i] == 1) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % x;
}
cout << dp[0] << endl;
}
| #include <bits/stdc++.h>
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);
dp[n] = 1;
int x = 1000000007;
for (int i = n - 1; i >= 0; i--) {
if (broken[i] == 1) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % x;
}
cout << dp[0] << endl;
}
| [
"expression.operation.binary.remove"
] | 825,915 | 825,916 | u931071094 | cpp |
p03013 | #include <bits/stdc++.h>
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 = 0;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 1);
dp[n] = 1;
int x = 1000000007;
for (int i = n - 1; i >= 0; i--) {
if (broken[i] == 1) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % x;
}
cout << dp[0] << endl;
}
| #include <bits/stdc++.h>
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);
dp[n] = 1;
int x = 1000000007;
for (int i = n - 1; i >= 0; i--) {
if (broken[i] == 1) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % x;
}
cout << dp[0] << endl;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 825,917 | 825,916 | u931071094 | cpp |
p03013 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repf(i, m, n) for (int i = (m); i < (n); i++)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
//////////////////////////////////////////////////
int main() {
ll n, m, x;
cin >> n >> m;
set<ll> a;
rep(i, m) {
cin >> x;
a.insert(x);
}
vector<ll> dp(n + 1, 0);
dp[0] = 1;
rep(i, n) {
if (a.count(i + 1) > 0)
dp[i + 1] = 0;
else if (i > 0)
dp[i + 1] = dp[i] + dp[i - 1];
else
dp[i + 1] = dp[i];
}
cout << dp[n] << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repr(i, n) for (int i = (n); i >= 0; i--)
#define repf(i, m, n) for (int i = (m); i < (n); i++)
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
//////////////////////////////////////////////////
int main() {
ll n, m, x;
cin >> n >> m;
set<ll> a;
rep(i, m) {
cin >> x;
a.insert(x);
}
vector<ll> dp(n + 1, 0);
dp[0] = 1;
rep(i, n) {
if (a.count(i + 1) > 0)
dp[i + 1] = 0;
else if (i > 0)
dp[i + 1] = (dp[i] + dp[i - 1]) % 1000000007;
else
dp[i + 1] = dp[i];
}
cout << dp[n] << endl;
return 0;
}
| [
"assignment.change"
] | 825,930 | 825,931 | u787696070 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define l long long
const l e = 1e9 + 7;
int main() {
int n, m, d;
cin >> n >> m;
int a[m + 1] = {0};
for (int i = 0; i < m; i++) {
cin >> d;
a[d] = 1;
}
l dp[n + 1] = {0};
dp[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++) {
if (a[j] == 0) {
dp[j] += dp[i];
dp[j] %= e;
}
}
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define l long long
const l e = 1e9 + 7;
int main() {
int n, m, d;
cin >> n >> m;
int a[n + 1] = {0};
for (int i = 0; i < m; i++) {
cin >> d;
a[d] = 1;
}
l dp[n + 1] = {0};
dp[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++) {
if (a[j] == 0) {
dp[j] += dp[i];
dp[j] %= e;
}
}
}
cout << dp[n] << endl;
} | [
"identifier.change",
"expression.operation.binary.change"
] | 825,940 | 825,941 | u269804852 | cpp |
p03013 | #include <bits/stdc++.h>
#define fst first
#define snd second
#define rep(n) for (lint I = 0; (I) < (lint)(n); ++(I))
#define repeat(i, n) for (lint i = 0; (i) < (lint)(n); ++(i))
#define repeat_to(i, n) for (lint i = 0; (i) <= (lint)(n); ++(i))
#define repeat_from(i, m, n) for (lint i = (m); (i) < (lint)(n); ++(i))
#define repeat_from_to(i, m, n) for (lint i = (m); (i) <= (lint)(n); ++(i))
#define repeat_reverse_from_to(i, m, n) \
for (lint i = (m); (i) >= (lint)(n); --(i))
#define el cout << endl
#define es cout << " "
#define dump(x) cout << " " << #x << "=" << x
#define pdump(p) cout << " " << #p << "=(" << p.fst << "," << p.snd << ")"
#define vdump(v) \
for (size_t I = 0; I < v.size(); ++I) { \
cout << " " << #v << "[" << I << "]=" << v[I]; \
} \
cout << endl
using namespace std;
using lint = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<lint, lint>;
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
int main(void) {
int n;
cin >> n;
vector<bool> b(n + 1, false);
int m;
cin >> m;
repeat(i, m) {
int t;
cin >> t;
b[t] = true;
}
vector<int> dp(n + 1, 0);
const int MOD = 1e9 + 7;
dp[0] = dp[1] = 1;
if (n == 1) {
cout << 1 << endl;
return 0;
}
if (dp[1])
dp[1] = 0;
repeat_from_to(i, 2, n) {
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= MOD;
if (b[i])
dp[i] = 0;
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define fst first
#define snd second
#define rep(n) for (lint I = 0; (I) < (lint)(n); ++(I))
#define repeat(i, n) for (lint i = 0; (i) < (lint)(n); ++(i))
#define repeat_to(i, n) for (lint i = 0; (i) <= (lint)(n); ++(i))
#define repeat_from(i, m, n) for (lint i = (m); (i) < (lint)(n); ++(i))
#define repeat_from_to(i, m, n) for (lint i = (m); (i) <= (lint)(n); ++(i))
#define repeat_reverse_from_to(i, m, n) \
for (lint i = (m); (i) >= (lint)(n); --(i))
#define el cout << endl
#define es cout << " "
#define dump(x) cout << " " << #x << "=" << x
#define pdump(p) cout << " " << #p << "=(" << p.fst << "," << p.snd << ")"
#define vdump(v) \
for (size_t I = 0; I < v.size(); ++I) { \
cout << " " << #v << "[" << I << "]=" << v[I]; \
} \
cout << endl
using namespace std;
using lint = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<lint, lint>;
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
int main(void) {
int n;
cin >> n;
vector<bool> b(n + 1, false);
int m;
cin >> m;
repeat(i, m) {
int t;
cin >> t;
b[t] = true;
}
vector<int> dp(n + 1, 0);
const int MOD = 1e9 + 7;
dp[0] = dp[1] = 1;
if (n == 1) {
cout << 1 << endl;
return 0;
}
if (b[1])
dp[1] = 0;
repeat_from_to(i, 2, n) {
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= MOD;
if (b[i])
dp[i] = 0;
}
cout << dp[n] << endl;
return 0;
}
| [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 825,947 | 825,948 | u674342364 | cpp |
p03013 | #include <bits/stdc++.h>
using ll = long long int;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> flag(N + 1, true);
vector<ll> dp(N + 1, 0);
for (int i = 0; i < M; i++) {
int index;
cin >> index;
flag[index] = false;
}
dp[0] = 1;
if (flag[1]) {
dp[1] = dp[0];
} else {
dp[1] = 0;
}
for (int i = 2; i <= N; i++) {
if (flag[i]) {
dp[i] = dp[i - 1] + dp[i - 2];
} else {
dp[i] = 0;
}
}
cout << dp[N] % 1000000007 << endl;
return 0;
} | #include <bits/stdc++.h>
using ll = long long int;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> flag(N + 1, true);
vector<ll> dp(N + 1, 0);
for (int i = 0; i < M; i++) {
int index;
cin >> index;
flag[index] = false;
}
dp[0] = 1;
if (flag[1]) {
dp[1] = dp[0];
} else {
dp[1] = 0;
}
for (int i = 2; i <= N; i++) {
if (flag[i]) {
dp[i] = (dp[i - 1] + dp[i - 2]) % 1000000007;
} else {
dp[i] = 0;
}
}
cout << dp[N] % 1000000007 << endl;
return 0;
} | [
"assignment.change"
] | 825,967 | 825,968 | u569272329 | cpp |
p03013 | #include <bits/stdc++.h>
using ll = long long int;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> flag(N + 1, true);
vector<ll> dp(N + 1, 0);
for (int i = 0; i < M; i++) {
int index;
cin >> index;
flag[index] = false;
}
dp[0] = 1;
if (flag[0]) {
dp[1] = dp[0];
} else {
dp[1] = 0;
}
for (int i = 2; i <= N; i++) {
if (flag[i]) {
dp[i] = dp[i - 1] + dp[i - 2];
} else {
dp[i] = 0;
}
}
cout << dp[N] % 1000000007 << endl;
return 0;
} | #include <bits/stdc++.h>
using ll = long long int;
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<bool> flag(N + 1, true);
vector<ll> dp(N + 1, 0);
for (int i = 0; i < M; i++) {
int index;
cin >> index;
flag[index] = false;
}
dp[0] = 1;
if (flag[1]) {
dp[1] = dp[0];
} else {
dp[1] = 0;
}
for (int i = 2; i <= N; i++) {
if (flag[i]) {
dp[i] = (dp[i - 1] + dp[i - 2]) % 1000000007;
} else {
dp[i] = 0;
}
}
cout << dp[N] % 1000000007 << endl;
return 0;
} | [
"literal.number.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change",
"assignment.change"
] | 825,969 | 825,968 | u569272329 | cpp |
p03013 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, k, n) for (int i = (k); i < (int)(n); i++)
#define all(i, n) (i), (i + n)
int dx4[4] = {1, 0, -1, 0};
int dy4[4] = {0, -1, 0, 1};
int dx8[8] = {1, 0, -1, 1, -1, 1, 0, -1};
int dy8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
typedef pair<int, int> P;
typedef pair<string, int> SP;
typedef long long ll;
const int INF = 1e9;
const ll LLINF = 1e18;
const int MAX_V = 1e6 + 1;
const ll mod = 1000000007;
// --------------------------------------
int n, m;
vector<int> v;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
vector<bool> v(n + 1, true);
REP(i, m) {
int a;
cin >> a;
v[a] = false;
}
vector<int> memo(n + 1, 0);
memo[0] = 1;
FOR(i, 2, n + 1) {
if (v[i]) {
if (i == 1)
memo[i] = memo[i - 1] % mod;
else
memo[i] = (memo[i - 1] + memo[i - 2]) % mod;
} else {
memo[i] = 0;
}
}
cout << memo[n] << endl;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define RREP(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, k, n) for (int i = (k); i < (int)(n); i++)
#define all(i, n) (i), (i + n)
int dx4[4] = {1, 0, -1, 0};
int dy4[4] = {0, -1, 0, 1};
int dx8[8] = {1, 0, -1, 1, -1, 1, 0, -1};
int dy8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
typedef pair<int, int> P;
typedef pair<string, int> SP;
typedef long long ll;
const int INF = 1e9;
const ll LLINF = 1e18;
const int MAX_V = 1e6 + 1;
const ll mod = 1000000007;
// --------------------------------------
int n, m;
vector<int> v;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
vector<bool> v(n + 1, true);
REP(i, m) {
int a;
cin >> a;
v[a] = false;
}
vector<int> memo(n + 1, 0);
memo[0] = 1;
FOR(i, 1, n + 1) {
if (v[i]) {
if (i == 1)
memo[i] = memo[i - 1] % mod;
else
memo[i] = (memo[i - 1] + memo[i - 2]) % mod;
} else {
memo[i] = 0;
}
}
cout << memo[n] << endl;
}
| [
"literal.number.change",
"call.arguments.change"
] | 825,972 | 825,973 | u502772848 | cpp |
p03013 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
typedef long long ll;
const ll LL_MAX(1LL << 60);
#define rep(i, s, e) for (ll i = (s); i < (e); i++)
using namespace std;
const ll MOD(1000000007);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<bool> broken(n, false);
rep(i, 0, m + 1) {
ll x;
cin >> x, broken[x] = true;
}
// rep(i,0,n)
// cout <<broken[i] << endl;
vector<ll> dp(n + 10);
dp[0] = 1;
rep(i, 0, n) {
if (!broken[i + 1])
dp[i + 1] += dp[i], dp[i + 1] = dp[i + 1] % MOD;
if (!broken[i + 2])
dp[i + 2] += dp[i], dp[i + 2] = dp[i + 2] % MOD;
}
cout << dp[n] << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
typedef long long ll;
const ll LL_MAX(1LL << 60);
#define rep(i, s, e) for (ll i = (s); i < (e); i++)
using namespace std;
const ll MOD(1000000007);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<bool> broken(n, false);
rep(i, 1, m + 1) {
ll x;
cin >> x, broken[x] = true;
}
// rep(i,0,n)
// cout <<broken[i] << endl;
vector<ll> dp(n + 10);
dp[0] = 1;
rep(i, 0, n) {
if (!broken[i + 1])
dp[i + 1] += dp[i], dp[i + 1] = dp[i + 1] % MOD;
if (!broken[i + 2])
dp[i + 2] += dp[i], dp[i + 2] = dp[i + 2] % MOD;
}
cout << dp[n] << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change"
] | 825,974 | 825,975 | u778668639 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = ((int)(n)); i > 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define SORT(c) sort((c).begin(), (c).end())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define REVSORT(c) \
SORT(c); \
REVERSE(c)
#define ALL(x) (x).begin(), (x).end()
#define INF 1e9
const long long MOD = 10e9 + 7;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<ll> dp(N + 1, 0);
vector<bool> ch(N + 1, true);
rep(i, M) {
ll a;
cin >> a;
ch[a] = false;
}
dp[0] = 1;
if (ch[1])
dp[1] = dp[0];
if (ch[2])
dp[2] = dp[0] + dp[1];
for (ll i = 3; i <= N; i++) {
if (ch[i])
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
cout << dp[N] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = ((int)(n)); i > 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define SORT(c) sort((c).begin(), (c).end())
#define REVERSE(c) reverse((c).begin(), (c).end())
#define REVSORT(c) \
SORT(c); \
REVERSE(c)
#define ALL(x) (x).begin(), (x).end()
#define INF 1e9
const long long MOD = 1000000007;
typedef long long ll;
int main() {
ll N, M;
cin >> N >> M;
vector<ll> dp(N + 1, 0);
vector<bool> ch(N + 1, true);
rep(i, M) {
ll a;
cin >> a;
ch[a] = false;
}
dp[0] = 1;
if (ch[1])
dp[1] = dp[0];
if (ch[2])
dp[2] = dp[0] + dp[1];
for (ll i = 3; i <= N; i++) {
if (ch[i])
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
}
cout << dp[N] << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 825,978 | 825,979 | u615258936 | cpp |
p03013 | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long int int64;
const int64 MOD = 1000000007;
class CTypicalStairs {
public:
void solve(std::istream &in, std::ostream &out) {
int n, m, x;
in >> n >> m;
vector<bool> fb(n + 1, false);
forn(i, n) {
in >> x;
fb[x] = true;
}
vector<int64> dp(n + 1, 0);
dp[0] = 1L;
for (int i = 1; i <= n; ++i) {
if (!fb[i]) {
dp[i] = dp[i - 1];
if (i >= 2)
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
}
out << dp[n] << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
CTypicalStairs solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
} | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long int64;
const int64 MOD = 1000000007;
class CTypicalStairs {
public:
void solve(std::istream &in, std::ostream &out) {
int n, m, x;
in >> n >> m;
vector<bool> fb(n + 1, false);
forn(i, m) {
in >> x;
fb[x] = true;
}
vector<int64> dp(n + 1, 0);
dp[0] = 1L;
for (int i = 1; i <= n; ++i) {
if (!fb[i]) {
dp[i] = dp[i - 1];
if (i >= 2)
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
}
out << dp[n] << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
CTypicalStairs solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
} | [
"variable_declaration.type.narrow.change"
] | 825,998 | 825,999 | u635804867 | cpp |
p03013 | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long int64;
const int64 MOD = 1000000007;
class CTypicalStairs {
public:
void solve(std::istream &in, std::ostream &out) {
int n, m, x;
in >> n >> m;
vector<bool> fb(n + 1, false);
forn(i, n) {
in >> x;
fb[x] = true;
}
vector<int64> dp(n + 1, 0);
dp[0] = 1L;
for (int i = 1; i <= n; ++i) {
if (!fb[i]) {
dp[i] = dp[i - 1];
if (i >= 2)
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
}
out << dp[n] << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
CTypicalStairs solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
} | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long int64;
const int64 MOD = 1000000007;
class CTypicalStairs {
public:
void solve(std::istream &in, std::ostream &out) {
int n, m, x;
in >> n >> m;
vector<bool> fb(n + 1, false);
forn(i, m) {
in >> x;
fb[x] = true;
}
vector<int64> dp(n + 1, 0);
dp[0] = 1L;
for (int i = 1; i <= n; ++i) {
if (!fb[i]) {
dp[i] = dp[i - 1];
if (i >= 2)
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
}
out << dp[n] << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
CTypicalStairs solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
} | [
"call.arguments.change"
] | 826,000 | 825,999 | u635804867 | cpp |
p03013 | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long int64;
const int64 MOD = 1000000007;
class CTypicalStairs {
public:
void solve(std::istream &in, std::ostream &out) {
int n, m, x;
in >> n >> m;
vector<bool> fb(n + 1, false);
forn(i, n) {
in >> x;
fb[x] = true;
}
vector<int64> dp(n + 1, 0);
dp[0] = 1L;
for (int i = 1; i <= n; ++i) {
if (!fb[i]) {
dp[i] = dp[i - 1];
if (i >= 2)
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
}
out << dp[n] << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
CTypicalStairs solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
} | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long int64;
const int64 MOD = 1000000007;
class CTypicalStairs {
public:
void solve(std::istream &in, std::ostream &out) {
int n, m, x;
in >> n >> m;
vector<bool> fb(n + 1, false);
forn(i, m) {
in >> x;
fb[x] = true;
}
vector<int64> dp(n + 1, 0);
dp[0] = 1L;
for (int i = 1; i <= n; ++i) {
if (!fb[i]) {
dp[i] = dp[i - 1];
if (i >= 2)
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
}
out << dp[n] << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
CTypicalStairs solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
} | [] | 826,001 | 825,999 | u635804867 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
int n, m;
cin >> n >> m;
vector<bool> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = true;
}
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;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
int n, m;
cin >> n >> m;
vector<bool> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = true;
}
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;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,004 | 826,005 | u362068529 | 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 + 1);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; 0 <= i; 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; 0 <= i; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,009 | 826,010 | u142082997 | cpp |
p03013 | #include <bits/stdc++.h>
#define int long long
#define ll long long
#define rep(i, a, b) for (signed i = a; i < (b); ++i)
#define erep(i, a, b) for (signed i = a; i <= (b); ++i)
#define per(i, a, b) for (signed i = (a); i > (b); --i)
#define eper(i, a, b) for (signed i = (a); i >= b; --i)
#define fore(i, x, a) for (auto &&x : a)
#define ITR(i, b, e) for (auto i = (b); i != (e); ++i)
#define pb emplace_back
#define mp make_pair
#define ALL(x) begin(x), end(x)
#define F first
#define S second
#define debug(x) cout << #x << ": " << (x) << '\n';
const long long INF = 1001001001001001001;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
using namespace std;
using Pii = pair<int, int>;
using vii = vector<int>;
template <class T> using PS_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> using vv = vector<T>;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct edge {
int from, to, cost;
};
int dy[] = {0, 1, -1, 0};
int dx[] = {1, 0, 0, -1};
// cout << fixed << setprecision(10) << val;
int n, m, dp[100005];
vii a;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
a.resize(m);
for (int i = 0; i < m; i++) {
int t;
cin >> t;
a[t] = 1;
}
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[0] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define int long long
#define ll long long
#define rep(i, a, b) for (signed i = a; i < (b); ++i)
#define erep(i, a, b) for (signed i = a; i <= (b); ++i)
#define per(i, a, b) for (signed i = (a); i > (b); --i)
#define eper(i, a, b) for (signed i = (a); i >= b; --i)
#define fore(i, x, a) for (auto &&x : a)
#define ITR(i, b, e) for (auto i = (b); i != (e); ++i)
#define pb emplace_back
#define mp make_pair
#define ALL(x) begin(x), end(x)
#define F first
#define S second
#define debug(x) cout << #x << ": " << (x) << '\n';
const long long INF = 1001001001001001001;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
using namespace std;
using Pii = pair<int, int>;
using vii = vector<int>;
template <class T> using PS_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T> using vv = vector<T>;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
struct edge {
int from, to, cost;
};
int dy[] = {0, 1, -1, 0};
int dx[] = {1, 0, 0, -1};
// cout << fixed << setprecision(10) << val;
int n, m, dp[100005];
vii a;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
a.resize(n);
for (int i = 0; i < m; i++) {
int t;
cin >> t;
a[t] = 1;
}
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[0] << endl;
return 0;
}
| [
"identifier.change",
"call.arguments.change"
] | 826,011 | 826,012 | u394919721 | 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(M);
rep(i, M) {
int w;
cin >> w;
broken[w] = 1;
}
vector<int> a(N + 2);
a[N] = 1;
for (int i = N - 1; i >= 0; i--) {
if (broken[i]) {
a[i] = 0;
} else {
a[i] = (a[i + 1] + a[i + 2]) % 1000000007;
}
}
int ans = a[0];
cout << ans << endl;
} | #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 w;
cin >> w;
broken[w] = 1;
}
vector<int> a(N + 2);
a[N] = 1;
for (int i = N - 1; i >= 0; i--) {
if (broken[i]) {
a[i] = 0;
} else {
a[i] = (a[i + 1] + a[i + 2]) % 1000000007;
}
}
int ans = a[0];
cout << ans << endl;
} | [] | 826,047 | 826,048 | u021755470 | 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<bool> broken(M);
rep(i, M) {
int w;
cin >> w;
broken[w] = true;
}
vector<int> a(N + 2);
a[N] = 1;
for (int i = N - 1; i >= 0; i--) {
if (broken[i]) {
a[i] = 0;
} else {
a[i] = (a[i + 1] + a[i + 2]) % 1000000007;
}
}
int ans = a[0];
cout << ans << endl;
} | #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 w;
cin >> w;
broken[w] = 1;
}
vector<int> a(N + 2);
a[N] = 1;
for (int i = N - 1; i >= 0; i--) {
if (broken[i]) {
a[i] = 0;
} else {
a[i] = (a[i + 1] + a[i + 2]) % 1000000007;
}
}
int ans = a[0];
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"assignment.value.change"
] | 826,049 | 826,048 | u021755470 | 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(M);
rep(i, M) {
int w;
cin >> w;
broken[w] = 1;
}
vector<int> a(N + 2);
a[N] = 1;
for (int i = N - 1; i >= 0; i--) {
if (broken[i]) {
a[i] = 0;
} else {
a[i] = (a[i + 1] + a[i + 2]) % 1000000007;
}
}
int ans = a[0];
cout << ans << endl;
} | #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 + 1);
rep(i, M) {
int w;
cin >> w;
broken[w] = 1;
}
vector<int> a(N + 2);
a[N] = 1;
for (int i = N - 1; i >= 0; i--) {
if (broken[i]) {
a[i] = 0;
} else {
a[i] = (a[i + 1] + a[i + 2]) % 1000000007;
}
}
int ans = a[0];
cout << ans << endl;
} | [
"assignment.change"
] | 826,047 | 826,050 | u021755470 | 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<bool> broken(M);
rep(i, M) {
int w;
cin >> w;
broken[w] = true;
}
vector<int> a(N + 2);
a[N] = 1;
for (int i = N - 1; i >= 0; i--) {
if (broken[i]) {
a[i] = 0;
} else {
a[i] = (a[i + 1] + a[i + 2]) % 1000000007;
}
}
int ans = a[0];
cout << ans << endl;
} | #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 + 1);
rep(i, M) {
int w;
cin >> w;
broken[w] = 1;
}
vector<int> a(N + 2);
a[N] = 1;
for (int i = N - 1; i >= 0; i--) {
if (broken[i]) {
a[i] = 0;
} else {
a[i] = (a[i + 1] + a[i + 2]) % 1000000007;
}
}
int ans = a[0];
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"assignment.value.change"
] | 826,049 | 826,050 | u021755470 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
const int mod = 1e9 + 7; // 1,000,000,007
int main() {
int N, M;
cin >> N >> M;
vector<bool> isStep(N, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
// a段目は壊れている
isStep[a] = false;
}
// 動的計画法を用いる
// 上記のテーブル
vector<int> dp(N, 0);
// 初期化条件
dp[0] = 1;
// 2段目
if (isStep[1] == true) {
dp[1] = 1;
}
// 2段目以降はループ
for (int i = 2; i < N; i++) {
// i - 1段目から来るパターン
if (isStep[i - 1] == true) {
dp[i] += dp[i - 1]; // 通りの加算
}
// i - 2段目から来るパターン
if (isStep[i - 2 == true]) {
dp[i] += dp[i - 2]; // 通りの加算
}
dp[i] %= mod;
}
int answer = dp[N];
cout << answer << endl;
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
const int mod = 1e9 + 7; // 1,000,000,007
int main() {
int N, M;
cin >> N >> M;
vector<bool> isStep(N, true);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
// a段目は壊れている
isStep[a] = false;
}
// 動的計画法を用いる
// 上記のテーブル
vector<int> dp(N + 1, 0);
// 初期化条件 0段目
dp[0] = 1;
// 1段目
if (isStep[1] == true) {
dp[1] = 1;
}
// 2段目以降はループ
for (int i = 2; i <= N; i++) {
// i - 1段目から来るパターン
if (isStep[i - 1] == true) {
dp[i] += dp[i - 1]; // 通りの加算
}
// i - 2段目から来るパターン
if (isStep[i - 2] == true) {
dp[i] += dp[i - 2]; // 通りの加算
}
dp[i] %= mod;
}
int answer = dp[N];
cout << answer << endl;
return 0;
} | [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.branch.if.condition.change"
] | 826,076 | 826,077 | u865500049 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
ll dp[100010]; // ans
ll mm[100010]; // unsafe points
bool vis[100010];
ll rec(ll n) {
if (vis[n])
return dp[n];
vis[n] = true;
if (mm[n])
return dp[n] = 0;
if (n == 0)
return dp[n] = 1;
if (n >= 2)
return dp[n] = (rec(n - 1) + rec(n - 2)) % mod;
return rec(n - 1);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
ll n, m;
cin >> n >> m;
rep(i, m) {
ll a;
cin >> a;
mm[a] = 1;
}
cout << rec(n) << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
ll dp[100010]; // ans
ll mm[100010]; // unsafe points
bool vis[100010];
ll rec(ll n) {
if (vis[n])
return dp[n];
vis[n] = true;
if (mm[n])
return dp[n] = 0;
if (n == 0)
return dp[n] = 1;
if (n >= 2)
return dp[n] = (rec(n - 1) + rec(n - 2)) % mod;
return dp[n] = rec(n - 1);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
ll n, m;
cin >> n >> m;
rep(i, m) {
ll a;
cin >> a;
mm[a] = 1;
}
cout << rec(n) << endl;
} | [
"assignment.change"
] | 826,078 | 826,079 | u862412671 | cpp |
p03013 | // _/ _/ _/_/_/ _/
//_/_/_/_/ _/_/ _/_/_/_/ _/_/ _/ _/_/
// _/ _/ _/ _/ _/ _/ _/_/_/ _/
//_/ _/ _/ _/ _/ _/ _/ _/ _/
// _/_/ _/_/ _/_/ _/_/ _/_/ _/
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
const double pi = 3.14159265358979323846;
const int inf = 1e9;
const ll INF = 1e18;
int main() {
cin.tie(0), cout.tie(0);
ios::sync_with_stdio(false);
ll n, m, a, dp[100005] = {};
cin >> n >> m;
map<int, int> mp;
for (int i = 0; i < n; i++) {
cin >> a;
mp[a]++;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (!mp[i - 1]) {
dp[i] += dp[i - 1];
dp[i] %= MOD;
}
if (i != 1 && !mp[i - 2]) {
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
}
cout << dp[n] << endl;
} | // _/ _/ _/_/_/ _/
//_/_/_/_/ _/_/ _/_/_/_/ _/_/ _/ _/_/
// _/ _/ _/ _/ _/ _/ _/_/_/ _/
//_/ _/ _/ _/ _/ _/ _/ _/ _/
// _/_/ _/_/ _/_/ _/_/ _/_/ _/
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
const double pi = 3.14159265358979323846;
const int inf = 1e9;
const ll INF = 1e18;
int main() {
cin.tie(0), cout.tie(0);
ios::sync_with_stdio(false);
ll n, m, a, dp[100005] = {};
cin >> n >> m;
map<int, int> mp;
for (int i = 0; i < m; i++) {
cin >> a;
mp[a]++;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (!mp[i - 1]) {
dp[i] += dp[i - 1];
dp[i] %= MOD;
}
if (i != 1 && !mp[i - 2]) {
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
}
cout << dp[n] << endl;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 826,082 | 826,083 | u401900157 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60, MOD = 1e9 + 7;
const long double PI = (acos(-1));
const long double EPS = 0.0000000001;
const ll dx[] = {1, 0, -1, 0};
const ll dy[] = {0, 1, 0, -1};
#define REP(i, a, b) for (ll i = a; i < b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define m_p make_pair
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<bool> ok(m, false);
vector<ll> dp(n + 1, 0);
rep(i, m) {
ll a;
cin >> a;
ok[a] = true;
}
dp[0] = 1;
REP(i, 1, n + 1) {
if (ok[i])
continue;
if (i == 1)
dp[i] = dp[i - 1];
else
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= MOD;
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60, MOD = 1e9 + 7;
const long double PI = (acos(-1));
const long double EPS = 0.0000000001;
const ll dx[] = {1, 0, -1, 0};
const ll dy[] = {0, 1, 0, -1};
#define REP(i, a, b) for (ll i = a; i < b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define m_p make_pair
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m;
cin >> n >> m;
vector<bool> ok(n + 1, false);
vector<ll> dp(n + 1, 0);
rep(i, m) {
ll a;
cin >> a;
ok[a] = true;
}
dp[0] = 1;
REP(i, 1, n + 1) {
if (ok[i])
continue;
if (i == 1)
dp[i] = dp[i - 1];
else
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= MOD;
}
cout << dp[n] << endl;
return 0;
} | [
"assignment.change"
] | 826,105 | 826,106 | u950046716 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
ll mod = 1e9 + 7;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> stair(n + 1, true);
for (ll i = 0; i < m; i++) {
ll x;
cin >> x;
stair[x] = false;
}
ll dp[n + 1];
for (int i = 0; i < n + 1; i++)
dp[i] = 0;
dp[0] = 1;
for (ll i = 1; i < n + 1; i++) {
if (i > 1) {
if (stair[i])
dp[i] = (dp[i - 1] + dp[i - 2]) % mod;
else
dp[i] = 0;
} else {
if (dp[i])
dp[i] = dp[i - 1];
else
dp[i] = 0;
}
}
cout << dp[n] % mod << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
ll mod = 1e9 + 7;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> stair(n + 1, true);
for (ll i = 0; i < m; i++) {
ll x;
cin >> x;
stair[x] = false;
}
ll dp[n + 1];
for (int i = 0; i < n + 1; i++) {
dp[i] = 0;
}
dp[0] = 1;
for (ll i = 1; i < n + 1; i++) {
if (i > 1) {
if (stair[i])
dp[i] = (dp[i - 1] + dp[i - 2]) % mod;
else
dp[i] = 0;
} else {
if (stair[i])
dp[i] = dp[i - 1];
else
dp[i] = 0;
}
}
cout << dp[n] % mod << endl;
} | [
"identifier.change",
"control_flow.branch.if.condition.change"
] | 826,116 | 826,117 | u504800764 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
const ll mod = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n + 1, true);
ll dp[n + 1];
rep(i, m) {
int q;
cin >> q;
a[q] = false;
}
//////
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;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long ll;
const ll mod = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n + 1, true);
vector<ll> dp(n + 1);
rep(i, m) {
int q;
cin >> q;
a[q] = false;
}
//////
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;
} | [] | 826,136 | 826,137 | u981304949 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> dp(n + 2);
vector<int> broken(n);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 1;
}
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i <= 0; i--) {
if (broken[i] = 1) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> dp(n + 2);
vector<int> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = 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;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.change"
] | 826,145 | 826,146 | u147556624 | cpp |
p03013 | #include <iostream>
#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;
}
| #include <iostream>
#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;
}
| [] | 826,147 | 826,148 | u147556624 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> broken(N);
for (int i = 0; i < M; i++) {
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 <iostream>
#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;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,149 | 826,148 | u147556624 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> broken(N);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(N + 1);
const int mod = 1000000007;
dp[N] = 1;
for (int i = N - 1; N >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = dp[i + 1] + dp[i + 2] % mod;
}
cout << dp[0] << endl;
}
| #include <iostream>
#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;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"identifier.change",
"control_flow.loop.for.condition.change"
] | 826,151 | 826,148 | u147556624 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long mod = 1e9 + 7;
int N, M;
cin >> N >> M;
vector<bool> a(N + 1, true);
for (int i = 0; i < M; i++) {
int x;
cin >> x;
a[x] = false;
}
vector<long long> d(N);
d[0] = 1;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j <= min(i + 2, N); j++) {
if (a[j]) {
d[j] += d[i];
d[j] %= mod;
}
}
}
cout << d[N] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long mod = 1e9 + 7;
int N, M;
cin >> N >> M;
vector<bool> a(N + 1, true);
for (int i = 0; i < M; i++) {
int x;
cin >> x;
a[x] = false;
}
vector<long long> d(N + 1);
d[0] = 1;
for (int i = 0; i < N; i++) {
for (int j = i + 1; j <= min(i + 2, N); j++) {
if (a[j]) {
d[j] += d[i];
d[j] %= mod;
}
}
}
cout << d[N] << endl;
}
| [
"assignment.change"
] | 826,152 | 826,153 | u584139221 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> as(N + 1, true);
rep(i, M) {
int a;
cin >> a;
as[a] = false;
}
vector<int> dp(N + 1);
dp[N] = 1;
dp[N - 1] = as[N - 1] ? 1 : 0;
for (int i = N - 1; i >= 0; --i) {
if (as[i])
dp[i] = dp[i + 1] + dp[i + 2];
dp[i] %= mod;
}
cout << dp[0] << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<bool> as(N + 1, true);
rep(i, M) {
int a;
cin >> a;
as[a] = false;
}
vector<int> dp(N + 1);
dp[N] = 1;
dp[N - 1] = as[N - 1] ? 1 : 0;
for (int i = N - 2; i >= 0; --i) {
if (as[i])
dp[i] = dp[i + 1] + dp[i + 2];
dp[i] %= mod;
}
cout << dp[0] << endl;
} | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 826,158 | 826,159 | u646792990 | cpp |
p03013 | #include "bits/stdc++.h"
typedef long long ll;
using namespace std;
static const int MOD = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<int> oks(n + 1, true);
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
oks[a] = false;
}
vector<ll> 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 (oks[next]) {
dp[next] += dp[now];
dp[next] %= MOD;
}
}
}
cout << dp[n] << endl;
return 0;
}
| #include "bits/stdc++.h"
typedef long long ll;
using namespace std;
static const int MOD = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<int> oks(n + 1, true);
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
oks[a] = false;
}
vector<ll> 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 (oks[next]) {
dp[next] += dp[now];
dp[next] %= MOD;
}
}
}
cout << dp[n] << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 826,165 | 826,166 | u616461826 | cpp |
p03013 | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define all(x) (x).begin(), (x).end()
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m;
cin >> n >> m;
vector<ll> dp(n);
set<ll> se;
ll mod = 1e9 + 7;
rep(i, m) {
ll a;
cin >> a;
a--;
se.insert(a);
}
if (se.count(0))
dp[0] = 0;
else
dp[0] = 1;
dp[1] = dp[0];
if (se.count(1))
dp[1] += 0;
else
dp[1] += 1;
repi(i, 2, n) {
if (se.count(i)) {
continue;
}
dp[i] = dp[i - 1] + dp[i - 2];
// /cout<<i<<" "<<dp[i]<<endl;
dp[i] %= mod;
}
cout << dp[n - 1] << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define all(x) (x).begin(), (x).end()
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m;
cin >> n >> m;
vector<ll> dp(n);
set<ll> se;
ll mod = 1e9 + 7;
rep(i, m) {
ll a;
cin >> a;
a--;
se.insert(a);
}
if (se.count(0))
dp[0] = 0;
else
dp[0] = 1;
dp[1] = dp[0];
if (se.count(1))
dp[1] = 0;
else
dp[1] += 1;
repi(i, 2, n) {
if (se.count(i)) {
continue;
}
dp[i] = dp[i - 1] + dp[i - 2];
// /cout<<i<<" "<<dp[i]<<endl;
dp[i] %= mod;
}
cout << dp[n - 1] << endl;
return 0;
}
| [
"assignment.value.change"
] | 826,210 | 826,211 | u834415466 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> is_safe(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
is_safe[a] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
for (int i = 0; i < N; ++i) {
if (is_safe[i + 1])
dp[i + 1] += dp[i], dp[i + 1] %= MOD;
if (is_safe[i + 2])
dp[i + 2] += dp[i], dp[i + 2] %= MOD;
}
cout << dp[N] << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> is_safe(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
is_safe[a] = false;
}
vector<int> dp(N + 2, 0);
dp[0] = 1;
for (int i = 0; i < N; ++i) {
if (is_safe[i])
dp[i + 1] += dp[i], dp[i + 1] %= MOD;
if (is_safe[i])
dp[i + 2] += dp[i], dp[i + 2] %= MOD;
}
cout << dp[N] << endl;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove"
] | 826,215 | 826,216 | u912025537 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> is_safe(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
is_safe[a] = false;
}
vector<long long> dp(N + 1, 0);
dp[0] = 1;
for (int i = 0; i < N; ++i) {
if (is_safe[i])
dp[i + 1] += dp[i], dp[i + 1] %= MOD;
if (is_safe[i])
dp[i + 2] += dp[i], dp[i + 2] %= MOD;
}
cout << dp[N] << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> is_safe(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
is_safe[a] = false;
}
vector<int> dp(N + 2, 0);
dp[0] = 1;
for (int i = 0; i < N; ++i) {
if (is_safe[i])
dp[i + 1] += dp[i], dp[i + 1] %= MOD;
if (is_safe[i])
dp[i + 2] += dp[i], dp[i + 2] %= MOD;
}
cout << dp[N] << endl;
}
| [
"variable_declaration.type.primitive.change",
"variable_declaration.type.narrow.change",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,217 | 826,216 | u912025537 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> is_safe(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
is_safe[a] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
for (int i = 0; i <= N; ++i) {
if (is_safe[i])
dp[i + 1] += dp[i], dp[i + 1] %= MOD;
if (is_safe[i])
dp[i + 2] += dp[i], dp[i + 2] %= MOD;
}
cout << dp[N] << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> is_safe(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
is_safe[a] = false;
}
vector<int> dp(N + 2, 0);
dp[0] = 1;
for (int i = 0; i < N; ++i) {
if (is_safe[i])
dp[i + 1] += dp[i], dp[i + 1] %= MOD;
if (is_safe[i])
dp[i + 2] += dp[i], dp[i + 2] %= MOD;
}
cout << dp[N] << endl;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one"
] | 826,218 | 826,216 | u912025537 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> is_safe(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
is_safe[a] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
for (int i = 0; i < N; ++i) {
if (is_safe[i])
dp[i + 1] += dp[i], dp[i + 1] %= MOD;
if (is_safe[i])
dp[i + 2] += dp[i], dp[i + 2] %= MOD;
}
cout << dp[N] << endl;
} | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> is_safe(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
is_safe[a] = false;
}
vector<int> dp(N + 2, 0);
dp[0] = 1;
for (int i = 0; i < N; ++i) {
if (is_safe[i])
dp[i + 1] += dp[i], dp[i + 1] %= MOD;
if (is_safe[i])
dp[i + 2] += dp[i], dp[i + 2] %= MOD;
}
cout << dp[N] << endl;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,219 | 826,216 | u912025537 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> is_safe(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
is_safe[a] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
for (int i = 0; i < N; ++i) {
if (is_safe[i + 1] && is_safe[i])
dp[i + 1] += dp[i], dp[i + 1] %= MOD;
if (is_safe[i + 2] && is_safe[i])
dp[i + 2] += dp[i], dp[i + 2] %= MOD;
}
cout << dp[N] << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> is_safe(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
is_safe[a] = false;
}
vector<int> dp(N + 2, 0);
dp[0] = 1;
for (int i = 0; i < N; ++i) {
if (is_safe[i + 1] && is_safe[i])
dp[i + 1] += dp[i], dp[i + 1] %= MOD;
if (is_safe[i + 2] && is_safe[i])
dp[i + 2] += dp[i], dp[i + 2] %= MOD;
}
cout << dp[N] << endl;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,220 | 826,221 | u912025537 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
vector<int> broken(n + 1);
for (i = 0; i < m; ++i) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 100000007;
dp[n] = 1;
for (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>
using namespace std;
int main() {
int n, m, i;
cin >> n >> m;
vector<int> broken(n + 1);
for (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 (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;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 826,245 | 826,246 | u144029820 | cpp |
p03013 | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N, M, tmp, _max = 0, count = 0;
long long result = 1;
//入力
scanf("%d%d", &N, &M);
vector<int> A(N, 1);
vector<int> q;
for (int i = 0; i < M; i++) {
scanf("%d", &tmp);
A[tmp - 1] = 0;
}
//キューに階段の塊の数をpush
for (const auto &e : A) {
if (e == 0) {
if (count == -1) {
cout << 0 << endl;
return 0;
} else {
q.push_back(max(count, 1));
count = -1;
}
} else {
count++;
}
}
if (count > 0) {
q.push_back(count);
count = -1;
}
//一番大きい階段の塊を_maxに代入
sort(q.begin(), q.end());
_max = q.back();
//フィボナッチ数列の計算
vector<long long> fibonacci(_max);
fibonacci[0] = 1;
fibonacci[1] = 2;
for (int i = 2; i < _max; i++)
fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
//結果の計算
for (const auto &e : q)
result = result * fibonacci[e - 1] % 1000000007;
cout << result << endl;
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int N, M, tmp, _max = 0, count = 0;
long long result = 1;
//入力
scanf("%d%d", &N, &M);
vector<int> A(N, 1);
vector<int> q;
for (int i = 0; i < M; i++) {
scanf("%d", &tmp);
A[tmp - 1] = 0;
}
//キューに階段の塊の数をpush
for (const auto &e : A) {
if (e == 0) {
if (count == -1) {
cout << 0 << endl;
return 0;
} else {
q.push_back(max(count, 1));
count = -1;
}
} else {
count++;
}
}
if (count > 0) {
q.push_back(count);
count = -1;
}
//一番大きい階段の塊を_maxに代入
sort(q.begin(), q.end());
_max = q.back();
//フィボナッチ数列の計算
vector<long long> fibonacci(_max);
fibonacci[0] = 1;
fibonacci[1] = 2;
for (int i = 2; i < _max; i++)
fibonacci[i] = (fibonacci[i - 1] + fibonacci[i - 2]) % 1000000007;
//結果の計算
for (const auto &e : q)
result = result * fibonacci[e - 1] % 1000000007;
cout << result << endl;
return 0;
} | [
"assignment.change"
] | 826,263 | 826,264 | u405010758 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
;
long long dp[n + 1];
vector<bool> s(n + 1, true);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
s[a] = false;
}
for (int i = 0; i < n + 1; i++)
dp[i] = 0;
dp[0] = 1;
for (int i = 0; i < n + 1; i++) {
if (s[i] == 1) {
dp[i + 1] += dp[i];
if (i > 0)
dp[i + 1] += dp[i - 1];
}
dp[i + 1] %= 1000000007LL;
}
// for(int i=1;i<n+1;i++) cout<<dp[i]<<endl;
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
;
long long dp[n + 1];
vector<bool> s(n + 1, true);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
s[a] = false;
}
for (int i = 0; i < n + 1; i++)
dp[i] = 0;
dp[0] = 1;
for (int i = 0; i < n + 1; i++) {
if (s[i + 1] == true) {
dp[i + 1] += dp[i];
if (i > 0)
dp[i + 1] += dp[i - 1];
}
dp[i + 1] %= 1000000007LL;
}
cout << dp[n] << endl;
} | [
"control_flow.branch.if.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 826,267 | 826,268 | u877494916 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> forbidden(n + 1, false);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
forbidden[a] = true;
}
long long mod = 1e9 + 7;
vector<long long> count(n, 0);
count[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++) {
if (forbidden[j])
continue;
count[j] += count[i];
count[j] %= mod;
}
}
cout << count[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> forbidden(n + 1, false);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
forbidden[a] = true;
}
long long mod = 1e9 + 7;
vector<long long> count(n + 1, 0);
count[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++) {
if (forbidden[j])
continue;
count[j] += count[i];
count[j] %= mod;
}
}
cout << count[n] << endl;
return 0;
} | [
"assignment.change"
] | 826,269 | 826,270 | u526708273 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long mod = 1e9 + 7;
cin >> n >> m;
vector<bool> hole(m + 1, 0);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
hole[a] = true;
}
vector<long long int> count(n + 1, 0);
count[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++) {
if (hole[j])
continue;
count[j] += count[i];
count[j] %= mod;
}
}
cout << count[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long mod = 1e9 + 7;
cin >> n >> m;
vector<bool> hole(n + 1, 0);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
hole[a] = true;
}
vector<long long int> count(n + 1, 0);
count[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++) {
if (hole[j])
continue;
count[j] += count[i];
count[j] %= mod;
}
}
cout << count[n] << endl;
return 0;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 826,271 | 826,272 | u526708273 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long mod = 1e9 + 7;
cin >> n >> m;
vector<bool> hole(m + 1, 0);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
hole[a] = true;
}
vector<long long> count(n + 1, 0);
count[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++) {
if (hole[j])
continue;
count[j] += count[i];
count[j] %= mod;
}
}
cout << count[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long long mod = 1e9 + 7;
cin >> n >> m;
vector<bool> hole(n + 1, 0);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
hole[a] = true;
}
vector<long long int> count(n + 1, 0);
count[0] = 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++) {
if (hole[j])
continue;
count[j] += count[i];
count[j] %= mod;
}
}
cout << count[n] << endl;
return 0;
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"variable_declaration.type.widen.change"
] | 826,273 | 826,272 | u526708273 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <vector>
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> dp(100001, 0);
vector<int> broken(100001, 0);
dp[0] = 1;
for (int i = 0; i < m + 1; i++) {
int tmp;
cin >> tmp;
broken[tmp] = 1;
}
for (int i = 1; i < n + 1; i++) {
if (broken[i] != 1) {
if (i == 1) {
dp[1] = dp[0];
} else {
dp[i] = dp[i - 1] + dp[i - 2];
}
}
}
cout << dp[n] << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <limits.h>
#include <map>
#include <queue>
#include <vector>
#define ll long long
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> dp(100001, 0);
vector<int> broken(100001, 0);
dp[0] = 1;
for (int i = 0; i < m; i++) {
int tmp;
cin >> tmp;
broken[tmp] = 1;
}
for (int i = 1; i < n + 1; i++) {
if (broken[i] != 1) {
if (i == 1) {
dp[1] = dp[0];
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % 1000000007;
}
}
}
cout << dp[n] << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"assignment.change"
] | 826,288 | 826,289 | u145078501 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<ll, ll> P;
#define M 1000000007
#define all(a) (a).begin(), (a).end()
#define rep(i, n) reps(i, 0, n)
#define reps(i, m, n) for (int i = (m); i < (n); i++)
int main() {
ll n, m;
cin >> n >> m;
vector<bool> b(n + 1, false);
vector<ll> a(n + 1, 0);
a[0] = 1;
rep(i, m + 1) {
int c;
cin >> c;
b[c] = true;
}
reps(i, 1, n + 1) {
if (i == 1)
a[1] = 1;
else
a[i] = (a[i - 1] + a[i - 2]) % M;
if (b[i])
a[i] = 0;
}
cout << a[n];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<ll, ll> P;
#define M 1000000007
#define all(a) (a).begin(), (a).end()
#define rep(i, n) reps(i, 0, n)
#define reps(i, m, n) for (int i = (m); i < (n); i++)
int main() {
ll n, m;
cin >> n >> m;
vector<bool> b(n + 1, false);
vector<ll> a(n + 1, 0);
a[0] = 1;
rep(i, m) {
int c;
cin >> c;
b[c] = true;
}
reps(i, 1, n + 1) {
if (i == 1)
a[1] = 1;
else
a[i] = (a[i - 1] + a[i - 2]) % M;
if (b[i])
a[i] = 0;
}
cout << a[n];
} | [
"expression.operation.binary.remove"
] | 826,302 | 826,303 | u987476436 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define countof(array) (sizeof(array) / sizeof(array[0]))
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, n, s) for (int i = s; i < (n); ++i)
#define rsrep(i, n, s) for (int i = (n)-1; i >= s; --i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define aall(a) (a), (a) + countof(a) // for array sorting
#define raall(a) (a), (a) + countof(a), greater<>()
#define show(x) cout << #x << " = " << x << endl;
#define vfind(v, a) find(all(v), a) != v.end()
#define yn(f) \
{ \
if (f) \
puts("YES"); \
else \
puts("NO"); \
}
#define yns(f) \
{ \
if (f) \
puts("Yes"); \
else \
puts("No"); \
}
#define show_ary(...) \
{ \
cout << #__VA_ARGS__ << " = "; \
for (const auto &x : (__VA_ARGS__)) { \
cout << x << " "; \
} \
cout << endl; \
}
#define out_ary(...) \
{ \
for (const auto &x : (__VA_ARGS__)) { \
cout << x << " "; \
} \
cout << endl; \
}
#define argmax(v) distance((v).begin(), max_element(all(v)))
#define argmin(v) distance((v).begin(), min_element(all(v)))
#define vmax(v) *max_element(all(v))
#define vmin(v) *min_element(all(v))
typedef long long int ll;
typedef vector<int> vint;
typedef vector<float> vfloat;
typedef vector<string> vstr;
typedef vector<bool> vbool;
typedef vector<vint> vvint;
typedef vector<vstr> vvstr;
const ll LINF = 2000000000000000000ll;
const int INF = 1000000100;
const ll MOD = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vint a(n, true);
rep(i, m) {
int b;
cin >> b;
a[b] = false;
}
vector<ll> dp(n + 1);
dp[0] = 1LL;
if (a[1])
dp[1] = 1LL;
else
dp[1] = 0LL;
srep(i, n + 1, 2) {
if (a[i])
dp[i] = dp[i - 1] + dp[i - 2];
else
dp[i] = 0LL;
dp[i] = dp[i] % MOD;
}
ll ans = dp[n];
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define countof(array) (sizeof(array) / sizeof(array[0]))
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, n, s) for (int i = s; i < (n); ++i)
#define rsrep(i, n, s) for (int i = (n)-1; i >= s; --i)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define aall(a) (a), (a) + countof(a) // for array sorting
#define raall(a) (a), (a) + countof(a), greater<>()
#define show(x) cout << #x << " = " << x << endl;
#define vfind(v, a) find(all(v), a) != v.end()
#define yn(f) \
{ \
if (f) \
puts("YES"); \
else \
puts("NO"); \
}
#define yns(f) \
{ \
if (f) \
puts("Yes"); \
else \
puts("No"); \
}
#define show_ary(...) \
{ \
cout << #__VA_ARGS__ << " = "; \
for (const auto &x : (__VA_ARGS__)) { \
cout << x << " "; \
} \
cout << endl; \
}
#define out_ary(...) \
{ \
for (const auto &x : (__VA_ARGS__)) { \
cout << x << " "; \
} \
cout << endl; \
}
#define argmax(v) distance((v).begin(), max_element(all(v)))
#define argmin(v) distance((v).begin(), min_element(all(v)))
#define vmax(v) *max_element(all(v))
#define vmin(v) *min_element(all(v))
typedef long long int ll;
typedef vector<int> vint;
typedef vector<float> vfloat;
typedef vector<string> vstr;
typedef vector<bool> vbool;
typedef vector<vint> vvint;
typedef vector<vstr> vvstr;
const ll LINF = 2000000000000000000ll;
const int INF = 1000000100;
const ll MOD = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vint a(n + 1, true);
rep(i, m) {
int b;
cin >> b;
a[b] = false;
}
vector<ll> dp(n + 1);
dp[0] = 1LL;
if (a[1])
dp[1] = 1LL;
else
dp[1] = 0LL;
srep(i, n + 1, 2) {
if (a[i])
dp[i] = dp[i - 1] + dp[i - 2];
else
dp[i] = 0LL;
dp[i] = dp[i] % MOD;
}
ll ans = dp[n];
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 826,326 | 826,327 | u365512540 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define ppb pop_back
#define INF 1e18
typedef long long ll;
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
cin >> n >> m;
vector<bool> a(n);
rep(i, n + 1) a[i] = true;
rep(i, m) {
int s;
cin >> s;
a[s] = false;
}
vector<ll> fib(n);
rep(i, n + 1) fib[i] = 0;
fib[0] = 1;
fib[1] = 1;
for (int i = 2; i < n + 1; i++) {
if (!a[i]) {
// cout<<i<<" continue\n";
continue;
}
if (a[i - 2])
fib[i] += fib[i - 2];
if (a[i - 1])
fib[i] += fib[i - 1];
fib[i] %= 1000000007;
}
cout << fib[n] << endl;
// rep(i,n+1)cout<<fib[i]<<" ";
cout << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define ppb pop_back
#define INF 1e18
typedef long long ll;
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
cin >> n >> m;
vector<bool> a(n + 1);
rep(i, n + 1) a[i] = true;
rep(i, m) {
int s;
cin >> s;
a[s] = false;
}
vector<ll> fib(n + 1);
rep(i, n + 1) fib[i] = 0;
fib[0] = 1;
fib[1] = 1;
for (int i = 2; i < n + 1; i++) {
if (!a[i]) {
// cout<<i<<" continue\n";
continue;
}
if (a[i - 2])
fib[i] += fib[i - 2];
if (a[i - 1])
fib[i] += fib[i - 1];
fib[i] %= 1000000007;
}
cout << fib[n] << endl;
cout << endl;
return 0;
} | [
"assignment.change"
] | 826,332 | 826,333 | u732817215 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<bool> broken(n);
rep(i, m) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(n);
dp[n] = 1;
// ll ans=0;
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;
const int MOD = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<bool> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = true;
}
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;
}
| [
"assignment.change"
] | 826,342 | 826,343 | u506858457 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> issafe;
issafe.assign(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
issafe[a] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
if (issafe[1])
dp[1] = 1;
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;
}
dp[N] %= MOD;
cout << dp[N] << endl;
} | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> issafe;
issafe.assign(N + 1, true);
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
issafe[a] = false;
}
vector<int> dp(N + 1, 0);
dp[0] = 1;
if (issafe[1])
dp[1] = 1;
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;
}
// dp[N]%=MOD;
cout << dp[N] << endl;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 826,344 | 826,345 | u506858457 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<long long> dp(n + 1, 0);
long long t;
for (long long i = 0; i < m; i++) {
cin >> t;
dp[t] = -1;
}
dp[n] = 1;
for (long long i = n - 1; i >= 0; i--) {
if (dp[i] != -1) {
if (dp[i + 1] != -1) {
dp[i] += dp[i + 1];
}
if (dp[i + 2] != -1) {
dp[i] += dp[i + 2];
}
dp[i] = dp[i] % 1000000007;
}
}
cout << dp[0] << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
vector<long long> dp(n + 2, 0);
long long t;
for (long long i = 0; i < m; i++) {
cin >> t;
dp[t] = -1;
}
dp[n] += 1;
for (long long i = n - 1; i >= 0; i--) {
if (dp[i] != -1) {
if (dp[i + 1] != -1) {
dp[i] += dp[i + 1];
}
if (dp[i + 2] != -1) {
dp[i] += dp[i + 2];
}
dp[i] = dp[i] % 1000000007;
}
}
cout << dp[0] << "\n";
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"assignment.value.change"
] | 826,346 | 826,347 | u261237205 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
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<long long> count(n + 1, 0LL);
count[0] = 1LL;
count[1] = broken[1] ? 0LL : 1LL;
for (int i = 2; i <= n; --i) {
if (broken[i]) {
count[i] = 0;
} else {
count[i] = (count[i - 1] + count[i - 2]) % 1000000007;
}
}
cout << count[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
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<long long> count(n + 1, 0LL);
count[0] = 1LL;
count[1] = broken[1] ? 0LL : 1LL;
for (int i = 2; i <= n; ++i) {
if (broken[i]) {
count[i] = 0;
} else {
count[i] = (count[i - 1] + count[i - 2]) % 1000000007;
}
}
cout << count[n] << endl;
return 0;
}
| [] | 826,370 | 826,371 | u813181182 | cpp |
p03013 | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define INF 110000000000
#define MAX 100000
typedef long long ll;
typedef pair<ll, int> P;
int check[110000];
ll dp[110000];
int main() {
int N, M, temp;
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> temp;
check[temp]++;
}
dp[0] = 1;
for (int i = 0; i < N; i++) {
for (int j = 1; j != 3; j++) {
if (check[i + j] == 0)
dp[i + j] += dp[i];
}
dp[i] %= 1000000007;
}
cout << dp[N] << endl;
}
| #include <algorithm>
#include <bitset>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define INF 110000000000
#define MAX 100000
typedef long long ll;
typedef pair<ll, int> P;
int check[110000];
ll dp[110000];
int main() {
int N, M, temp;
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> temp;
check[temp]++;
}
dp[0] = 1;
for (int i = 0; i < N; i++) {
for (int j = 1; j != 3; j++) {
if (check[i + j] == 0) {
dp[i + j] += dp[i];
dp[i + j] %= 1000000007;
}
}
}
cout << dp[N] << endl;
}
| [
"assignment.change"
] | 826,375 | 826,376 | u591914971 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define all(vec) vec.begin(), vec.end()
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
const ll MOD = (1e9 + 7);
ll dp[100010];
ll gcd(ll x, ll y) { return y == 0 ? x : gcd(y, x % y); }
ll lcg(ll x, ll y) { return x * y / gcd(x, y); }
map<ll, ll> factor(ll n) {
map<ll, ll> ans;
ll a = 2;
while (n >= a * a) {
if (n % a == 0) {
ans[a]++;
n /= a;
} else
a++;
}
ans[n]++;
return ans;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int s, b;
cin >> s >> b;
map<int, bool> isBroken;
rep(i, s) isBroken[i] = false;
rep(i, b) {
int x;
cin >> x;
isBroken[x] = true;
}
// string ans = "Yes";
// string ans = "No";
// string ans = "YES";
// string ans = "NO";
ll ans = 0;
dp[0] = 1;
for (int i = 1; i <= s; ++i) {
if (!isBroken[i]) {
dp[i] += dp[i - 1];
if (i > 1)
dp[i] += dp[i - 2];
dp[i] % MOD;
}
}
ans = dp[s] % MOD;
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define all(vec) vec.begin(), vec.end()
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
const ll MOD = (1e9 + 7);
ll dp[100010];
ll gcd(ll x, ll y) { return y == 0 ? x : gcd(y, x % y); }
ll lcg(ll x, ll y) { return x * y / gcd(x, y); }
map<ll, ll> factor(ll n) {
map<ll, ll> ans;
ll a = 2;
while (n >= a * a) {
if (n % a == 0) {
ans[a]++;
n /= a;
} else
a++;
}
ans[n]++;
return ans;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int s, b;
cin >> s >> b;
map<int, bool> isBroken;
rep(i, s) isBroken[i] = false;
rep(i, b) {
int x;
cin >> x;
isBroken[x] = true;
}
// string ans = "Yes";
// string ans = "No";
// string ans = "YES";
// string ans = "NO";
ll ans = 0;
dp[0] = 1;
for (int i = 1; i <= s; ++i) {
if (!isBroken[i]) {
dp[i] += dp[i - 1];
if (i > 1)
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
}
ans = dp[s] % MOD;
cout << ans << endl;
} | [
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change"
] | 826,386 | 826,387 | u165267345 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define pi \
3.1415926535897932384626433832795028841971693993751058209749445923078164062
#define ll long long
#define pb push_back
#define pf push_front
#define mp make_pair
#define mt make_tuple
#define ub upper_bound
#define lb lower_bound
#define popb pop_back()
#define popf pop_front()
#define ff first
#define ss second
#define vl vector<ll>
#define vi vector<int>
#define vs vector<string>
#define vll vector<pair<ll, ll>>
#define vii vector<pair<int, int>>
#define viii vector<tuple<int, int, int>>
#define vlll vector<tuple<ll, ll, ll>>
#define vvl vector<vector<ll>>
#define vv vector<vector<int>>
#define all(v) v.begin(), v.end()
#define sqrt sqrtl
#define cbrt cbrtl
#define pll pair<ll, ll>
#define pii pair<int, int>
#define mapcl map<char, ll>
#define mapci map<char, int>
#define mapll map<ll, ll>
#define mapii map<int, int>
#define seti set<int>
ifstream fin("input.txt");
ofstream fout("output.txt");
#define FOR(i, l, r) for (int i = int(l); i < int(r); ++i)
int gcd(int a, int b) {
while (a && b)
a > b ? a %= b : b %= a;
return a + b;
}
ll pows(int a, int b) {
ll res = 1;
for (int i = 0; i < b; ++i) {
res *= a;
}
return res;
}
ll logx(ll base, ll num) {
int cnt = 0;
while (num != 1) {
num /= base;
++cnt;
}
return cnt;
}
ll divisibles(ll a, ll b, ll m) {
if (a % m == 0)
return (b / m) - (a / m) + 1;
else
return (b / m) - (a / m);
} // in [a,b]
vi vis(100001, 0);
vi adj[100001];
int main() {
std::ios::sync_with_stdio(false);
// srand(time(0));
// cin.tie(NULL);
// cout.tie(NULL);
ll n, m;
cin >> n >> m;
vl vec(100001, -1);
vec[1] = 1;
vec[2] = 2;
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
vec[x] = 0;
}
for (int i = 3; i <= n; ++i) {
if (vec[i] == -1)
vec[i] = (vec[i - 1] + vec[i - 2]) % MOD;
}
cout << vec[n] << "\n";
} | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define pi \
3.1415926535897932384626433832795028841971693993751058209749445923078164062
#define ll long long
#define pb push_back
#define pf push_front
#define mp make_pair
#define mt make_tuple
#define ub upper_bound
#define lb lower_bound
#define popb pop_back()
#define popf pop_front()
#define ff first
#define ss second
#define vl vector<ll>
#define vi vector<int>
#define vs vector<string>
#define vll vector<pair<ll, ll>>
#define vii vector<pair<int, int>>
#define viii vector<tuple<int, int, int>>
#define vlll vector<tuple<ll, ll, ll>>
#define vvl vector<vector<ll>>
#define vv vector<vector<int>>
#define all(v) v.begin(), v.end()
#define sqrt sqrtl
#define cbrt cbrtl
#define pll pair<ll, ll>
#define pii pair<int, int>
#define mapcl map<char, ll>
#define mapci map<char, int>
#define mapll map<ll, ll>
#define mapii map<int, int>
#define seti set<int>
ifstream fin("input.txt");
ofstream fout("output.txt");
#define FOR(i, l, r) for (int i = int(l); i < int(r); ++i)
int gcd(int a, int b) {
while (a && b)
a > b ? a %= b : b %= a;
return a + b;
}
ll pows(int a, int b) {
ll res = 1;
for (int i = 0; i < b; ++i) {
res *= a;
}
return res;
}
ll logx(ll base, ll num) {
int cnt = 0;
while (num != 1) {
num /= base;
++cnt;
}
return cnt;
}
ll divisibles(ll a, ll b, ll m) {
if (a % m == 0)
return (b / m) - (a / m) + 1;
else
return (b / m) - (a / m);
} // in [a,b]
vi vis(100001, 0);
vi adj[100001];
int main() {
std::ios::sync_with_stdio(false);
// srand(time(0));
// cin.tie(NULL);
// cout.tie(NULL);
ll n, m;
cin >> n >> m;
vl vec(100001, -1);
vec[0] = 1;
vec[1] = 1;
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
vec[x] = 0;
}
for (int i = 2; i <= n; ++i) {
if (vec[i] == -1)
vec[i] = (vec[i - 1] + vec[i - 2]) % MOD;
}
cout << vec[n] << "\n";
} | [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"assignment.value.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 826,388 | 826,389 | u186089447 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.