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 |
|---|---|---|---|---|---|---|---|
p03012 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans;
vector<int> t(N + 1);
for (int i = 0; i < N; i++) {
cin >> t[i];
}
int S1 = 0, S2 = 0;
for (int i = 0; i < N - 1; i++) {
for (int j = 0; j < i + 1; j++) {
S1 = S1 + t[j];
}
for (int k = i + 1; k < N; k++) {
S2 = S2 + t[k];
}
if (i == 0) {
ans = abs(S1 - S2);
} else {
if (abs(S1 - S2) < ans) {
ans = abs(S1 - S2);
}
}
S1 = 0;
S2 = 0;
}
cin >> ans;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans;
vector<int> t(N + 1);
for (int i = 0; i < N; i++) {
cin >> t[i];
}
int S1 = 0, S2 = 0;
for (int i = 0; i < N - 1; i++) {
for (int j = 0; j < i + 1; j++) {
S1 = S1 + t[j];
}
for (int k = i + 1; k < N; k++) {
S2 = S2 + t[k];
}
if (i == 0) {
ans = abs(S1 - S2);
} else {
if (abs(S1 - S2) < ans) {
ans = abs(S1 - S2);
}
}
S1 = 0;
S2 = 0;
}
cout << ans;
}
| [] | 824,750 | 824,751 | u249546633 | cpp |
p03012 | #include <algorithm>
#include <array>
#include <iostream>
#include <stdlib.h>
using namespace std;
int main() {
array<int, 100> w;
int n, s1, s2, ans;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> w.at(i);
}
ans = 10000;
int i;
for (i = 1; i < n; i++) {
s1 = 0;
s2 = 0;
for (int j = 1; j <= i; j++) {
s1 = s1 + w.at(j);
}
for (int j = i + 1; j < n; j++) {
s2 = s2 + w.at(j);
}
if (ans > abs(s2 - s1)) {
ans = abs(s2 - s1);
}
}
cout << ans << endl;
} | #include <algorithm>
#include <array>
#include <iostream>
#include <stdlib.h>
using namespace std;
int main() {
array<int, 100> w;
int n, s1, s2, ans;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> w.at(i);
}
ans = 10000;
int i;
for (i = 1; i < n; i++) {
s1 = 0;
s2 = 0;
for (int j = 0; j < i; j++) {
s1 = s1 + w.at(j);
}
for (int j = i; j < n; j++) {
s2 = s2 + w.at(j);
}
if (ans > abs(s2 - s1)) {
ans = abs(s2 - s1);
}
}
cout << ans << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 824,754 | 824,755 | u822685707 | cpp |
p03012 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define pb push_back
#define mp make_pair
#define IOS ios_base::sync_with_stdio(false), cin.tie(0);
using namespace std;
typedef long long ll;
ll a, b, k, n, sum;
const ll maxn = 105;
ll num[maxn];
int main() {
while (cin >> n) {
sum = 0;
rep1(i, n) {
cin >> num[i];
sum += num[i];
}
ll ans = 1000000005;
ll now = 0;
rep1(i, n) {
now += num[i];
ans = min(ans, abs(sum - now));
}
cout << ans << "\n";
}
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define pb push_back
#define mp make_pair
#define IOS ios_base::sync_with_stdio(false), cin.tie(0);
using namespace std;
typedef long long ll;
ll a, b, k, n, sum;
const ll maxn = 105;
ll num[maxn];
int main() {
while (cin >> n) {
sum = 0;
rep1(i, n) {
cin >> num[i];
sum += num[i];
}
ll ans = 1000000005;
ll now = 0;
rep1(i, n) {
now += num[i];
ans = min(ans, abs(sum - now - now));
}
cout << ans << "\n";
}
} | [
"assignment.change"
] | 824,756 | 824,757 | u856205835 | cpp |
p03012 | #include <bits/stdc++.h>
using namespace std;
int n, ans = 1e9, a[10005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 0; i <= 101; i++) {
int sa = 0, sb = 0;
for (int j = 1; j <= n; j++)
if (a[j] <= i)
sa += a[j];
else
sb += a[j];
ans = min(ans, abs(sa - sb));
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
int n, ans = 1e9, a[10005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i <= n; i++) {
int sa = 0, sb = 0;
for (int j = 1; j <= n; j++)
if (j <= i)
sa += a[j];
else
sb += a[j];
ans = min(ans, abs(sa - sb));
}
cout << ans;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"identifier.replace.add",
"literal.replace.remove",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"control_flow.branch.if.condition.cha... | 824,764 | 824,765 | u447610671 | cpp |
p03012 | #include <iostream>
using namespace std;
#ifdef DEBUG
#define IFD if (true)
#else
#define IFD if (false)
#endif
int main() {
int N;
int W[100];
int ans = 100000000;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> W[i];
}
for (int T = 0; T < N - 1; T++) {
int S1 = 0, S2 = 0;
for (int i = 0; i < T; i++) {
S1 += W[i];
}
for (int i = T; i < N; i++) {
S2 += W[i];
}
ans = min(ans, abs(S1 - S2));
}
cout << ans << endl;
return 0;
}
| #include <iostream>
using namespace std;
#ifdef DEBUG
#define IFD if (true)
#else
#define IFD if (false)
#endif
int main() {
int N;
int W[100];
int ans = 100000000;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> W[i];
}
for (int T = 0; T < N - 1; T++) {
int S1 = 0, S2 = 0;
for (int i = 0; i <= T; i++) {
S1 += W[i];
}
for (int i = T + 1; i < N; i++) {
S2 += W[i];
}
ans = min(ans, abs(S1 - S2));
}
cout << ans << endl;
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.off_by_one",
"expression.operation.binary.change",
"control_flow.loop.for.initializer.change"
] | 824,780 | 824,781 | u711582524 | cpp |
p03012 | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
const int MAXN = 105;
int n, a[MAXN];
long long A, r, ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i], A += a[i];
ans = A;
for (int i = 0; i < n; i++) {
r += a[i];
ans = min(ans, abs(A - (A - r)));
}
cout << ans;
} | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
const int MAXN = 105;
int n, a[MAXN];
long long A, r, ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i], A += a[i];
ans = A;
for (int i = 0; i < n; i++) {
r += a[i];
ans = min(ans, abs(r - (A - r)));
}
cout << ans;
} | [
"assignment.value.change",
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 824,782 | 824,783 | u494617175 | cpp |
p03012 | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define y0 qvya13579
#define y1 qvyb24680
#define j0 qvja13579
#define j1 qvjb24680
#define next qvne13579xt
#define prev qvpr13579ev
#define INF 1000000007
#define MOD 1000000007
#define PI acos(-1.0)
#define endl "\n"
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(false)
#define M_P make_pair
#define PU_B push_back
#define PU_F push_front
#define PO_B pop_back
#define PO_F pop_front
#define U_B upper_bound
#define L_B lower_bound
#define B_S binary_search
#define PR_Q priority_queue
#define FIR first
#define SEC second
#if __cplusplus < 201103L
#define stoi(argument_string) atoi((argument_string).c_str())
#endif
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP_R(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define FOR(i, m, n) for (int i = ((int)(m)); i < (int)(n); ++i)
#define FOR_R(i, m, n) for (int i = ((int)(m)-1); i >= (int)(n); --i)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define SIZ(x) ((int)(x).size())
#define CIN(x) cin >> (x)
#define CIN2(x, y) cin >> (x) >> (y)
#define CIN3(x, y, z) cin >> (x) >> (y) >> (z)
#define CIN4(x, y, z, w) cin >> (x) >> (y) >> (z) >> (w)
#define CIN5(x, y, z, w, u) cin >> (x) >> (y) >> (z) >> (w) >> (u)
#define SCAND(x) scanf("%d", &(x))
#define SCAND2(x, y) scanf("%d%d", &(x), &(y))
#define SCAND3(x, y, z) scanf("%d%d%d", &(x), &(y), &(z))
#define SCAND4(x, y, z, w) scanf("%d%d%d%d", &(x), &(y), &(z), &(w))
#define SCAND5(x, y, z, w, u) scanf("%d%d%d%d%d", &(x), &(y), &(z), &(w), &(u))
#define SCANLLD(x) scanf("%lld", &(x))
#define SCANLLD2(x, y) scanf("%lld%lld", &(x), &(y))
#define SCANLLD3(x, y, z) scanf("%lld%lld%lld", &(x), &(y), &(z))
#define SCANLLD4(x, y, z, w) scanf("%lld%lld%lld%lld", &(x), &(y), &(z), &(w))
#define SCANLLD5(x, y, z, w, u) \
scanf("%lld%lld%lld%lld%lld", &(x), &(y), &(z), &(w), &(u))
#define PRINTD(x) printf("%d\n", (x))
#define PRINTLLD(x) printf("%lld\n", (x))
#define DEBUG(argument) cerr << (#argument) << " : " << (argument) << "\n"
typedef long long int lli;
using namespace std;
bool compare_by_2nd(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int ctoi(char c) {
if (c >= '0' and c <= '9') {
return (int)(c - '0');
}
return -1;
}
int alphabet_pos(char c) {
if (c >= 'a' and c <= 'z') {
return (int)(c - 'a');
}
return -1;
}
int alphabet_pos_capital(char c) {
if (c >= 'A' and c <= 'Z') {
return (int)(c - 'A');
}
return -1;
}
vector<string> split(string str, char ch) {
int first = 0;
int last = str.find_first_of(ch);
if (last == string::npos) {
last = SIZ(str);
}
vector<string> result;
while (first < SIZ(str)) {
string Ssubstr(str, first, last - first);
result.push_back(Ssubstr);
first = last + 1;
last = str.find_first_of(ch, first);
if (last == string::npos) {
last = SIZ(str);
}
}
return result;
}
int gcd(int a, int b) // assuming a,b >= 1
{
if (a < b) {
return gcd(b, a);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int lcm(int a, int b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
lli pow_fast(lli x, lli n_power, lli modulus) {
if (n_power == 0) {
return 1;
}
if (n_power % 2 == 0) {
return pow_fast(x * x % modulus, n_power / 2, modulus);
}
return x * pow_fast(x, n_power - 1, modulus) % modulus;
}
struct CombinationTable {
vector<vector<long long>> val;
CombinationTable(int size)
: val(size + 1, vector<long long>(size + 1)) // constructor
{
for (int i = 0; i <= size; ++i) // note that 0 <= i <= size
{
for (int j = 0; j <= i; ++j) {
if (j == 0 or j == i) {
val[i][j] = 1LL;
} else {
val[i][j] = val[i - 1][j - 1] + val[i - 1][j];
}
}
}
}
};
struct UnionFind // size-based
{
vector<int> parent, treesize;
UnionFind(int size)
: parent(size), treesize(size, 1) // constructor
{
for (int i = 0; i < size; ++i) {
parent[i] = i;
}
}
int root(int x) {
if (parent[x] == x) {
return x;
}
return parent[x] = root(parent[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return;
}
if (treesize[x] < treesize[y]) {
parent[x] = y;
treesize[y] += treesize[x];
} else {
parent[y] = x;
treesize[x] += treesize[y];
}
}
bool sametree(int x, int y) { return root(x) == root(y); }
int gettreesize(int x) { return treesize[root(x)]; }
};
/*------------------ the end of the template -----------------------*/
signed main() {
IOS; /* making cin faster */
int N;
SCAND(N);
vector<int> W(N);
REP(i, N) { SCAND(W[i]); }
int mn = INF;
FOR(T, 1, N) {
int s1 = 0;
int s2 = 0;
REP(i, N) {
if (W[i] > T) {
s2 += W[i];
} else {
s1 += W[i];
}
}
mn = min(mn, abs(s1 - s2));
}
PRINTD(mn);
}
| #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define y0 qvya13579
#define y1 qvyb24680
#define j0 qvja13579
#define j1 qvjb24680
#define next qvne13579xt
#define prev qvpr13579ev
#define INF 1000000007
#define MOD 1000000007
#define PI acos(-1.0)
#define endl "\n"
#define IOS \
cin.tie(0); \
ios::sync_with_stdio(false)
#define M_P make_pair
#define PU_B push_back
#define PU_F push_front
#define PO_B pop_back
#define PO_F pop_front
#define U_B upper_bound
#define L_B lower_bound
#define B_S binary_search
#define PR_Q priority_queue
#define FIR first
#define SEC second
#if __cplusplus < 201103L
#define stoi(argument_string) atoi((argument_string).c_str())
#endif
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP_R(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define FOR(i, m, n) for (int i = ((int)(m)); i < (int)(n); ++i)
#define FOR_R(i, m, n) for (int i = ((int)(m)-1); i >= (int)(n); --i)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define SIZ(x) ((int)(x).size())
#define CIN(x) cin >> (x)
#define CIN2(x, y) cin >> (x) >> (y)
#define CIN3(x, y, z) cin >> (x) >> (y) >> (z)
#define CIN4(x, y, z, w) cin >> (x) >> (y) >> (z) >> (w)
#define CIN5(x, y, z, w, u) cin >> (x) >> (y) >> (z) >> (w) >> (u)
#define SCAND(x) scanf("%d", &(x))
#define SCAND2(x, y) scanf("%d%d", &(x), &(y))
#define SCAND3(x, y, z) scanf("%d%d%d", &(x), &(y), &(z))
#define SCAND4(x, y, z, w) scanf("%d%d%d%d", &(x), &(y), &(z), &(w))
#define SCAND5(x, y, z, w, u) scanf("%d%d%d%d%d", &(x), &(y), &(z), &(w), &(u))
#define SCANLLD(x) scanf("%lld", &(x))
#define SCANLLD2(x, y) scanf("%lld%lld", &(x), &(y))
#define SCANLLD3(x, y, z) scanf("%lld%lld%lld", &(x), &(y), &(z))
#define SCANLLD4(x, y, z, w) scanf("%lld%lld%lld%lld", &(x), &(y), &(z), &(w))
#define SCANLLD5(x, y, z, w, u) \
scanf("%lld%lld%lld%lld%lld", &(x), &(y), &(z), &(w), &(u))
#define PRINTD(x) printf("%d\n", (x))
#define PRINTLLD(x) printf("%lld\n", (x))
#define DEBUG(argument) cerr << (#argument) << " : " << (argument) << "\n"
typedef long long int lli;
using namespace std;
bool compare_by_2nd(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
int ctoi(char c) {
if (c >= '0' and c <= '9') {
return (int)(c - '0');
}
return -1;
}
int alphabet_pos(char c) {
if (c >= 'a' and c <= 'z') {
return (int)(c - 'a');
}
return -1;
}
int alphabet_pos_capital(char c) {
if (c >= 'A' and c <= 'Z') {
return (int)(c - 'A');
}
return -1;
}
vector<string> split(string str, char ch) {
int first = 0;
int last = str.find_first_of(ch);
if (last == string::npos) {
last = SIZ(str);
}
vector<string> result;
while (first < SIZ(str)) {
string Ssubstr(str, first, last - first);
result.push_back(Ssubstr);
first = last + 1;
last = str.find_first_of(ch, first);
if (last == string::npos) {
last = SIZ(str);
}
}
return result;
}
int gcd(int a, int b) // assuming a,b >= 1
{
if (a < b) {
return gcd(b, a);
}
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
int lcm(int a, int b) // assuming a,b >= 1
{
return a * b / gcd(a, b);
}
lli pow_fast(lli x, lli n_power, lli modulus) {
if (n_power == 0) {
return 1;
}
if (n_power % 2 == 0) {
return pow_fast(x * x % modulus, n_power / 2, modulus);
}
return x * pow_fast(x, n_power - 1, modulus) % modulus;
}
struct CombinationTable {
vector<vector<long long>> val;
CombinationTable(int size)
: val(size + 1, vector<long long>(size + 1)) // constructor
{
for (int i = 0; i <= size; ++i) // note that 0 <= i <= size
{
for (int j = 0; j <= i; ++j) {
if (j == 0 or j == i) {
val[i][j] = 1LL;
} else {
val[i][j] = val[i - 1][j - 1] + val[i - 1][j];
}
}
}
}
};
struct UnionFind // size-based
{
vector<int> parent, treesize;
UnionFind(int size)
: parent(size), treesize(size, 1) // constructor
{
for (int i = 0; i < size; ++i) {
parent[i] = i;
}
}
int root(int x) {
if (parent[x] == x) {
return x;
}
return parent[x] = root(parent[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return;
}
if (treesize[x] < treesize[y]) {
parent[x] = y;
treesize[y] += treesize[x];
} else {
parent[y] = x;
treesize[x] += treesize[y];
}
}
bool sametree(int x, int y) { return root(x) == root(y); }
int gettreesize(int x) { return treesize[root(x)]; }
};
/*------------------ the end of the template -----------------------*/
signed main() {
IOS; /* making cin faster */
int N;
SCAND(N);
vector<int> W(N);
REP(i, N) { SCAND(W[i]); }
int mn = INF;
FOR(T, 1, N) {
int s1 = 0;
int s2 = 0;
REP(i, N) {
if (i + 1 > T) {
s2 += W[i];
} else {
s1 += W[i];
}
}
mn = min(mn, abs(s1 - s2));
}
PRINTD(mn);
}
| [
"control_flow.branch.if.condition.change"
] | 824,784 | 824,785 | u900727536 | cpp |
p03012 | #include <bits/stdc++.h>
#define LL long long
#define INF 0x7FFFFFFF
using namespace std;
int nums[100 + 5];
int main() {
int n;
cin >> n;
int sum = 0;
for (int i = 0; i < n; ++i) {
cin >> nums[i];
sum = sum + nums[i];
}
int now = 0;
int ans = INF;
for (int i = 0; i < n; ++i) {
now = now + nums[i];
ans = min(ans, now * 2 - sum);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define LL long long
#define INF 0x7FFFFFFF
using namespace std;
int nums[100 + 5];
int main() {
int n;
cin >> n;
int sum = 0;
for (int i = 0; i < n; ++i) {
cin >> nums[i];
sum = sum + nums[i];
}
int now = 0;
int ans = INF;
for (int i = 0; i < n; ++i) {
now = now + nums[i];
ans = min(ans, abs(now * 2 - sum));
}
cout << ans << endl;
return 0;
} | [
"call.add",
"call.arguments.change"
] | 824,790 | 824,791 | u368384385 | cpp |
p03012 | #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, MOD = 998244353;
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
typedef long long ll;
int u, v, p, d, n, tc, q, k, l, r, c, m, b[N], cnt, curr, a[N], ans;
bool sum[N];
char s[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &a[i]);
int curr = 0;
for (int i = 0; i < n; i++) {
curr += a[i];
int othercurr = 0;
for (int j = i + 1; j < n; j++)
othercurr += a[j];
ans = min(ans, abs(othercurr - curr));
}
printf("%d\n", ans);
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, MOD = 998244353;
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
typedef long long ll;
int u, v, p, d, n, tc, q, k, l, r, c, m, b[N], cnt, curr, a[N], ans;
bool sum[N];
char s[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &a[i]);
int curr = 0;
ans = 1e9;
for (int i = 0; i < n; i++) {
curr += a[i];
int othercurr = 0;
for (int j = i + 1; j < n; j++)
othercurr += a[j];
ans = min(ans, abs(othercurr - curr));
}
printf("%d\n", ans);
}
| [
"assignment.add"
] | 824,794 | 824,795 | u318875010 | cpp |
p03012 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define popcount __builtin_popcount
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int n;
cin >> n;
int w[110];
for (int i = 0; i < n; i++)
cin >> w[i];
int ans = 1e9;
for (int t = 1; t < n; t++) {
int s1 = 0, s2 = 0;
for (int i = 0; i < n; i++) {
if (w[i] <= t)
s1 += w[i];
else
s2 += w[i];
}
ans = min(ans, abs(s1 - s2));
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define popcount __builtin_popcount
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int n;
cin >> n;
int w[110];
for (int i = 0; i < n; i++)
cin >> w[i];
int ans = 1e9;
for (int t = 0; t < n - 1; t++) {
int s1 = 0, s2 = 0;
for (int i = 0; i < n; i++) {
if (i <= t)
s1 += w[i];
else
s2 += w[i];
}
ans = min(ans, abs(s1 - s2));
}
cout << ans << endl;
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"control_flow.loop.for.condition.change",
"misc.off_by_one",
"control_flow.branch.if.condition.change"
] | 824,798 | 824,799 | u930898631 | cpp |
p03012 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repp(i, l, r) for (int i = (l); i < (r); i++)
#define per(i, n) for (int i = ((n)-1); i >= 0; i--)
#define perr(i, l, r) for (int i = ((r)-1); i >= (l); i--)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define IINF 1000000000
#define LINF 1000000000000000000
#define SP << " " <<
#define CYES cout << "Yes" << endl
#define CNO cout << "No" << endl
#define CFS \
cin.tie(0); \
ios::sync_with_stdio(false)
typedef long long LL;
typedef long double LD;
int main() {
int n;
cin >> n;
vector<int> w(n);
rep(i, n) { cin >> w[i]; }
int ans = IINF;
repp(i, 0, 101) {
int s = 0, t = 0;
rep(j, n) {
if (w[j] < i) {
s += w[j];
} else {
t += w[j];
}
}
ans = min(ans, abs(s - t));
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repp(i, l, r) for (int i = (l); i < (r); i++)
#define per(i, n) for (int i = ((n)-1); i >= 0; i--)
#define perr(i, l, r) for (int i = ((r)-1); i >= (l); i--)
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
#define IINF 1000000000
#define LINF 1000000000000000000
#define SP << " " <<
#define CYES cout << "Yes" << endl
#define CNO cout << "No" << endl
#define CFS \
cin.tie(0); \
ios::sync_with_stdio(false)
typedef long long LL;
typedef long double LD;
int main() {
int n;
cin >> n;
vector<int> w(n);
rep(i, n) { cin >> w[i]; }
int ans = IINF;
repp(i, 0, 101) {
int s = 0, t = 0;
rep(j, n) {
if (j < i) {
s += w[j];
} else {
t += w[j];
}
}
ans = min(ans, abs(s - t));
}
cout << ans << endl;
return 0;
}
| [
"control_flow.branch.if.condition.change"
] | 824,800 | 824,801 | u405923605 | cpp |
p03012 | // Last Change: 06/10/2019 18:34:40.
#include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
namespace NS {
void LoopUntilZeroInpput() {
int hogegegege = 0;
while (cin >> hogegegege && hogegegege != 0) {
}
}
} // namespace NS
int main() {
int N;
cin >> N;
vector<int> wLui(N);
int tmp = 0;
for (auto &&e : wLui) {
cin >> e;
e += tmp;
tmp = e;
}
wLui.pop_back();
const int sumAll = tmp;
int ans = 1e5;
for (auto &&e : wLui) {
ans = min(ans, sumAll - e);
}
cout << ans << endl;
// NS::LoopUntilZeroInpput();
}
| // Last Change: 06/10/2019 18:36:19.
#include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
namespace NS {
void LoopUntilZeroInpput() {
int hogegegege = 0;
while (cin >> hogegegege && hogegegege != 0) {
}
}
} // namespace NS
int main() {
int N;
cin >> N;
vector<int> wLui(N);
int tmp = 0;
for (auto &&e : wLui) {
cin >> e;
e += tmp;
tmp = e;
}
wLui.pop_back();
const int sumAll = tmp;
int ans = 1e5;
for (auto &&e : wLui) {
ans = min(ans, abs(sumAll - e - e));
}
cout << ans << endl;
// NS::LoopUntilZeroInpput();
}
| [
"call.add",
"call.arguments.add"
] | 824,804 | 824,805 | u915934642 | cpp |
p03012 | #include <bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define pb emplace_back
#define mp make_pair
#define ff first
#define ss second
typedef long long ll;
typedef long double ld;
int main() {
fast;
int n;
cin >> n;
int a[n + 1], p[n + 1];
p[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
p[i] = p[i - 1] + a[i];
}
int ans = INT_MAX, i;
for (i = 1; i < n; i++) {
ans = min(ans, abs(p[n] - 2 * p[i - 1]));
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define pb emplace_back
#define mp make_pair
#define ff first
#define ss second
typedef long long ll;
typedef long double ld;
int main() {
fast;
int n;
cin >> n;
int a[n + 1], p[n + 1];
p[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
p[i] = p[i - 1] + a[i];
}
int ans = INT_MAX, i;
for (i = 1; i < n; i++) {
ans = min(ans, abs(p[n] - 2 * p[i]));
}
cout << ans;
}
| [
"expression.operation.binary.remove"
] | 824,809 | 824,810 | u670919462 | cpp |
p03012 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
signed main() {
int n;
cin >> n;
vector<int> w(n);
vector<int> cumul(n);
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> w[i];
sum += w[i];
}
cumul[0] = w[0];
for (int i = 1; i < n; i++) {
cumul[i] = (cumul[i - 1] + w[i]);
}
int ans;
for (int i = 0; i < n; i++) {
ans = min(ans, abs(cumul[i] - (sum - cumul[i])));
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
signed main() {
int n;
cin >> n;
vector<int> w(n);
vector<int> cumul(n);
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> w[i];
sum += w[i];
}
cumul[0] = w[0];
for (int i = 1; i < n; i++) {
cumul[i] = (cumul[i - 1] + w[i]);
}
int ans = 10000;
for (int i = 0; i < n; i++) {
ans = min(ans, abs(cumul[i] - (sum - cumul[i])));
}
cout << ans << endl;
return 0;
}
| [
"variable_declaration.value.change"
] | 824,825 | 824,826 | u539199630 | cpp |
p03012 |
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define M_PI 3.14159265358979323846
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define FILL(a, x) memset(a, x, sizeof(a))
// repetition
//------------------------------------------
#define FOR(i, s, n) for (int i = s; i < (int)n; ++i)
#define REP(i, n) FOR(i, 0, n)
const LL MOD = 998244353;
int w[105];
int main() {
int n;
scanf("%d", &n);
REP(i, n) scanf("%d", &w[i]);
int ret = 1e9;
FOR(i, 1, n) {
int s1 = 0;
int s2 = 0;
REP(j, i) s1 += w[i];
FOR(j, i, n) s2 += w[i];
ret = min(ret, abs(s1 - s2));
}
printf("%d\n", ret);
return 0;
} |
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define M_PI 3.14159265358979323846
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define FILL(a, x) memset(a, x, sizeof(a))
// repetition
//------------------------------------------
#define FOR(i, s, n) for (int i = s; i < (int)n; ++i)
#define REP(i, n) FOR(i, 0, n)
const LL MOD = 1000000007;
int w[105];
int main() {
int n;
scanf("%d", &n);
REP(i, n) scanf("%d", &w[i]);
int ret = 1e9;
FOR(i, 1, n) {
int s1 = 0;
int s2 = 0;
REP(j, i) s1 += w[j];
FOR(j, i, n) s2 += w[j];
ret = min(ret, abs(s1 - s2));
}
printf("%d\n", ret);
return 0;
} | [
"literal.number.change",
"variable_declaration.value.change",
"assignment.value.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 824,837 | 824,838 | u614497125 | cpp |
p03012 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<int> w(n);
for (int i = 0; i < n; i++) {
cin >> w[i];
}
int ans = 1e9;
for (int i = 1; i < n; i++) {
int l = 0, r = 0;
for (int j = 0; j < i; j++)
l += w[j];
for (int j = i; j < n; j++)
r += w[j];
ans = min(ans, abs(l - r));
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> w(n);
for (int i = 0; i < n; i++) {
cin >> w[i];
}
int ans = 1e9;
for (int i = 1; i < n; i++) {
int l = 0, r = 0;
for (int j = 0; j < i; j++)
l += w[j];
for (int j = i; j < n; j++)
r += w[j];
ans = min(ans, abs(l - r));
}
cout << ans << endl;
return 0;
}
| [] | 824,841 | 824,842 | u457283867 | cpp |
p03012 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N;
cin >> N;
int W[N];
for (int i = 0; i < N; i++) {
cin >> W[i];
}
int min = 1000000;
for (int j = 0; j < N - 1; j++) {
int suma = 0, sumb = 0;
for (int a = 0; a <= j; a++) {
suma += W[a];
}
for (int b = j; b < N; b++) {
sumb += W[b];
}
if (abs(suma - sumb) < min)
min = abs(suma - sumb);
}
cout << min << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N;
cin >> N;
int W[N];
for (int i = 0; i < N; i++) {
cin >> W[i];
}
int min = 1000000;
for (int j = 0; j < N - 1; j++) {
int suma = 0, sumb = 0;
for (int a = 0; a <= j; a++) {
suma += W[a];
}
for (int b = j + 1; b < N; b++) {
sumb += W[b];
}
if (abs(suma - sumb) < min)
min = abs(suma - sumb);
}
cout << min << endl;
} | [
"control_flow.loop.for.initializer.change"
] | 824,855 | 824,856 | u335770593 | cpp |
p03012 | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N;
cin >> N;
int W[N];
for (int i = 0; i < N; i++) {
cin >> W[i];
}
int min = 1000000;
for (int j = 1; j < N - 1; j++) {
int suma = 0, sumb = 0;
for (int a = 0; a < j; a++) {
suma += W[a];
}
for (int b = j; b < N; b++) {
sumb += W[b];
}
if (abs(suma - sumb) < min)
min = abs(suma - sumb);
}
cout << min << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int N;
cin >> N;
int W[N];
for (int i = 0; i < N; i++) {
cin >> W[i];
}
int min = 1000000;
for (int j = 0; j < N - 1; j++) {
int suma = 0, sumb = 0;
for (int a = 0; a <= j; a++) {
suma += W[a];
}
for (int b = j + 1; b < N; b++) {
sumb += W[b];
}
if (abs(suma - sumb) < min)
min = abs(suma - sumb);
}
cout << min << endl;
} | [
"literal.number.change",
"variable_declaration.value.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operator.compare.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 824,857 | 824,856 | u335770593 | cpp |
p03012 | #include <iostream>
#include <math.h>
using namespace std;
int main() {
int l, i = 0, j = 0, w[100], min, N;
int left = 0, right = 0;
cin >> N;
for (i = 0; i < N; i++) {
cin >> w[i];
}
for (i = 0; i < N; i++) {
for (j = 0; j <= i; j++) {
left += w[j];
}
for (j = i + 1; j < N; j++) {
right += w[j];
}
if (i == 0)
min = abs(left - right);
else if (min < abs(left - right))
min = abs(left - right);
left = 0, right = 0;
}
std::cout << min << endl;
}
| #include <iostream>
#include <math.h>
using namespace std;
int main() {
int l, i = 0, j = 0, w[100], min, N;
int left = 0, right = 0;
cin >> N;
for (i = 0; i < N; i++) {
cin >> w[i];
}
for (i = 0; i < N; i++) {
for (j = 0; j <= i; j++) {
left += w[j];
}
for (j = i + 1; j < N; j++) {
right += w[j];
}
if (i == 0)
min = abs(left - right);
else if (min > abs(left - right))
min = abs(left - right);
left = 0, right = 0;
}
std::cout << min << endl;
}
| [
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 824,858 | 824,859 | u346818994 | cpp |
p03012 | #include "iostream"
using namespace std;
int main() {
/* code */
int n, s1 = 0, s2 = 0, s3, ans;
int w1[100], w2[100];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> w1[i];
s1 += w1[i];
}
s3 = s1 - w1[0];
if (w1[0] - s3 > 0) {
w2[1] = w1[0] - s3;
ans = w1[0] - s3;
} else {
w2[1] = s3 - w1[0];
ans = s3 - w1[0];
}
for (int i = 2; i < n; i++) {
for (int j = 0; j < i; j++) {
s2 += w1[j];
}
s3 = s1 - s2;
if (s2 - s3 > 0) {
w2[i] = s2 - s3;
} else {
w2[i] = s3 - s2;
}
if (w2[i] < ans) {
ans = w2[i];
}
}
cout << ans << endl;
return 0;
}
| #include "iostream"
using namespace std;
int main() {
/* code */
int n, s1 = 0, s2 = 0, s3, ans;
int w1[100], w2[100];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> w1[i];
s1 += w1[i];
}
s3 = s1 - w1[0];
if (w1[0] - s3 > 0) {
w2[1] = w1[0] - s3;
ans = w1[0] - s3;
} else {
w2[1] = s3 - w1[0];
ans = s3 - w1[0];
}
for (int i = 2; i < n; i++) {
for (int j = 0; j < i; j++) {
s2 += w1[j];
}
s3 = s1 - s2;
if (s2 - s3 > 0) {
w2[i] = s2 - s3;
} else {
w2[i] = s3 - s2;
}
if (w2[i] < ans) {
ans = w2[i];
}
s2 = 0;
}
cout << ans << endl;
return 0;
}
| [
"assignment.add"
] | 824,870 | 824,871 | u338369716 | 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 int INF = 1001001001;
const int mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<bool> v(n, false);
vector<ll> dp(n, 0);
rep(i, m) {
int a;
cin >> a;
a--;
v.at(a) = true;
}
if (!v.at(0))
dp.at(0) = 1;
if (!v.at(1))
dp.at(1) = dp.at(0) + 1;
for (int i = 2; i < n; i++) {
if (v.at(i))
continue;
dp.at(i) = (dp.at(i - 1) + dp.at(i - 2)) % mod;
}
cout << dp.at(n - 1) << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
const int INF = 1001001001;
const int mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<bool> v(n, false);
vector<ll> dp(n, 0);
rep(i, m) {
int a;
cin >> a;
a--;
v.at(a) = true;
}
if (!v.at(0))
dp.at(0) = 1;
if (n > 1 && !v.at(1))
dp.at(1) = dp.at(0) + 1;
for (int i = 2; i < n; i++) {
if (v.at(i))
continue;
dp.at(i) = (dp.at(i - 1) + dp.at(i - 2)) % mod;
}
cout << dp.at(n - 1) << endl;
} | [
"control_flow.branch.if.condition.change"
] | 824,895 | 824,896 | u928286416 | 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>;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 1);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
}
// cout << fixed << setprecision(15) << << endl; | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int 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;
}
// cout << fixed << setprecision(15) << << endl; | [
"variable_declaration.type.primitive.change",
"assignment.value.change",
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 824,897 | 824,898 | u052656528 | cpp |
p03013 | /*
-ensure correct output format
-ensure printing required output
-reread the problem statement
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pll;
typedef pair<ll, pair<ll, ll>> plll;
#define fastread() (ios_base::sync_with_stdio(false), cin.tie(NULL));
#define vll(v) v.begin(), v.end()
#define all(x) x.rbegin(), x.rend()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define F first
#define S second
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define minheap int, vector<int>, greater<int>
#define pb push_back
#define eb emplace_back
#define ischar(x) (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
#define isvowel(ch) \
((ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') || \
(ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U'))
#define bug cout << "BUG" << endl;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const double PI = 3.141592653589793238463;
bool compare(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return (a.first > b.first);
}
ll lcm(ll a, ll b) {
if (a == 0 || b == 0)
return 0;
return a / __gcd(a, b) * b;
}
void input(ll ara[], ll n) {
for (ll i = 0; i < n; i++)
cin >> ara[i];
}
void print(ll ara[], ll n) {
for (ll i = 0; i < n; i++)
cout << ara[i] << " ";
cout << endl;
}
ll ara[110];
ll dp[110];
ll n;
ll call(ll i) {
if (ara[i] || i > n)
return 0;
ll &ret = dp[i];
if (~ret)
return ret;
ret = (call(i + 1) % Mod + call(i + 2) % Mod) % Mod;
return ret;
}
int main() {
fastread();
ll i, j, m, p, a, sum = 0, k, t, b, c, d, cnt = 0, q, l, r, ans = 0;
bool flag = false;
string str;
cin >> n >> k;
memset(dp, -1, sizeof(dp));
for (i = 0; i < k; i++) {
cin >> a;
ara[a] = 1;
}
ara[n + 1] = 1;
ara[n + 2] = 1;
dp[n] = 1;
cout << call(0) << endl;
}
| /*
-ensure correct output format
-ensure printing required output
-reread the problem statement
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pll;
typedef pair<ll, pair<ll, ll>> plll;
#define fastread() (ios_base::sync_with_stdio(false), cin.tie(NULL));
#define vll(v) v.begin(), v.end()
#define all(x) x.rbegin(), x.rend()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define F first
#define S second
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define minheap int, vector<int>, greater<int>
#define pb push_back
#define eb emplace_back
#define ischar(x) (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
#define isvowel(ch) \
((ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') || \
(ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U'))
#define bug cout << "BUG" << endl;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const double PI = 3.141592653589793238463;
bool compare(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return (a.first > b.first);
}
ll lcm(ll a, ll b) {
if (a == 0 || b == 0)
return 0;
return a / __gcd(a, b) * b;
}
void input(ll ara[], ll n) {
for (ll i = 0; i < n; i++)
cin >> ara[i];
}
void print(ll ara[], ll n) {
for (ll i = 0; i < n; i++)
cout << ara[i] << " ";
cout << endl;
}
ll ara[Max];
ll dp[Max];
ll n;
ll call(ll i) {
if (ara[i] || i > n)
return 0;
ll &ret = dp[i];
if (~ret)
return ret;
ret = (call(i + 1) + call(i + 2)) % Mod;
return ret;
}
int main() {
fastread();
ll i, j, m, p, a, sum = 0, k, t, b, c, d, cnt = 0, q, l, r, ans = 0;
bool flag = false;
string str;
cin >> n >> k;
memset(dp, -1, sizeof(dp));
for (i = 0; i < k; i++) {
cin >> a;
ara[a] = 1;
}
ara[n + 1] = 1;
ara[n + 2] = 1;
dp[n] = 1;
cout << call(0) << endl;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"variable_declaration.array_dimensions.change",
"expression.operation.binary.remove"
] | 824,899 | 824,900 | u434874161 | cpp |
p03013 | /*
-ensure correct output format
-ensure printing required output
-reread the problem statement
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pll;
typedef pair<ll, pair<ll, ll>> plll;
#define fastread() (ios_base::sync_with_stdio(false), cin.tie(NULL));
#define vll(v) v.begin(), v.end()
#define all(x) x.rbegin(), x.rend()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define F first
#define S second
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define minheap int, vector<int>, greater<int>
#define pb push_back
#define eb emplace_back
#define ischar(x) (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
#define isvowel(ch) \
((ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') || \
(ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U'))
#define bug cout << "BUG" << endl;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const double PI = 3.141592653589793238463;
bool compare(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return (a.first > b.first);
}
ll lcm(ll a, ll b) {
if (a == 0 || b == 0)
return 0;
return a / __gcd(a, b) * b;
}
void input(ll ara[], ll n) {
for (ll i = 0; i < n; i++)
cin >> ara[i];
}
void print(ll ara[], ll n) {
for (ll i = 0; i < n; i++)
cout << ara[i] << " ";
cout << endl;
}
ll ara[110];
ll dp[110];
ll n;
ll call(ll i) {
if (ara[i] || i > n)
return 0;
ll &ret = dp[i];
if (~ret)
return ret;
ret = (call(i + 1) + call(i + 2)) % Mod;
return ret;
}
int main() {
fastread();
ll i, j, m, p, a, sum = 0, k, t, b, c, d, cnt = 0, q, l, r, ans = 0;
bool flag = false;
string str;
cin >> n >> k;
memset(dp, -1, sizeof(dp));
for (i = 0; i < k; i++) {
cin >> a;
ara[a] = 1;
}
ara[n + 1] = 1;
ara[n + 2] = 1;
dp[n] = 1;
cout << call(0) << endl;
}
| /*
-ensure correct output format
-ensure printing required output
-reread the problem statement
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> pll;
typedef pair<ll, pair<ll, ll>> plll;
#define fastread() (ios_base::sync_with_stdio(false), cin.tie(NULL));
#define vll(v) v.begin(), v.end()
#define all(x) x.rbegin(), x.rend()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define F first
#define S second
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define minheap int, vector<int>, greater<int>
#define pb push_back
#define eb emplace_back
#define ischar(x) (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
#define isvowel(ch) \
((ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') || \
(ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U'))
#define bug cout << "BUG" << endl;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const double PI = 3.141592653589793238463;
bool compare(const pair<ll, ll> &a, const pair<ll, ll> &b) {
return (a.first > b.first);
}
ll lcm(ll a, ll b) {
if (a == 0 || b == 0)
return 0;
return a / __gcd(a, b) * b;
}
void input(ll ara[], ll n) {
for (ll i = 0; i < n; i++)
cin >> ara[i];
}
void print(ll ara[], ll n) {
for (ll i = 0; i < n; i++)
cout << ara[i] << " ";
cout << endl;
}
ll ara[Max];
ll dp[Max];
ll n;
ll call(ll i) {
if (ara[i] || i > n)
return 0;
ll &ret = dp[i];
if (~ret)
return ret;
ret = (call(i + 1) + call(i + 2)) % Mod;
return ret;
}
int main() {
fastread();
ll i, j, m, p, a, sum = 0, k, t, b, c, d, cnt = 0, q, l, r, ans = 0;
bool flag = false;
string str;
cin >> n >> k;
memset(dp, -1, sizeof(dp));
for (i = 0; i < k; i++) {
cin >> a;
ara[a] = 1;
}
ara[n + 1] = 1;
ara[n + 2] = 1;
dp[n] = 1;
cout << call(0) << endl;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"variable_declaration.array_dimensions.change"
] | 824,901 | 824,900 | u434874161 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define pb push_back
#define lp(i, s, f) for (ll i = s; i < ll(f); i++)
#define inF freopen("input.in", "r", stdin);
#define outF freopen("output.in", "w", stdout);
#define endl '\n'
#define MOD 1000000007
#define mm(arr) memset(arr, 0, sizeof(arr))
#define int ll
const int N = 1e5 + 5;
int dp[N];
bool cant[N];
int n;
int calc(int i) {
if (i > n)
return 0;
if (cant[i])
return 0;
if (i == n) {
return 1;
}
if (dp[i] != -1) {
return dp[i];
}
return dp[i] = (calc(i + 1) % MOD) + (calc(i + 2) % MOD) % MOD;
}
int32_t main() {
FAST int m;
cin >> n >> m;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < m; i++) {
int a;
cin >> a;
cant[a] = 1;
}
cout << calc(0);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define pb push_back
#define lp(i, s, f) for (ll i = s; i < ll(f); i++)
#define inF freopen("input.in", "r", stdin);
#define outF freopen("output.in", "w", stdout);
#define endl '\n'
#define MOD 1000000007
#define mm(arr) memset(arr, 0, sizeof(arr))
#define int ll
const int N = 1e5 + 5;
int dp[N];
bool cant[N];
int n;
int calc(int i) {
if (i > n)
return 0;
if (cant[i])
return 0;
if (i == n) {
return 1;
}
if (dp[i] != -1) {
return dp[i];
}
return dp[i] = ((calc(i + 1) % MOD) + calc(i + 2) % MOD) % MOD;
}
int32_t main() {
FAST int m;
cin >> n >> m;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < m; i++) {
int a;
cin >> a;
cant[a] = 1;
}
cout << calc(0);
return 0;
}
| [
"function.return_value.change"
] | 824,902 | 824,903 | u021108615 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define pb push_back
#define lp(i, s, f) for (ll i = s; i < ll(f); i++)
#define inF freopen("input.in", "r", stdin);
#define outF freopen("output.in", "w", stdout);
#define endl '\n'
#define MOD 1000000007
#define mm(arr) memset(arr, 0, sizeof(arr))
#define int ll
const int N = 1e5 + 5;
int dp[N];
bool cant[N];
int n;
int calc(int i) {
if (i >= n)
return 0;
if (cant[i])
return 0;
if (i == n) {
return 1;
}
if (dp[i] != -1) {
return dp[i];
}
return dp[i] = (calc(i + 1) % MOD) + (calc(i + 2) % MOD) % MOD;
}
int32_t main() {
FAST int m;
cin >> n >> m;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < m; i++) {
int a;
cin >> a;
cant[a] = 1;
}
cout << calc(0);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
#define mp make_pair
#define pb push_back
#define lp(i, s, f) for (ll i = s; i < ll(f); i++)
#define inF freopen("input.in", "r", stdin);
#define outF freopen("output.in", "w", stdout);
#define endl '\n'
#define MOD 1000000007
#define mm(arr) memset(arr, 0, sizeof(arr))
#define int ll
const int N = 1e5 + 5;
int dp[N];
bool cant[N];
int n;
int calc(int i) {
if (i > n)
return 0;
if (cant[i])
return 0;
if (i == n) {
return 1;
}
if (dp[i] != -1) {
return dp[i];
}
return dp[i] = ((calc(i + 1) % MOD) + calc(i + 2) % MOD) % MOD;
}
int32_t main() {
FAST int m;
cin >> n >> m;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < m; i++) {
int a;
cin >> a;
cant[a] = 1;
}
cout << calc(0);
return 0;
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change",
"function.return_value.change"
] | 824,904 | 824,903 | u021108615 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
ll N, M;
cin >> N >> M;
vector<bool> vec(110000, true);
vector<ll> dp(110000, 0);
for (int i = 0; i < N; i++) {
ll a;
cin >> a;
vec[a] = false;
}
dp[0] = 1;
for (int i = 1; i <= N; i++) {
if (i == 1) {
if (vec[i] == true) {
dp[i] = 1;
}
continue;
}
if (vec[i - 1] == true)
dp[i] += dp[i - 1];
if (vec[i - 2] == true)
dp[i] += dp[i - 2];
dp[i] %= 1000000007;
}
cout << dp[N] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void) {
ll N, M;
cin >> N >> M;
vector<bool> vec(110000, true);
vector<ll> dp(110000, 0);
for (int i = 0; i < M; i++) {
ll a;
cin >> a;
vec[a] = false;
}
dp[0] = 1;
for (int i = 1; i <= N; i++) {
if (i == 1) {
if (vec[i] == true) {
dp[i] = 1;
}
continue;
}
if (vec[i - 1] == true)
dp[i] += dp[i - 1];
if (vec[i - 2] == true)
dp[i] += dp[i - 2];
dp[i] %= 1000000007;
}
cout << dp[N] << endl;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 824,905 | 824,906 | u883680855 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define FastIO \
ios::sync_with_stdio(0); \
cin.tie(0);
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<pair<ll, ll>> vpl;
typedef map<ll, ll> mll;
typedef map<string, ll> msl;
#define md 1000000009
void minn(ll &a, ll b) { a = min(a, b); }
void maxx(ll &a, ll b) { a = max(a, b); }
void mod(ll &a) {
if (a >= md) {
a -= md;
}
}
vl dp;
vector<bool> stair;
ll f(ll a) {
if (a < 0 or !stair[a]) {
return 0;
}
if (a == 0) {
return 1;
}
if (dp[a] != -1) {
return dp[a];
}
dp[a] = f(a - 1) + f(a - 2);
mod(dp[a]);
return dp[a];
}
int main() {
FastIO ll n, m;
cin >> n >> m;
dp.resize(n + 1, -1);
stair.resize(n + 1, true);
for (int i = 0; i < m; i++) {
ll x;
cin >> x;
stair[x] = false;
}
cout << f(n) << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define FastIO \
ios::sync_with_stdio(0); \
cin.tie(0);
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<pair<ll, ll>> vpl;
typedef map<ll, ll> mll;
typedef map<string, ll> msl;
#define md 1000000007
void minn(ll &a, ll b) { a = min(a, b); }
void maxx(ll &a, ll b) { a = max(a, b); }
void mod(ll &a) {
if (a >= md) {
a -= md;
}
}
vl dp;
vector<bool> stair;
ll f(ll a) {
if (a < 0 or !stair[a]) {
return 0;
}
if (a == 0) {
return 1;
}
if (dp[a] != -1) {
return dp[a];
}
dp[a] = f(a - 1) + f(a - 2);
mod(dp[a]);
return dp[a];
}
int main() {
FastIO ll n, m;
cin >> n >> m;
dp.resize(n + 1, -1);
stair.resize(n + 1, true);
for (int i = 0; i < m; i++) {
ll x;
cin >> x;
stair[x] = false;
}
cout << f(n) << '\n';
return 0;
} | [
"preprocessor.define.value.change",
"literal.integer.change"
] | 824,928 | 824,929 | u089230684 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<int> oks(N + 1);
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;
} | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
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 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;
} | [
"variable_declaration.type.primitive.change",
"call.arguments.add"
] | 824,936 | 824,937 | u264265458 | cpp |
p03013 | #include <bits/stdc++.h>
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;
}
} | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
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 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;
} | [
"variable_declaration.type.primitive.change"
] | 824,938 | 824,937 | u264265458 | cpp |
p03013 | #include <bits/stdc++.h>
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;
}
} | #include <bits/stdc++.h>
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;
} | [] | 824,938 | 824,939 | u264265458 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod) {
x -= mod;
}
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod) {
x -= mod;
}
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t) {
return 1;
}
mint a = pow(t >> 1);
a *= a;
if (t & 1) {
a *= *this;
}
return a;
}
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) { return mint(*this) /= a; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m;
cin >> n >> m;
vector<bool> as(m, false);
rep(i, m) {
int a;
cin >> a;
as[a] = true;
};
vector<mint> dp(n + 2, 0);
dp[0] = 1;
rep(i, n) {
if (!as[i + 1]) {
dp[i + 1] += dp[i];
}
if (!as[i + 2]) {
dp[i + 2] += dp[i];
}
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod) {
x -= mod;
}
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod) {
x -= mod;
}
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t) {
return 1;
}
mint a = pow(t >> 1);
a *= a;
if (t & 1) {
a *= *this;
}
return a;
}
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) { return mint(*this) /= a; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m;
cin >> n >> m;
vector<bool> as(n, false);
rep(i, m) {
int a;
cin >> a;
as[a] = true;
};
vector<mint> dp(n + 2, 0);
dp[0] = 1;
rep(i, n) {
if (!as[i + 1]) {
dp[i + 1] += dp[i];
}
if (!as[i + 2]) {
dp[i + 2] += dp[i];
}
}
cout << dp[n] << endl;
return 0;
}
| [] | 824,963 | 824,964 | u804049891 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod) {
x -= mod;
}
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod) {
x -= mod;
}
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) % mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t) {
return 1;
}
mint a = pow(t >> 1);
a *= a;
if (t & 1) {
a *= *this;
}
return a;
}
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) { return mint(*this) /= a; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m;
cin >> n >> m;
vector<bool> as(m, false);
rep(i, m) {
int a;
cin >> a;
as[a] = true;
};
vector<mint> dp(n + 2, 0);
dp[0] = 1;
rep(i, n) {
if (!as[i + 1]) {
dp[i + 1] += dp[i];
}
if (!as[i + 2]) {
dp[i + 2] += dp[i];
}
}
cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x(x % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod) {
x -= mod;
}
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod) {
x -= mod;
}
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t) {
return 1;
}
mint a = pow(t >> 1);
a *= a;
if (t & 1) {
a *= *this;
}
return a;
}
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) { return mint(*this) /= a; }
};
istream &operator>>(istream &is, mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m;
cin >> n >> m;
vector<bool> as(n, false);
rep(i, m) {
int a;
cin >> a;
as[a] = true;
};
vector<mint> dp(n + 2, 0);
dp[0] = 1;
rep(i, n) {
if (!as[i + 1]) {
dp[i + 1] += dp[i];
}
if (!as[i + 2]) {
dp[i + 2] += dp[i];
}
}
cout << dp[n] << endl;
return 0;
}
| [
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change"
] | 824,965 | 824,964 | u804049891 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
int main() {
ll n, m;
cin >> n >> m;
vl v(n);
rep(i, m) {
ll a;
cin >> a;
v[a] = 1;
}
vl dp(n + 10); // dp[i] : i段目に上る場合の数
dp[0] = 1;
if (v[1] == 0) {
dp[1] = 1;
}
rep(i, n) {
if (v[i + 2] == 0) {
dp[i + 2] = dp[i + 1] + dp[i];
dp[i + 2] %= mod;
}
}
out(dp[n]);
re0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define exrep(i, a, b) for (ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
int main() {
ll n, m;
cin >> n >> m;
vl v(n + 10);
rep(i, m) {
ll a;
cin >> a;
v[a] = 1;
}
vl dp(n + 10); // dp[i] : i段目に上る場合の数
dp[0] = 1;
if (v[1] == 0) {
dp[1] = 1;
}
rep(i, n) {
if (v[i + 2] == 0) {
dp[i + 2] = dp[i + 1] + dp[i];
dp[i + 2] %= mod;
}
}
out(dp[n]);
re0;
} | [
"assignment.change"
] | 824,966 | 824,967 | u828388155 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
if (n == 1) {
cout << 1 << endl;
return 0;
}
vector<int> broken(n);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 1);
dp[0] = 1;
dp[1] = 1;
if (broken[1]) {
dp[1] = 0;
}
for (int i = 2; i <= n; i++) {
if (broken[i]) {
continue;
}
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= mod;
}
cout << dp[n] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
if (n == 1) {
cout << 1 << endl;
return 0;
}
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 1);
dp[0] = 1;
dp[1] = 1;
if (broken[1]) {
dp[1] = 0;
}
for (int i = 2; i <= n; i++) {
if (broken[i]) {
continue;
}
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= mod;
}
cout << dp[n] << endl;
return 0;
} | [
"assignment.change"
] | 824,968 | 824,969 | u828388155 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i++) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0];
cout << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0];
cout << endl;
return 0;
} | [] | 824,970 | 824,971 | u828388155 | cpp |
p03013 | //#include <bits/stdc++.h>
#include <iostream>
#include <map>
#include <math.h>
#include <vector>
#define irep(i, n) for (int i = 0; i < (int)(n); i++)
#define irep2(i, a, n) for (int i = (int)(a); i <= (int)(n); i++)
#define irrep(i, n) for (int i = (int)(n - 1); i > -1; i--)
#define irrep2(i, n, a) for (int i = (int)(n); i >= (int)(a); i--)
#define fi first
#define se second
using namespace std;
using ll = long long;
using v_int = vector<int>;
using v2_int = vector<v_int>;
using v_ll = vector<ll>;
using v2_ll = vector<v_ll>;
using v_string = vector<string>;
using v_bool = vector<bool>;
using v2_bool = vector<v_bool>;
using pii = pair<int, int>;
using mii = map<int, int>;
const double PI = 3.1415926535897932;
const int INF = (int)2e9;
const ll LINF = (ll)2e18;
const ll MOD = 1000000007;
const int dc[8] = {1, -1, 0, 0, 1, -1, 1, -1};
const int dr[8] = {0, 0, 1, -1, 1, 1, -1, -1};
template <typename T, typename U>
inline ostream &operator<<(ostream &o, pair<T, U> &p) {
return o << "{" << p.first << "," << p.second << "}";
}
template <typename T> inline istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) {
is >> v;
}
return is;
}
template <typename T> inline ostream &operator<<(ostream &os, vector<T> &vec) {
for (auto &v : vec) {
os << v << ",";
}
return os;
}
template <typename T>
inline ostream &operator<<(ostream &os, vector<vector<T>> &mat) {
for (auto &row : mat) {
os << row << endl;
}
return os;
}
template <typename T> inline void chmin(T &a, T b) { a = min(a, b); }
template <typename T> inline void chmax(T &a, T b) { a = max(a, b); }
int main(void) {
int n, m;
cin >> n >> m;
v_int a(n);
irep(i, m) {
int tmp;
cin >> tmp;
a[tmp] = 1;
}
v_int dp(100005);
dp[0] = 1;
irep(i, n + 1) {
if (!a[i + 1]) {
dp[i + 1] += dp[i];
dp[i + 1] %= MOD;
}
if (!a[i + 2]) {
dp[i + 2] += dp[i];
dp[i + 2] %= MOD;
}
}
cout << dp[n] << endl;
return 0;
} /*atcoder*/
| //#include <bits/stdc++.h>
#include <iostream>
#include <map>
#include <math.h>
#include <vector>
#define irep(i, n) for (int i = 0; i < (int)(n); i++)
#define irep2(i, a, n) for (int i = (int)(a); i <= (int)(n); i++)
#define irrep(i, n) for (int i = (int)(n - 1); i > -1; i--)
#define irrep2(i, n, a) for (int i = (int)(n); i >= (int)(a); i--)
#define fi first
#define se second
using namespace std;
using ll = long long;
using v_int = vector<int>;
using v2_int = vector<v_int>;
using v_ll = vector<ll>;
using v2_ll = vector<v_ll>;
using v_string = vector<string>;
using v_bool = vector<bool>;
using v2_bool = vector<v_bool>;
using pii = pair<int, int>;
using mii = map<int, int>;
const double PI = 3.1415926535897932;
const int INF = (int)2e9;
const ll LINF = (ll)2e18;
const ll MOD = 1000000007;
const int dc[8] = {1, -1, 0, 0, 1, -1, 1, -1};
const int dr[8] = {0, 0, 1, -1, 1, 1, -1, -1};
template <typename T, typename U>
inline ostream &operator<<(ostream &o, pair<T, U> &p) {
return o << "{" << p.first << "," << p.second << "}";
}
template <typename T> inline istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) {
is >> v;
}
return is;
}
template <typename T> inline ostream &operator<<(ostream &os, vector<T> &vec) {
for (auto &v : vec) {
os << v << ",";
}
return os;
}
template <typename T>
inline ostream &operator<<(ostream &os, vector<vector<T>> &mat) {
for (auto &row : mat) {
os << row << endl;
}
return os;
}
template <typename T> inline void chmin(T &a, T b) { a = min(a, b); }
template <typename T> inline void chmax(T &a, T b) { a = max(a, b); }
int main(void) {
int n, m;
cin >> n >> m;
v_int a(n + 3);
irep(i, m) {
int tmp;
cin >> tmp;
a[tmp] = 1;
}
v_int dp(100005);
dp[0] = 1;
irep(i, n + 1) {
if (!a[i + 1]) {
dp[i + 1] += dp[i];
dp[i + 1] %= MOD;
}
if (!a[i + 2]) {
dp[i + 2] += dp[i];
dp[i + 2] %= MOD;
}
}
cout << dp[n] << endl;
return 0;
} /*atcoder*/
| [
"assignment.change"
] | 824,979 | 824,980 | u829260400 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> broken(n);
vector<ll> dp(n + 2, 0);
dp.at(n + 1) = 0;
dp[n] = 1;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken.at(a) = 1;
}
for (int j = n - 1; j > -1; --j) {
if (broken[j] == 1)
continue;
dp[j] = dp[j + 1] % mod + dp[j + 2] % mod;
}
// for (int h=0;h < n;h++) cout <<broken[h] << " ";
// printf("\n");
// for (int i=0;i<n+2;i++) cout << dp[i] << " ";
// printf("\n");
cout << dp[0] << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> broken(n);
vector<ll> dp(n + 2, 0);
dp.at(n + 1) = 0;
dp[n] = 1;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken.at(a) = 1;
}
for (int j = n - 1; j > -1; --j) {
if (broken[j] == 1)
continue;
dp[j] = dp[j + 1] % mod + dp[j + 2] % mod;
}
// for (int h=0;h < n;h++) cout <<broken[h] << " ";
// printf("\n");
// for (int i=0;i<n+2;i++) cout << dp[i] << " ";
// printf("\n");
cout << dp[0] % mod << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 824,981 | 824,982 | u657208344 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
#define ld long double
#define ll long long
#define mod 1000000007
#define IINF INT_MAX
#define INF 1LL << 30
int main() {
int n, m;
cin >> n >> m;
V<int> b(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
b[a] = 1;
}
V<int> dp(n + 1);
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (b[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] % mod << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
#define ld long double
#define ll long long
#define mod 1000000007
#define IINF INT_MAX
#define INF 1LL << 30
int main() {
int n, m;
cin >> n >> m;
V<int> b(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
b[a] = 1;
}
V<int> dp(n + 2);
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (b[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",
"expression.operation.binary.remove"
] | 824,985 | 824,986 | u651235280 | cpp |
p03013 | /*
ABC026 高橋君の給料 DFS
int dfs(int n,vector<vector<int>> G){
int mi = 1000000000;
int ma = 0;
int w,v;
for(int i=0;i<G[n].size();i++){
v = G[n][i];
if(G[v].size() == 0)w = 1;
else w = dfs(v,G);
mi = min(mi,w);
ma = max(ma,w);
}
return mi + ma + 1;
}
int main() {
int n;
cin >> n;
Graph G(n+1);
for(int i=2;i<=n;i++){
int a;
cin >> a;
G[a].push_back(i);
}
int ans = dfs(1,G);
cout << ans << endl;
}
*/
//素因数分解
// ABC169-D - Div Game
/*
int main() {
ll n;
cin >> n;
vector<pair<ll,ll> > res;
for(ll i = 2;i*i <= n;i++){
if(n % i !=0) continue;
ll ex = 0;// 指数
//割れる限り割り続ける
while(n % i ==0){
ex++;
n /=i;
}
//その結果をpush
res.push_back({i,ex});
}
//最後に残った数について
if(n !=1) res.push_back({n,1});
// cout << n << ":";
// for (auto p : res) {
// for (int i = 0; i < p.second; ++i) cout << " " << p.first;
// }
// cout << endl;
ll times = 0;
for (auto p : res) {
int count = 1;
int cnt = 0;
while(p.second > cnt){
// cout << p.second << endl;
p.second -=count;
count++;
cnt ++;
}
times += cnt;
}
cout << times << endl;
}
*/
// ABC146 //二分探索
/*int main() {
ll a,b,x;
cin >> a >> b >> x;
ll left = 0;
ll right = 1000000001;
while(right - left > 1){
ll mid = (left + right ) /2;
if(a * mid + b * ketasuu(mid) > x) right = mid;
else left = mid;
// cout << left << " " << right << endl;
}
cout << left << endl;
}
*/
// ABC_128_B// pair型の中にpair型
/*int main() {
int n;
cin >> n;
vector<pair<pair<string,int>,int>> a(n);
for(int i=0;i<n;i++){
string s;
cin >> s;
int num;
cin >> num;
num = num * -1;
a.at(i).first.first = s;
a.at(i).first.second = num;
a.at(i).second = i;
}
sort(a.begin(), a.end());
for(int i=0;i<n;i++){
cout << a.at(i).second +1 << endl;
}
}
*/
// ABC_058_Cのように
// s.at(j) == a のとき
// cout << s.at(j)-'0' - 49 << endl;
//とすると、「0」を出力してくれる。 →もっといいほかの方法はないの？
//全bit探索を入れよう!!
/*ABC_167_C skill up などを参考に…
//https://qiita.com/hareku/items/3d08511eab56a481c7db
int main() {
int n = 3;
// {0, 1, ..., n-1} の部分集合の全探索
for (int bit = 0; bit < (1<<n); ++bit) {
vector<int> S;
for (int i = 0; i < n; ++i) {
if (bit & (1<<i)) { // 列挙に i が含まれるか
S.push_back(i);
}
}
cout << bit << ": {";
for (int i = 0; i < (int)S.size(); ++i) {
cout << S[i] << " ";
}
cout << "}" << endl;
}
}
*/
// next_permutation（順列列挙）
/*https://note.com/memenekokaburi/n/nf0201d6002cd
//https://scrapbox.io/ganariya/AtCoderGrandContest022_A%E5%95%8F%E9%A1%8C300%E7%82%B9%E3%80%8CDiverse_Word%E3%80%8D_(copy)
//https://atcoder.jp/contests/agc022/tasks/agc022_a
ABC_150_Cなど。
int main() {
int n;
cin >> n ;
vector<int>array = {};
for(int i=0;i<n;i++){
array.push_back(i);
}
do{
for(int i=0; i<n; i++){
cout << array.at(i);
if(i!=n-1)cout<<" ";
}
cout<<endl;
}while(next_permutation(array.begin(),array.end()));
return 0;
}
*/
// ABC126_Cのように関数でdouble型で返ってきてほしい場合はdouble
// kan_halfのようにかく
/*
//ABC_041_C// pair型
int main() {
int n;
cin >> n;
vector<pair<int,int>>a(n);
for(int i=0;i<n;i++){
int num;
cin >> num;
a.at(i).first = num;
a.at(i).second = i;
}
sort(a.begin(), a.end());
reverse(a.begin(),a.end());
for(int i=0;i<n;i++){
cout << a.at(i).second + 1<< endl;
}
}
*/
/*ABC_068_C //boolの配列を使って
bool s[200050] = {};
bool t[200050] = {};
int main() {
ll n, m; cin >> n >> m;
for (int i = 0; i < m; i++){
ll a, b; cin >> a >> b;
if (a == 1) {
t[b] = true;
}
if (b == n) {
s[a] = true;
}
}
for (int i = 0; i < 200050; i++){
if (s[i] && t[i]) {
cout << "POSSIBLE" << endl;
return 0;
}
}
cout << "IMPOSSIBLE" << endl;
return 0;
}
*/
// int32 4 signed, signed int, int -2,147,483,648 ～ 2,147,483,647 =
// 2*10^9 再帰関数 ABC_029_C
/*
void f(int rest , string s){
if(rest == 0){
cout << s << endl;
}
else{
for(char moji = 'a' ;moji <='c' ; moji++){
f(rest-1,s+moji);
}
}
}
int main() {
int n;
cin >> n;
f(n, "");
}
*/
//連想配列 ARC_081_Cの解答 //ABC073でも復習できます。
/*
int main() {
ll n;
cin >> n;
vector<ll>a(n);
rep(i,n) cin>>a.at(i);
map<ll,ll>mp;
rep(i,n){
mp[a.at(i)]++;
}
ll one = 0;
ll two = 0;
for(auto p:mp){
// cout << p.first << " " << p.second << endl;
if(p.second >= 2){
if(one <= p.first){
two = one;
one = p.first;
}
}
if(p.second >= 4){
if(one <= p.first){
two = p.first;
one = p.first;
}
}
}
// cout << one << endl;
// cout << two << endl;
// cout << endl;
cout << one * two << endl;
}
*/
//#define pi 3.14159265359
//桁数を指定して出力する方法
//#include <iomanip>//これをincludeしておかないといけない
// cout << fixed << setprecision(20)<< ans << endl;
// s.at(0) = toupper(s.at(0));//小文字なら大文字へ//大文字の場合はそのまま
// s.at(i) = tolower(s.at(i));//大文字なら小文字へ//小文字の場合はそのまま
// getline(cin, s); //空白文字を含むものをまとめて入力できる。
// s配列に格納した単語を、辞書順にソートする
// sort(s.begin(), s.end());
// string t = "keyence";//で文字列を格納できる
// s.empty() //emptyなら1を出力 入っていれば0を出力
/*//ABC018-B 部分的にreverseをかける解法
int main() {
string s; cin >> s;
int n; cin >> n;
vector<int>a(n); vector<int>b(n);
rep(i,n) cin>>a.at(i)>>b.at(i);
rep(i,n)a.at(i)--; rep(i,n)b.at(i)--;
string t;
rep(i,n){
t = s;
for(int k=0;k<=b.at(i)-a.at(i);k++){
t.at(a.at(i)+k) = s.at(b.at(i)-k);
}
s = t;
}
cout << s << endl;
}
*///ABC018-B
// cout << char(i+48) <<
// endl;//なぜかaは47と得る時がある。+48で出力もaにできる。 cout << char(97) <<
// endl;//アスキーコードでaを出力
// sort(b.begin(), b.end());//bという配列を小さい方からソート
// reverse(b.begin(), b.end());//bという配列をリターン
/*01 02 03 12 13 23 と６回見ていくパターン
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++){
}
}
*/
// vector<vector<int>> a(3, vector<int>(4));//int型の2次元配列(3×4要素の)の宣言
// 10のi乗pow(10, i);//ただしdouble型のため注意
/*string s; stringでの文字列を数字型に変える方法
cin >> s;
rep(i,s.size()-2) {
int a= (s.at(i)-'0')*100 + (s.at(i+1)-'0')*10+ s.at(i+2) -'0';
*/
#include <bits/stdc++.h>
#include <iomanip> //これをincludeしておかないといけない
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
using Graph = vector<vector<int>>;
typedef long long ll;
typedef long double lld;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265359
ll gcd(ll a, ll b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
ll lcm(ll a, ll b) {
// return a * b / gcd(a, b);
return a / gcd(a, b) * b;
}
int kan_hyaku(int n) {
int kurai = 0;
for (int i = 0; i < 3; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
int kan_ju(int n) {
int kurai = 0;
for (int i = 0; i < 2; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
int kan_ichi(int n) {
int kurai = 0;
for (int i = 0; i < 1; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
ll keta(ll n) {
ll wa = 1;
while (n > 0) {
wa *= 10;
n--;
}
return wa;
}
double kan_half(int n) {
double wa = 1;
while (n > 0) {
// cout << "TEST"<<endl;
wa *= 0.5;
// cout << wa << endl;
n--;
}
return wa;
}
ll facctorialMethod(ll k) {
ll sum = 1;
for (ll i = 1; i <= k; ++i) {
sum = sum % 1000000007 * i % 1000000007;
}
return sum;
}
int zorocheck(string s) {
int count = 0;
rep(i, s.size()) {
if (s.at(i) == s.at(0))
count++;
}
if (count == s.size()) {
return 1;
} else {
return 0;
}
}
int sannobekijou(int n) {
int wa = 1;
while (n > 0) {
n--;
wa *= 3;
}
return wa;
}
ll ketasuu(ll k) {
ll wa = 0;
while (k > 0) {
k /= 10;
wa++;
}
return wa;
}
ll beki(ll f, ll num) {
ll wa = 1;
while (num > 0) {
wa *= f;
num--;
// cout << wa << endl;
}
return wa;
}
ll fibona(ll num) {
vector<ll> c(3);
c.at(0) = 1;
c.at(1) = 2;
c.at(2) = 3;
if (num == 1) {
return c.at(0);
} else if (num == 2) {
return c.at(1);
} else if (num == 3) {
return c.at(2);
} else {
for (ll i = 3; i < num; i++) {
// cout << " tes " << endl;
ll tmp;
tmp = c.at(1) + c.at(2);
c.at(0) = c.at(1);
c.at(1) = c.at(2);
c.at(2) = tmp;
}
return c.at(2);
}
}
/*
int n;
cin >> n;
vector<int>a(n);
rep(i,n) cin >> a.at(i);
*/
// cout << fixed << setprecision(10)<< ans << endl;
//数字から文字列に変換 a.at(0) = std::to_string(111);
int main() {
int flag = 0;
ll n, m;
cin >> n >> m;
vector<ll> a(n + 1);
vector<ll> b;
rep(i, m) {
ll k;
cin >> k;
a.at(k) = -1;
}
rep(i, n) {
if (a.at(i) == -1 && a.at(i + 1) == -1)
flag = 1;
}
if (flag == 1) {
cout << 0 << endl;
return 0;
}
ll num = 0;
rep(i, n) {
if (a.at(i) == -1) {
b.push_back((i - 1) - num);
num = i + 1;
}
}
if (num != n + 1) {
b.push_back(n - num);
}
// rep(i,b.size()){
// cout << b.at(i) << endl;
// }
ll ans = 1;
rep(i, b.size()) {
if (b.at(i) != 0) {
ans *= fibona(b.at(i));
ans %= 1000000007;
}
}
cout << ans << endl;
// cout << fibona(6) << endl;
} | /*
ABC026 高橋君の給料 DFS
int dfs(int n,vector<vector<int>> G){
int mi = 1000000000;
int ma = 0;
int w,v;
for(int i=0;i<G[n].size();i++){
v = G[n][i];
if(G[v].size() == 0)w = 1;
else w = dfs(v,G);
mi = min(mi,w);
ma = max(ma,w);
}
return mi + ma + 1;
}
int main() {
int n;
cin >> n;
Graph G(n+1);
for(int i=2;i<=n;i++){
int a;
cin >> a;
G[a].push_back(i);
}
int ans = dfs(1,G);
cout << ans << endl;
}
*/
//素因数分解
// ABC169-D - Div Game
/*
int main() {
ll n;
cin >> n;
vector<pair<ll,ll> > res;
for(ll i = 2;i*i <= n;i++){
if(n % i !=0) continue;
ll ex = 0;// 指数
//割れる限り割り続ける
while(n % i ==0){
ex++;
n /=i;
}
//その結果をpush
res.push_back({i,ex});
}
//最後に残った数について
if(n !=1) res.push_back({n,1});
// cout << n << ":";
// for (auto p : res) {
// for (int i = 0; i < p.second; ++i) cout << " " << p.first;
// }
// cout << endl;
ll times = 0;
for (auto p : res) {
int count = 1;
int cnt = 0;
while(p.second > cnt){
// cout << p.second << endl;
p.second -=count;
count++;
cnt ++;
}
times += cnt;
}
cout << times << endl;
}
*/
// ABC146 //二分探索
/*int main() {
ll a,b,x;
cin >> a >> b >> x;
ll left = 0;
ll right = 1000000001;
while(right - left > 1){
ll mid = (left + right ) /2;
if(a * mid + b * ketasuu(mid) > x) right = mid;
else left = mid;
// cout << left << " " << right << endl;
}
cout << left << endl;
}
*/
// ABC_128_B// pair型の中にpair型
/*int main() {
int n;
cin >> n;
vector<pair<pair<string,int>,int>> a(n);
for(int i=0;i<n;i++){
string s;
cin >> s;
int num;
cin >> num;
num = num * -1;
a.at(i).first.first = s;
a.at(i).first.second = num;
a.at(i).second = i;
}
sort(a.begin(), a.end());
for(int i=0;i<n;i++){
cout << a.at(i).second +1 << endl;
}
}
*/
// ABC_058_Cのように
// s.at(j) == a のとき
// cout << s.at(j)-'0' - 49 << endl;
//とすると、「0」を出力してくれる。 →もっといいほかの方法はないの？
//全bit探索を入れよう!!
/*ABC_167_C skill up などを参考に…
//https://qiita.com/hareku/items/3d08511eab56a481c7db
int main() {
int n = 3;
// {0, 1, ..., n-1} の部分集合の全探索
for (int bit = 0; bit < (1<<n); ++bit) {
vector<int> S;
for (int i = 0; i < n; ++i) {
if (bit & (1<<i)) { // 列挙に i が含まれるか
S.push_back(i);
}
}
cout << bit << ": {";
for (int i = 0; i < (int)S.size(); ++i) {
cout << S[i] << " ";
}
cout << "}" << endl;
}
}
*/
// next_permutation（順列列挙）
/*https://note.com/memenekokaburi/n/nf0201d6002cd
//https://scrapbox.io/ganariya/AtCoderGrandContest022_A%E5%95%8F%E9%A1%8C300%E7%82%B9%E3%80%8CDiverse_Word%E3%80%8D_(copy)
//https://atcoder.jp/contests/agc022/tasks/agc022_a
ABC_150_Cなど。
int main() {
int n;
cin >> n ;
vector<int>array = {};
for(int i=0;i<n;i++){
array.push_back(i);
}
do{
for(int i=0; i<n; i++){
cout << array.at(i);
if(i!=n-1)cout<<" ";
}
cout<<endl;
}while(next_permutation(array.begin(),array.end()));
return 0;
}
*/
// ABC126_Cのように関数でdouble型で返ってきてほしい場合はdouble
// kan_halfのようにかく
/*
//ABC_041_C// pair型
int main() {
int n;
cin >> n;
vector<pair<int,int>>a(n);
for(int i=0;i<n;i++){
int num;
cin >> num;
a.at(i).first = num;
a.at(i).second = i;
}
sort(a.begin(), a.end());
reverse(a.begin(),a.end());
for(int i=0;i<n;i++){
cout << a.at(i).second + 1<< endl;
}
}
*/
/*ABC_068_C //boolの配列を使って
bool s[200050] = {};
bool t[200050] = {};
int main() {
ll n, m; cin >> n >> m;
for (int i = 0; i < m; i++){
ll a, b; cin >> a >> b;
if (a == 1) {
t[b] = true;
}
if (b == n) {
s[a] = true;
}
}
for (int i = 0; i < 200050; i++){
if (s[i] && t[i]) {
cout << "POSSIBLE" << endl;
return 0;
}
}
cout << "IMPOSSIBLE" << endl;
return 0;
}
*/
// int32 4 signed, signed int, int -2,147,483,648 ～ 2,147,483,647 =
// 2*10^9 再帰関数 ABC_029_C
/*
void f(int rest , string s){
if(rest == 0){
cout << s << endl;
}
else{
for(char moji = 'a' ;moji <='c' ; moji++){
f(rest-1,s+moji);
}
}
}
int main() {
int n;
cin >> n;
f(n, "");
}
*/
//連想配列 ARC_081_Cの解答 //ABC073でも復習できます。
/*
int main() {
ll n;
cin >> n;
vector<ll>a(n);
rep(i,n) cin>>a.at(i);
map<ll,ll>mp;
rep(i,n){
mp[a.at(i)]++;
}
ll one = 0;
ll two = 0;
for(auto p:mp){
// cout << p.first << " " << p.second << endl;
if(p.second >= 2){
if(one <= p.first){
two = one;
one = p.first;
}
}
if(p.second >= 4){
if(one <= p.first){
two = p.first;
one = p.first;
}
}
}
// cout << one << endl;
// cout << two << endl;
// cout << endl;
cout << one * two << endl;
}
*/
//#define pi 3.14159265359
//桁数を指定して出力する方法
//#include <iomanip>//これをincludeしておかないといけない
// cout << fixed << setprecision(20)<< ans << endl;
// s.at(0) = toupper(s.at(0));//小文字なら大文字へ//大文字の場合はそのまま
// s.at(i) = tolower(s.at(i));//大文字なら小文字へ//小文字の場合はそのまま
// getline(cin, s); //空白文字を含むものをまとめて入力できる。
// s配列に格納した単語を、辞書順にソートする
// sort(s.begin(), s.end());
// string t = "keyence";//で文字列を格納できる
// s.empty() //emptyなら1を出力 入っていれば0を出力
/*//ABC018-B 部分的にreverseをかける解法
int main() {
string s; cin >> s;
int n; cin >> n;
vector<int>a(n); vector<int>b(n);
rep(i,n) cin>>a.at(i)>>b.at(i);
rep(i,n)a.at(i)--; rep(i,n)b.at(i)--;
string t;
rep(i,n){
t = s;
for(int k=0;k<=b.at(i)-a.at(i);k++){
t.at(a.at(i)+k) = s.at(b.at(i)-k);
}
s = t;
}
cout << s << endl;
}
*///ABC018-B
// cout << char(i+48) <<
// endl;//なぜかaは47と得る時がある。+48で出力もaにできる。 cout << char(97) <<
// endl;//アスキーコードでaを出力
// sort(b.begin(), b.end());//bという配列を小さい方からソート
// reverse(b.begin(), b.end());//bという配列をリターン
/*01 02 03 12 13 23 と６回見ていくパターン
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++){
}
}
*/
// vector<vector<int>> a(3, vector<int>(4));//int型の2次元配列(3×4要素の)の宣言
// 10のi乗pow(10, i);//ただしdouble型のため注意
/*string s; stringでの文字列を数字型に変える方法
cin >> s;
rep(i,s.size()-2) {
int a= (s.at(i)-'0')*100 + (s.at(i+1)-'0')*10+ s.at(i+2) -'0';
*/
#include <bits/stdc++.h>
#include <iomanip> //これをincludeしておかないといけない
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
using Graph = vector<vector<int>>;
typedef long long ll;
typedef long double lld;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265359
ll gcd(ll a, ll b) {
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
ll lcm(ll a, ll b) {
// return a * b / gcd(a, b);
return a / gcd(a, b) * b;
}
int kan_hyaku(int n) {
int kurai = 0;
for (int i = 0; i < 3; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
int kan_ju(int n) {
int kurai = 0;
for (int i = 0; i < 2; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
int kan_ichi(int n) {
int kurai = 0;
for (int i = 0; i < 1; i++) {
kurai = n % 10;
n /= 10;
}
return kurai;
}
ll keta(ll n) {
ll wa = 1;
while (n > 0) {
wa *= 10;
n--;
}
return wa;
}
double kan_half(int n) {
double wa = 1;
while (n > 0) {
// cout << "TEST"<<endl;
wa *= 0.5;
// cout << wa << endl;
n--;
}
return wa;
}
ll facctorialMethod(ll k) {
ll sum = 1;
for (ll i = 1; i <= k; ++i) {
sum = sum % 1000000007 * i % 1000000007;
}
return sum;
}
int zorocheck(string s) {
int count = 0;
rep(i, s.size()) {
if (s.at(i) == s.at(0))
count++;
}
if (count == s.size()) {
return 1;
} else {
return 0;
}
}
int sannobekijou(int n) {
int wa = 1;
while (n > 0) {
n--;
wa *= 3;
}
return wa;
}
ll ketasuu(ll k) {
ll wa = 0;
while (k > 0) {
k /= 10;
wa++;
}
return wa;
}
ll beki(ll f, ll num) {
ll wa = 1;
while (num > 0) {
wa *= f;
num--;
// cout << wa << endl;
}
return wa;
}
ll fibona(ll num) {
vector<ll> c(3);
c.at(0) = 1;
c.at(1) = 2;
c.at(2) = 3;
if (num == 1) {
return c.at(0);
} else if (num == 2) {
return c.at(1);
} else if (num == 3) {
return c.at(2);
} else {
for (ll i = 3; i < num; i++) {
// cout << " tes " << endl;
ll tmp;
tmp = c.at(1) + c.at(2);
tmp %= 1000000007;
c.at(0) = c.at(1);
c.at(1) = c.at(2);
c.at(2) = tmp;
}
return c.at(2);
}
}
/*
int n;
cin >> n;
vector<int>a(n);
rep(i,n) cin >> a.at(i);
*/
// cout << fixed << setprecision(10)<< ans << endl;
//数字から文字列に変換 a.at(0) = std::to_string(111);
int main() {
int flag = 0;
ll n, m;
cin >> n >> m;
vector<ll> a(n + 1);
vector<ll> b;
rep(i, m) {
ll k;
cin >> k;
a.at(k) = -1;
}
rep(i, n) {
if (a.at(i) == -1 && a.at(i + 1) == -1)
flag = 1;
}
if (flag == 1) {
cout << 0 << endl;
return 0;
}
ll num = 0;
rep(i, n) {
if (a.at(i) == -1) {
b.push_back((i - 1) - num);
num = i + 1;
}
}
if (num != n + 1) {
b.push_back(n - num);
}
// rep(i,b.size()){
// cout << b.at(i) << endl;
// }
ll ans = 1;
rep(i, b.size()) {
if (b.at(i) != 0) {
ans *= fibona(b.at(i));
ans %= 1000000007;
}
}
cout << ans << endl;
// cout << fibona(6) << endl;
} | [
"assignment.add"
] | 824,998 | 824,999 | u037563046 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
#define np next_permutation
typedef long long ll;
int dp__[100];
//最大公約数
ll gcd(ll x, ll y) {
if (x % y == 0)
return y;
return gcd(y, x % y);
}
//最小公倍数
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
//フィボナッチ数列
//配列dpを-1で初期化する
int fib(int n) {
if (n == 0 || n == 1)
return dp__[n] = 1;
if (dp__[n] != -1)
return dp__[n];
return dp__[n] = fib(n - 1) + fib(n - 2);
}
//階乗計算(factorial)
int fact(int n) {
if (n = 1)
return 1;
return n * fact(n - 1);
}
//累乗計算(Exponentiation)
// x**y
ll expo(int x, int y) {
ll ans = 1;
rep(i, y) { ans *= x; }
return ans;
}
//桁数
int keta(ll x) {
if (x == 0)
return 1;
int res = 0;
while (x) {
x /= 10;
res++;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<ll> dp(n + 2);
dp[n] = 1;
for (ll i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = dp[i + 1] + dp[i + 2];
}
ll ans = dp[0] % 1000000007;
cout << ans << endl;
}
/*
*/
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
#define np next_permutation
typedef long long ll;
int dp__[100];
//最大公約数
ll gcd(ll x, ll y) {
if (x % y == 0)
return y;
return gcd(y, x % y);
}
//最小公倍数
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
//フィボナッチ数列
//配列dpを-1で初期化する
int fib(int n) {
if (n == 0 || n == 1)
return dp__[n] = 1;
if (dp__[n] != -1)
return dp__[n];
return dp__[n] = fib(n - 1) + fib(n - 2);
}
//階乗計算(factorial)
int fact(int n) {
if (n = 1)
return 1;
return n * fact(n - 1);
}
//累乗計算(Exponentiation)
// x**y
ll expo(int x, int y) {
ll ans = 1;
rep(i, y) { ans *= x; }
return ans;
}
//桁数
int keta(ll x) {
if (x == 0)
return 1;
int res = 0;
while (x) {
x /= 10;
res++;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<ll> dp(n + 2);
dp[n] = 1;
for (ll i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % 1000000007;
}
ll ans = dp[0] % 1000000007;
cout << ans << endl;
}
/*
*/
| [
"assignment.change"
] | 825,002 | 825,003 | u363936720 | cpp |
p03013 | #include <iostream>
#include <vector>
int main() {
int n, m;
std::cin >> n >> m;
std::vector<int> broken(n + 1);
for (int i = 0; i < n + 1; i++) {
int a;
std::cin >> a;
broken[a] = 1;
}
std::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;
}
std::cout << dp[0] << std::endl;
return 0;
}
| #include <iostream>
#include <vector>
int main() {
int n, m;
std::cin >> n >> m;
std::vector<int> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
std::cin >> a;
broken[a] = 1;
}
std::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;
}
std::cout << dp[0] << std::endl;
return 0;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 825,004 | 825,005 | u477343425 | cpp |
p03013 | #include <cstdio>
#include <iostream>
#include <vector>
int main(void) {
int n, m;
std::cin >> n >> m;
std::vector<int> broken(n + 1);
for (int i = 0; i < n; i++) {
int a;
std::cin >> a;
broken.at(a) = 1;
}
std::vector<int> dp(n + 2);
const int mod = 1000000007;
dp.at(n) = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken.at(i)) {
dp.at(i) = 0;
continue;
}
dp.at(i) = (dp.at(i + 1) + dp.at(i + 2)) % mod;
}
std::cout << dp.at(0) << std::endl;
return 0;
} | #include <cstdio>
#include <iostream>
#include <vector>
int main(void) {
int n, m;
std::cin >> n >> m;
std::vector<int> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
std::cin >> a;
broken.at(a) = 1;
}
std::vector<int> dp(n + 2);
const int mod = 1000000007;
dp.at(n) = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken.at(i)) {
dp.at(i) = 0;
continue;
}
dp.at(i) = (dp.at(i + 1) + dp.at(i + 2)) % mod;
}
std::cout << dp.at(0) << std::endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 825,007 | 825,008 | u477343425 | cpp |
p03013 | #include <cstdio>
#include <iostream>
#include <vector>
int main(void) {
int n, m;
std::cin >> n >> m;
std::vector<int> broken(n + 1);
for (int i = 0; i < n; i++) {
int a;
std::cin >> a;
broken.at(a) = 1;
}
std::vector<int> dp(n + 2);
const int mod = 1e9 + 7;
dp.at(n) = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken.at(i)) {
dp.at(i) = 0;
continue;
}
dp.at(i) = (dp.at(i + 1) + dp.at(i + 2)) % mod;
}
std::cout << dp.at(0) << std::endl;
return 0;
} | #include <cstdio>
#include <iostream>
#include <vector>
int main(void) {
int n, m;
std::cin >> n >> m;
std::vector<int> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
std::cin >> a;
broken.at(a) = 1;
}
std::vector<int> dp(n + 2);
const int mod = 1000000007;
dp.at(n) = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken.at(i)) {
dp.at(i) = 0;
continue;
}
dp.at(i) = (dp.at(i + 1) + dp.at(i + 2)) % mod;
}
std::cout << dp.at(0) << std::endl;
return 0;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"literal.number.change",
"variable_declaration.value.change",
"expression.operation.binary.remove"
] | 825,009 | 825,008 | u477343425 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define FOR(i, start, end) for (int i = start; i <= end; i++)
const int INF = 1001001001;
typedef long long ll;
const ll MOD = 1000000007;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> auto MAX(const T &a) {
return *max_element(a.begin(), a.end());
}
template <class T> auto MIN(const T &a) {
return *min_element(a.begin(), a.end());
}
template <class T, class U> U SUM(const T &a, const U &v) {
return accumulate(a.begin(), a.end(), v);
}
template <class T, class U> U COUNT(const T &a, const U &v) {
return count(a.begin(), a.end(), v);
}
template <class T, class U> int LOWER(const T &a, const U &v) {
return lower_bound(a.begin(), a.end(), v) - a.begin();
}
template <class T, class U> int UPPER(const T &a, const U &v) {
return upper_bound(a.begin(), a.end(), v) - a.begin();
}
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) {
int g = GCD(a, b);
return a / g * b;
}
bool vector_finder(std::vector<int> vec, int number) {
auto itr = std::find(vec.begin(), vec.end(), number);
size_t index = std::distance(vec.begin(), itr);
if (index != vec.size()) { // 発見できたとき
return true;
} else { // 発見できなかったとき
return false;
}
}
int main(void) {
// Your code here!
int n, m;
cin >> n >> m;
int a;
vector<ll> dp(n + 1, 0);
rep(i, m) {
cin >> a;
dp[a] = -1;
}
dp[0] = 1;
if (dp[1] != -1)
dp[1] = 1;
FOR(i, 2, n) {
if (dp[i] == -1)
continue;
if (dp[i - 1] != -1)
dp[i] += dp[i - 1];
if (dp[i - 2] != -1)
dp[i] += dp[i - 2];
dp[i] % MOD;
}
cout << dp[n] << endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define FOR(i, start, end) for (int i = start; i <= end; i++)
const int INF = 1001001001;
typedef long long ll;
const ll MOD = 1000000007;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> auto MAX(const T &a) {
return *max_element(a.begin(), a.end());
}
template <class T> auto MIN(const T &a) {
return *min_element(a.begin(), a.end());
}
template <class T, class U> U SUM(const T &a, const U &v) {
return accumulate(a.begin(), a.end(), v);
}
template <class T, class U> U COUNT(const T &a, const U &v) {
return count(a.begin(), a.end(), v);
}
template <class T, class U> int LOWER(const T &a, const U &v) {
return lower_bound(a.begin(), a.end(), v) - a.begin();
}
template <class T, class U> int UPPER(const T &a, const U &v) {
return upper_bound(a.begin(), a.end(), v) - a.begin();
}
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int LCM(int a, int b) {
int g = GCD(a, b);
return a / g * b;
}
bool vector_finder(std::vector<int> vec, int number) {
auto itr = std::find(vec.begin(), vec.end(), number);
size_t index = std::distance(vec.begin(), itr);
if (index != vec.size()) { // 発見できたとき
return true;
} else { // 発見できなかったとき
return false;
}
}
int main(void) {
// Your code here!
int n, m;
cin >> n >> m;
int a;
vector<ll> dp(n + 1, 0);
rep(i, m) {
cin >> a;
dp[a] = -1;
}
dp[0] = 1;
if (dp[1] != -1)
dp[1] = 1;
FOR(i, 2, n) {
if (dp[i] == -1)
continue;
if (dp[i - 1] != -1)
dp[i] += dp[i - 1];
if (dp[i - 2] != -1)
dp[i] += dp[i - 2];
dp[i] %= MOD;
}
cout << dp[n] << endl;
}
| [
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change"
] | 825,015 | 825,016 | u852862907 | 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>;
ll dp[100100];
const int mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
rep(i, m) {
int a;
cin >> a;
dp[a] = -1;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (dp[i] == -1)
continue;
if (dp[i - 1] != -1) {
dp[i] += dp[i - 1] % mod;
}
if (i > 1 && dp[i - 2] != -1) {
dp[i] += dp[i - 2] % mod;
}
}
// rep(i, n + 1) cout << i << " : " << dp[i] % mod << endl;
cout << dp[n] << 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>;
ll dp[100100];
const int mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
rep(i, m) {
int a;
cin >> a;
dp[a] = -1;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (dp[i] == -1)
continue;
if (dp[i - 1] != -1) {
dp[i] += dp[i - 1] % mod;
}
if (i > 1 && dp[i - 2] != -1) {
dp[i] += dp[i - 2] % mod;
}
}
// rep(i, n + 1) cout << i << " : " << dp[i] % mod << endl;
cout << dp[n] % mod << endl;
return 0;
} | [
"expression.operation.binary.add"
] | 825,021 | 825,022 | u337734014 | 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>;
ll dp[100100];
const int mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
rep(i, m) {
int a;
cin >> a;
dp[a] = -1;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (dp[i] == -1)
continue;
if (dp[i - 1] != -1) {
dp[i] += dp[i - 1];
}
if (i > 1 && dp[i - 2] != -1) {
dp[i] += dp[i - 2];
}
}
// rep(i, n + 1) cout << i << " : " << dp[i] % mod << 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>;
ll dp[100100];
const int mod = 1000000007;
int main() {
int n, m;
cin >> n >> m;
rep(i, m) {
int a;
cin >> a;
dp[a] = -1;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (dp[i] == -1)
continue;
if (dp[i - 1] != -1) {
dp[i] += dp[i - 1] % mod;
}
if (i > 1 && dp[i - 2] != -1) {
dp[i] += dp[i - 2] % mod;
}
}
// rep(i, n + 1) cout << i << " : " << dp[i] % mod << endl;
cout << dp[n] % mod << endl;
return 0;
} | [
"assignment.change"
] | 825,023 | 825,022 | u337734014 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<bool> ng(m);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
ng[a] = true;
}
const ll mod = 1e9 + 7;
vector<ll> memo(n + 1, -1);
memo[0] = 1;
function<ll(int)> f = [&](int n) -> ll {
if (n < 0)
return 0;
if (memo[n] != -1)
return memo[n];
if (ng[n])
return 0;
return memo[n] = (f(n - 1) + f(n - 2)) % mod;
};
cout << f(n) << endl;
// vector<ll> dp(n + 1, 0);
// dp[0] = 1;
// for (int i = 1; i <= n; i++) {
// if (find(a.begin(), a.end(), i) != a.end())
// continue;
// dp[i] += dp[i - 1];
// dp[i] %= mod;
// if (i > 1) {
// dp[i] += dp[i - 2];
// dp[i] %= mod;
// }
// }
//
// cout << dp[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<bool> ng(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
ng[a] = true;
}
const ll mod = 1e9 + 7;
vector<ll> memo(n + 1, -1);
memo[0] = 1;
function<ll(int)> f = [&](int n) -> ll {
if (n < 0)
return 0;
if (memo[n] != -1)
return memo[n];
if (ng[n])
return 0;
return memo[n] = (f(n - 1) + f(n - 2)) % mod;
};
cout << f(n) << endl;
// vector<ll> dp(n + 1, 0);
// dp[0] = 1;
// for (int i = 1; i <= n; i++) {
// if (find(a.begin(), a.end(), i) != a.end())
// continue;
// dp[i] += dp[i - 1];
// dp[i] %= mod;
// if (i > 1) {
// dp[i] += dp[i - 2];
// dp[i] %= mod;
// }
// }
//
// cout << dp[n] << endl;
return 0;
}
| [
"assignment.change"
] | 825,037 | 825,038 | u642276346 | 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>;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a + 1] = 1;
}
vector<int> dp(n + 2);
const int mod = 1e9 + 7;
dp[1] = 1;
for (int i = 2; i <= n + 1; i++) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i - 1] + dp[i - 2]) % mod;
}
cout << dp[n + 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 2);
rep(i, m) {
int a;
cin >> a;
broken[a + 1] = 1;
}
vector<int> dp(n + 2);
const int mod = 1e9 + 7;
dp[1] = 1;
for (int i = 2; i <= n + 1; i++) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i - 1] + dp[i - 2]) % mod;
}
cout << dp[n + 1] << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 825,045 | 825,046 | u171400122 | cpp |
p03013 | #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
typedef long long ll;
using namespace std;
int main() {
int n, m, temp;
cin >> n >> m;
vector<bool> broken(m);
vector<ll> dp(n + 1);
for (int i = 0; i < m; i++) {
cin >> temp;
broken[temp] = true;
}
dp[0] = 1;
if (!broken[1])
dp[1] = 1;
for (int i = 2; i <= n; i++) {
if (!broken[i]) {
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= MOD;
}
}
cout << dp[n] << endl;
return 0;
}
| #include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
typedef long long ll;
using namespace std;
int main() {
int n, m, temp;
cin >> n >> m;
vector<bool> broken(n + 1);
vector<ll> dp(n + 1);
for (int i = 0; i < m; i++) {
cin >> temp;
broken[temp] = true;
}
dp[0] = 1;
if (!broken[1])
dp[1] = 1;
for (int i = 2; i <= n; i++) {
if (!broken[i]) {
dp[i] = dp[i - 1] + dp[i - 2];
dp[i] %= MOD;
}
}
cout << dp[n] << endl;
return 0;
}
| [
"assignment.change"
] | 825,059 | 825,060 | u075296067 | cpp |
p03013 | #include <bits/stdc++.h>
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define INF 1000000000
using namespace std;
typedef long long ll;
int mod = 1000000007;
// Typical DP
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);
dp[N] = 1;
FORD(i, N - 1, 0) {
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 (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define INF 1000000000
using namespace std;
typedef long long ll;
int mod = 1000000007;
// Typical DP
int main() {
int N, M;
cin >> N >> M;
vector<int> broken(N + 1);
REP(i, M) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(N + 2);
dp[N] = 1;
FORD(i, N - 1, 0) {
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"
] | 825,088 | 825,089 | u511096055 | cpp |
p03013 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define DEBUG 1
using namespace std;
constexpr int kMod = 1000000007;
typedef long long LL;
template <typename T> istream &operator>>(istream &is, vector<T> &vs) {
for (T &v : vs)
is >> v;
return is;
}
LL add(LL a, LL b) { return (a + b) % kMod; }
int main() {
int N, M;
cin >> N >> M;
set<int> A;
for (int i = 0; i < N; ++i) {
int a;
cin >> a;
A.insert(a);
}
vector<LL> dp(N + 1);
dp[0] = 1;
dp[1] = (A.count(1)) ? 0 : 1;
for (int i = 2; i <= N; ++i) {
if (A.count(i)) {
dp[i] = 0;
} else {
dp[i] = add(dp[i - 2], dp[i - 1]);
}
}
cout << dp[N] << endl;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define DEBUG 1
using namespace std;
constexpr int kMod = 1000000007;
typedef long long LL;
template <typename T> istream &operator>>(istream &is, vector<T> &vs) {
for (T &v : vs)
is >> v;
return is;
}
LL add(LL a, LL b) { return (a + b) % kMod; }
int main() {
int N, M;
cin >> N >> M;
set<LL> A;
for (int i = 0; i < M; ++i) {
int a;
cin >> a;
A.insert(a);
}
vector<LL> dp(N + 1);
dp[0] = 1;
dp[1] = (A.count(1)) ? 0 : 1;
for (int i = 2; i <= N; ++i) {
if (A.count(i)) {
dp[i] = 0;
} else {
dp[i] = add(dp[i - 2], dp[i - 1]);
}
}
cout << dp[N] << endl;
}
| [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 825,092 | 825,093 | u116523315 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(obj) (obj).begin(), (obj).end()
#define bit(n) (1LL << (n))
typedef long long ll;
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<bool> issafe;
issafe.assign(n + 1, true);
rep(i, n) {
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 + 1; ++i) {
if (issafe[i - 1])
dp[i] += dp[i - 1];
if (issafe[i - 2])
dp[i] += dp[i - 2];
dp[i] = dp[i] % 1000000007;
}
cout << dp[n];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(obj) (obj).begin(), (obj).end()
#define bit(n) (1LL << (n))
typedef long long ll;
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const long long INF = 1LL << 60;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<bool> issafe;
issafe.assign(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 + 1; ++i) {
if (issafe[i - 1])
dp[i] += dp[i - 1];
if (issafe[i - 2])
dp[i] += dp[i - 2];
dp[i] = dp[i] % 1000000007;
}
cout << dp[n];
return 0;
}
| [] | 825,102 | 825,103 | u931191237 | cpp |
p03013 | #include "bits/stdc++.h"
#define rep(i, j) for (int i = 0; i < j; i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using ull = unsigned long long;
ll gcd(ll x, ll y);
int fac(ll n, vector<int> num);
const int INF = 1001001001;
// mint�p�̒萔 (10��9��)
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n + 1, 0);
rep(i, m) {
int num;
cin >> num;
a[num] = 1;
}
vector<mint> dp(n + 2, 0);
dp[n] = 1;
for (int i = n - 2; i >= 0; i--) {
if (a[i] == 1)
continue;
dp[i] = dp[i + 1] + dp[i + 2];
}
cout << dp[0] << endl;
return 0;
}
/*���C�u�����ő����*/
//���[�O���b�h�̌ݏ��@
ll gcd(ll x, ll y) {
ll num[3];
num[0] = (x > y) ? x : y;
num[1] = (x <= y) ? x : y;
num[2] = num[0] % num[1];
while (num[2]) {
num[0] = num[1];
num[1] = num[2];
num[2] = num[0] % num[1];
}
return num[1];
}
/*�f��������*/
//���색�C�u����
int fac(ll n, vector<int> num) {
ll kazu = n;
for (int i = 2; i <= sqrt(n); i++) {
while (1) {
if (kazu % i != 0)
break;
kazu /= i;
num[i]++;
}
}
if (kazu == n && n != 1)
return 1;
int ans = 0;
if (kazu != 1)
ans++;
for (int i = 2; i <= sqrt(n); i++) {
for (int j = 1; j <= num[i]; j++) {
num[i] -= j;
ans++;
}
}
return ans;
} | #include "bits/stdc++.h"
#define rep(i, j) for (int i = 0; i < j; i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using ull = unsigned long long;
ll gcd(ll x, ll y);
int fac(ll n, vector<int> num);
const int INF = 1001001001;
// mint�p�̒萔 (10��9��)
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n + 1, 0);
rep(i, m) {
int num;
cin >> num;
a[num] = 1;
}
vector<mint> dp(n + 2, 0);
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (a[i] == 1)
continue;
dp[i] = dp[i + 1] + dp[i + 2];
}
cout << dp[0] << endl;
return 0;
}
/*���C�u�����ő����*/
//���[�O���b�h�̌ݏ��@
ll gcd(ll x, ll y) {
ll num[3];
num[0] = (x > y) ? x : y;
num[1] = (x <= y) ? x : y;
num[2] = num[0] % num[1];
while (num[2]) {
num[0] = num[1];
num[1] = num[2];
num[2] = num[0] % num[1];
}
return num[1];
}
/*�f��������*/
//���색�C�u����
int fac(ll n, vector<int> num) {
ll kazu = n;
for (int i = 2; i <= sqrt(n); i++) {
while (1) {
if (kazu % i != 0)
break;
kazu /= i;
num[i]++;
}
}
if (kazu == n && n != 1)
return 1;
int ans = 0;
if (kazu != 1)
ans++;
for (int i = 2; i <= sqrt(n); i++) {
for (int j = 1; j <= num[i]; j++) {
num[i] -= j;
ans++;
}
}
return ans;
} | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 825,109 | 825,110 | u616794313 | 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 INF = 10e9;
const ll mod = 10e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<int> dp(n + 1, -1);
dp[0] = 1;
dp[1] = 1;
rep(i, m) {
int a;
cin >> a;
dp[a] = 0;
}
for (int i = 2; i <= n; i++) {
if (dp[i] != 0)
dp[i] = (dp[i - 1] + dp[i - 2]) % mod;
}
cout << dp[n] << 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 INF = 10e9;
const ll mod = 10e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<ll> dp(n + 1, -1);
dp[0] = 1;
dp[1] = 1;
rep(i, m) {
int a;
cin >> a;
dp[a] = 0;
}
for (int i = 2; i <= n; i++) {
if (dp[i] != 0)
dp[i] = (dp[i - 1] + dp[i - 2]) % 1000000007;
}
cout << dp[n] << endl;
} | [
"assignment.value.change",
"identifier.replace.remove",
"literal.replace.add",
"expression.operation.binary.change"
] | 825,117 | 825,118 | u166553470 | cpp |
p03013 | #include <bits/stdc++.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define size_of_array(array) (sizeof(array) / sizeof(array[0]))
using ll = long long;
using namespace std;
using Graph = vector<vector<int>>;
using Field = vector<vector<int>>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const int modn = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<ll> dp(n + 1);
for (int i = 0; i <= n; ++i) {
if (!broken[i]) {
if (i == 0)
dp[i] = 1;
else if (i == 1)
dp[i] = 1;
else
dp[i] = (dp[i - 1] + dp[i - 2]) % modn;
} else {
dp[i] = 0;
}
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define size_of_array(array) (sizeof(array) / sizeof(array[0]))
using ll = long long;
using namespace std;
using Graph = vector<vector<int>>;
using Field = vector<vector<int>>;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const int modn = 1000000007;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<ll> dp(n + 1);
for (int i = 0; i <= n; ++i) {
if (!broken[i]) {
if (i == 0)
dp[i] = 1;
else if (i == 1)
dp[i] = 1;
else
dp[i] = (dp[i - 1] + dp[i - 2]) % modn;
} else {
dp[i] = 0;
}
}
cout << dp[n] << endl;
} | [
"assignment.change"
] | 825,133 | 825,134 | u527105447 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
using namespace std;
const ll mod = 1000000007;
int main() {
ll n, m;
cin >> n >> m;
vector<bool> a(n + 1, true);
rep(i, n) {
ll x;
cin >> x;
a[x] = false;
}
vector<ll> dp(n + 1, 0);
dp[0] = 1;
rep(i, n) {
if (a[i + 1])
dp[i + 1] = (dp[i] + dp[i + 1]) % mod;
if (i == n - 1)
break;
if (a[i + 2])
dp[i + 2] = (dp[i] + dp[i + 2]) % mod;
}
cout << dp[n] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; i++)
using namespace std;
const ll mod = 1000000007;
int main() {
ll n, m;
cin >> n >> m;
vector<bool> a(n + 1, true);
rep(i, m) {
ll x;
cin >> x;
a[x] = false;
}
vector<ll> dp(n + 1, 0);
dp[0] = 1;
rep(i, n) {
if (a[i + 1])
dp[i + 1] = (dp[i] + dp[i + 1]) % mod;
if (i == n - 1)
break;
if (a[i + 2])
dp[i + 2] = (dp[i] + dp[i + 2]) % mod;
}
cout << dp[n] << endl;
return 0;
} | [] | 825,138 | 825,139 | u622070196 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
bool ch[100010];
ll ans[100010];
int main() {
ll n, k;
cin >> n >> k;
for (ll i = 0; i < k; i++) {
ll x;
cin >> x;
ch[x] = true;
}
ans[0] = 1;
for (ll i = 0; i <= n; i++) {
ans[i + 2] += ans[i];
ans[i + 1] += ans[i];
// cout << ans[2]<<endl;
if (ch[i + 2] == true) {
ans[i + 2] = 0;
}
if (ch[i + 1] == true) {
ans[i + 1] = 0;
}
ans[i + 2] %= inf;
ans[i + 1] %= inf;
}
cout << ans[6];
// your code goes here
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL << 62
#define inf 1000000007
bool ch[100010];
ll ans[100010];
int main() {
ll n, k;
cin >> n >> k;
for (ll i = 0; i < k; i++) {
ll x;
cin >> x;
ch[x] = true;
}
ans[0] = 1;
for (ll i = 0; i <= n; i++) {
ans[i + 2] += ans[i];
ans[i + 1] += ans[i];
// cout << ans[2]<<endl;
if (ch[i + 2] == true) {
ans[i + 2] = 0;
}
if (ch[i + 1] == true) {
ans[i + 1] = 0;
}
ans[i + 2] %= inf;
ans[i + 1] %= inf;
}
cout << ans[n];
// your code goes here
return 0;
} | [
"identifier.replace.add",
"literal.replace.remove",
"variable_access.subscript.index.change",
"io.output.change"
] | 825,140 | 825,141 | u166378830 | cpp |
p03013 | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr ll MOD_LL = ll(1e9) + 7;
int main(void) {
int n, m;
cin >> n >> m;
vector<bool> ok(n + 1, true);
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
ok[a] = false;
}
vector<ll> dp(n + 1);
dp[0] = 1;
for (int i = 0; i < n; ++i) {
if (ok[i + 1]) {
dp[i + 1] += dp[i];
dp[i + 1] %= MOD_LL;
}
if (ok[i + 2]) {
dp[i + 2] += dp[i];
dp[i + 2] %= MOD_LL;
}
}
cout << dp[n] << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr ll MOD_LL = ll(1e9) + 7;
int main(void) {
int n, m;
cin >> n >> m;
vector<bool> ok(n + 1, true);
for (int i = 0; i < m; ++i) {
int a;
cin >> a;
ok[a] = false;
}
vector<ll> dp(100005);
dp[0] = 1;
for (int i = 0; i < n; ++i) {
if (ok[i + 1]) {
dp[i + 1] += dp[i];
dp[i + 1] %= MOD_LL;
}
if (ok[i + 2]) {
dp[i + 2] += dp[i];
dp[i + 2] %= MOD_LL;
}
}
cout << dp[n] << endl;
return 0;
}
| [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"expression.operation.binary.remove"
] | 825,160 | 825,161 | u835805357 | cpp |
p03013 | #include <iostream>
#include <vector>
using namespace std;
int N, M;
int a[100000];
vector<bool> a_d(100001, false);
long long num[100001];
const long long dv = 1e9 + 7;
void solve() {
num[0] = 1;
if (!a_d[1])
num[0] = 1;
for (int i = 2; i <= N; i++) {
if (!a_d[i]) {
num[i] = (num[i - 2] + num[i - 1]) % dv;
}
}
long long ans = num[N];
cout << ans << endl;
}
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> a[i];
a_d[a[i]] = true;
}
solve();
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
int N, M;
int a[100000];
vector<bool> a_d(100001, false);
long long num[100001];
const long long dv = 1e9 + 7;
void solve() {
num[0] = 1;
if (!a_d[1])
num[1] = 1;
for (int i = 2; i <= N; i++) {
if (!a_d[i]) {
num[i] = (num[i - 2] + num[i - 1]) % dv;
}
}
long long ans = num[N];
cout << ans << endl;
}
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> a[i];
a_d[a[i]] = true;
}
solve();
return 0;
}
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 825,171 | 825,172 | u748577909 | cpp |
p03013 | #include <bits/stdc++.h>
#include <iostream>
#include <math.h>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int64_t N, M;
cin >> N >> M;
vector<int64_t> dp(N + 1, 0);
for (int64_t i = 0; i < M; i++) {
int64_t num;
cin >> num;
dp[num] = -1;
}
dp[0] = 1;
for (int64_t i = 1; i <= N; i++) {
if (dp[i] == -1)
continue;
int64_t pattern = 0;
if (dp[i - 1] != -1)
pattern += dp[i - 1];
if (i > 1 && dp[i - 2] != -1)
pattern += dp[i - 2];
dp[i] = pattern;
}
cout << dp[N] % 1000000007 << endl;
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
#include <math.h>
using namespace std;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
int64_t N, M;
cin >> N >> M;
vector<int64_t> dp(N + 1, 0);
for (int64_t i = 0; i < M; i++) {
int64_t num;
cin >> num;
dp[num] = -1;
}
dp[0] = 1;
for (int64_t i = 1; i <= N; i++) {
if (dp[i] == -1)
continue;
int64_t pattern = 0;
if (dp[i - 1] != -1)
pattern += dp[i - 1];
if (i > 1 && dp[i - 2] != -1)
pattern += dp[i - 2];
dp[i] = pattern % 1000000007;
}
cout << dp[N] << endl;
return 0;
} | [
"assignment.change",
"expression.operation.binary.remove"
] | 825,177 | 825,178 | u651314218 | cpp |
p03013 | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
oset;
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
using ll = long long;
const int mod = 1e9 + 7;
ll dp[100005];
void test_case() {
int n, m;
cin >> n >> m;
set<int> hash;
dp[0] = 1;
dp[1] = 2;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (x == 1)
dp[1] = 0;
if (x == 0)
dp[2] = 0;
hash.insert(x);
}
for (int i = 2; i <= n; i++) {
if (hash.find(i) != hash.end())
dp[i] = 0;
else
dp[i] = (dp[i - 1] + dp[i - 2]) % mod;
}
cout << dp[n] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
//~ cin >> T;
while (T--) {
test_case();
}
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag,
tree_order_statistics_node_update>
oset;
#define sim template <class c
#define ris return *this
#define dor > debug &operator<<
#define eni(x) \
sim > typename enable_if<sizeof dud<c>(0) x 1, debug &>::type operator<<( \
c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c *x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i;
ris;
} eni(==) ris << range(begin(i), end(i));
}
sim, class b dor(pair<b, c> d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c &) { ris; }
#endif
}
;
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
using ll = long long;
const int mod = 1e9 + 7;
ll dp[100005];
void test_case() {
int n, m;
cin >> n >> m;
set<int> hash;
dp[0] = 1;
dp[1] = 1;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (x == 1)
dp[1] = 0;
if (x == 0)
dp[0] = 0;
hash.insert(x);
}
for (int i = 2; i <= n; i++) {
if (hash.find(i) != hash.end())
dp[i] = 0;
else
dp[i] = (dp[i - 1] + dp[i - 2]) % mod;
}
cout << dp[n] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
//~ cin >> T;
while (T--) {
test_case();
}
return 0;
}
| [
"literal.number.change",
"assignment.value.change",
"assignment.variable.change",
"variable_access.subscript.index.change"
] | 825,187 | 825,188 | u306697932 | cpp |
p03013 | #include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 1);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | #include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 825,197 | 825,198 | u651197500 | cpp |
p03013 | #include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 1);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = dp[i + 1] + dp[i + 2] % mod;
}
cout << dp[0] << endl;
return 0;
} | #include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 825,199 | 825,198 | u651197500 | cpp |
p03013 | #include <bits/stdc++.h>
#define ll long long
#define EPS (ll)1e-9
#define N (ll)(2 * 1e5)
#define M (ll)(1e9 + 7)
using namespace std;
bitset<100001> trap;
ll dp[N];
ll solve(ll n) {
dp[0] = 1;
dp[1] = trap[1] ? 0 : 1;
for (ll i = 2; i <= n; i++) {
if (trap[i])
dp[i] = 0;
else
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n] % M;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(NULL));
ll n, m, pos;
cin >> n >> m;
for (ll i = 0; i < m; i++) {
cin >> pos;
trap[pos] = true;
}
cout << solve(n) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define EPS (ll)1e-9
#define N (ll)(2 * 1e5)
#define M (ll)(1e9 + 7)
using namespace std;
bitset<100010> trap;
ll dp[N];
ll solve(ll n) {
dp[0] = 1;
dp[1] = trap[1] ? 0 : 1;
for (ll i = 2; i <= n; i++) {
if (trap[i])
dp[i] = 0;
else
dp[i] = (dp[i - 1] + dp[i - 2]) % M;
}
return dp[n] % M;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(NULL));
ll n, m, pos;
cin >> n >> m;
for (ll i = 0; i < m; i++) {
cin >> pos;
trap[pos] = true;
}
cout << solve(n) << endl;
return 0;
}
| [
"literal.number.change",
"assignment.change"
] | 825,200 | 825,201 | u863370423 | cpp |
p03013 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
const int64_t mod = 1000000007;
int main() {
int64_t n, m;
cin >> n >> m;
vector<bool> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken.at(a) = true;
}
vector<int64_t> dp(n + 2);
dp.at(n) = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken.at(i)) {
dp.at(i) = 0;
} else {
dp.at(i) = dp.at(i + 1) + dp.at(i + 2) % mod;
}
}
cout << dp.at(0) << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
const int64_t mod = 1000000007;
int main() {
int64_t n, m;
cin >> n >> m;
vector<bool> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken.at(a) = true;
}
vector<int64_t> dp(n + 2);
dp.at(n) = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken.at(i)) {
dp.at(i) = 0;
continue;
} else {
dp.at(i) = (dp.at(i + 1) + dp.at(i + 2)) % mod;
}
}
cout << dp.at(0) << endl;
return 0;
} | [] | 825,207 | 825,208 | u370865069 | cpp |
p03013 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
/*
using PAIR = pair<string, int>;
sort(sp.begin(), sp.end(), [](PAIR l, PAIR r){
return l.first<r.first || (l.first==r.first && l.second > r.second);
});
*/
typedef long long ll;
#define fi first
#define se second
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
for (int i = 0; i < v.size(); i++) { \
cout << v[i] << " "; \
} \
cout << endl;
using Graph = vector<vector<int>>;
using PAIR = pair<string, int>;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m;
cin >> n >> m;
vector<ll> dp(n + 10, 0);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
dp[a] = -1;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (dp[i] != -1) {
if (i != 1) {
if (dp[i - 1] == -1 && dp[i - 2] == -1) {
cout << -1 << endl;
return 0;
}
dp[i] = (max(dp[i - 1], 0ll) + max(dp[i - 2], 0ll)) % mod;
} else {
dp[i] = max(dp[i - 1], 0ll);
}
}
}
cout << dp[n] % mod << endl;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
/*
using PAIR = pair<string, int>;
sort(sp.begin(), sp.end(), [](PAIR l, PAIR r){
return l.first<r.first || (l.first==r.first && l.second > r.second);
});
*/
typedef long long ll;
#define fi first
#define se second
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
for (int i = 0; i < v.size(); i++) { \
cout << v[i] << " "; \
} \
cout << endl;
using Graph = vector<vector<int>>;
using PAIR = pair<string, int>;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m;
cin >> n >> m;
vector<ll> dp(n + 10, 0);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
dp[a] = -1;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (dp[i] != -1) {
if (i != 1) {
if (dp[i - 1] == -1 && dp[i - 2] == -1) {
cout << 0 << endl;
return 0;
}
dp[i] = (max(dp[i - 1], 0ll) + max(dp[i - 2], 0ll)) % mod;
} else {
dp[i] = max(dp[i - 1], 0ll);
}
}
}
cout << dp[n] % mod << endl;
return 0;
} | [
"literal.number.change",
"io.output.change"
] | 825,209 | 825,210 | u275934251 | cpp |
p03013 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int INF = 1e9;
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;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int INF = 1e9;
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;
}
| [
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change"
] | 825,257 | 825,258 | u110653681 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
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;
}
int dp[100001] = {1};
bool ok[100001];
int main() {
int n, m;
int tmp;
cin >> n >> m;
for (int i = 0; i < n; i++)
ok[i] = true;
for (int i = 0; i < m; i++) {
cin >> tmp;
ok[tmp] = false;
}
if (ok[1]) {
dp[1] = 1;
}
for (int i = 2; i <= n; i++) {
dp[i] %= MOD;
if (ok[i - 1])
dp[i] += (dp[i - 1] % MOD);
dp[i] %= MOD;
if (ok[i - 2])
dp[i] += (dp[i - 2] % MOD);
dp[i] %= MOD;
}
dp[n] %= MOD;
cout << dp[n] << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define MOD 1000000007
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;
}
int dp[100001] = {1};
bool ok[100001];
int main() {
int n, m;
int tmp;
cin >> n >> m;
for (int i = 0; i <= n; i++)
ok[i] = true;
for (int i = 0; i < m; i++) {
cin >> tmp;
ok[tmp] = false;
}
if (ok[1]) {
dp[1] = 1;
}
for (int i = 2; i <= n; i++) {
dp[i] %= MOD;
if (ok[i - 1])
dp[i] += (dp[i - 1] % MOD);
dp[i] %= MOD;
if (ok[i - 2])
dp[i] += (dp[i - 2] % MOD);
dp[i] %= MOD;
}
dp[n] %= 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"
] | 825,261 | 825,262 | u145483532 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(n + 2);
dp[n] = 1;
const int mod = 1000000007;
for (int i = n; 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;
cin >> n >> m;
vector<bool> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(n + 2);
dp[n] = 1;
const int mod = 1000000007;
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;
}
| [
"control_flow.loop.for.initializer.change"
] | 825,285 | 825,286 | u834753207 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(n + 2);
dp[n] = 1;
int mod = 1000000007;
for (int i = n; i >= 0; i--) {
if (broken[i]) {
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<bool> broken(n + 1);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(n + 2);
dp[n] = 1;
const int mod = 1000000007;
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;
}
| [
"control_flow.loop.for.initializer.change",
"assignment.change",
"control_flow.return.add",
"control_flow.return.0.add"
] | 825,287 | 825,286 | u834753207 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define POSSIBLE(n) cout << ((n) ? "POSSIBLE" : "IMPOSSIBLE") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define rep(i, n) REP(i, 0, n) // 0, 1, ..., n-1
#define REP(i, x, n) for (int i = x; i < n; i++) // x, x + 1, ..., n-1
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define COUT(x) cout << (x) << endl
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, m;
cin >> N >> m;
vector<int> check(N + 1, m);
rep(i, m) {
int a;
cin >> a;
check[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 (check[next]) {
dp[next] += dp[now];
dp[next] %= MOD;
}
}
}
COUT(dp[N]);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
#define dump(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define POSSIBLE(n) cout << ((n) ? "POSSIBLE" : "IMPOSSIBLE") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define rep(i, n) REP(i, 0, n) // 0, 1, ..., n-1
#define REP(i, x, n) for (int i = x; i < n; i++) // x, x + 1, ..., n-1
#define FOREACH(x, a) for (auto &(x) : (a))
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define COUT(x) cout << (x) << endl
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, m;
cin >> N >> m;
vector<int> check(N + 1, true);
rep(i, m) {
int a;
cin >> a;
check[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 (check[next]) {
dp[next] += dp[now];
dp[next] %= MOD;
}
}
}
COUT(dp[N]);
} | [
"call.arguments.change"
] | 825,290 | 825,291 | u038027079 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mx 100005
ll broken[mx] = {0};
ll dp[mx] = {0};
#define mod 1000000007
int main() {
ios_base::sync_with_stdio(0);
ll n, m, a;
cin >> n;
cin >> m;
for (int i = 1; i <= n; i++) {
cin >> a;
broken[a] = 1;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
ll total = 0;
if (i - 1 >= 0 && broken[i - 1] == 0)
total += dp[i - 1];
if (i - 2 >= 0 && broken[i - 2] == 0)
total += dp[i - 2];
dp[i] = total % mod;
}
cout << dp[n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mx 100005
ll broken[mx] = {0};
ll dp[mx] = {0};
#define mod 1000000007
int main() {
ios_base::sync_with_stdio(0);
ll n, m, a;
cin >> n;
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> a;
broken[a] = 1;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
ll total = 0;
if (i - 1 >= 0 && broken[i - 1] == 0)
total += dp[i - 1];
if (i - 2 >= 0 && broken[i - 2] == 0)
total += dp[i - 2];
dp[i] = total % mod;
}
cout << dp[n] << endl;
} | [
"identifier.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change"
] | 825,295 | 825,296 | u701914155 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
int main() {
int n, m, k;
cin >> n >> m;
set<int> drop;
rep(i, m) {
cin >> k;
drop.insert(k);
}
vector<int> dp(n + 1);
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (drop.count(i) == 1)
dp[i] == 0;
else
dp[i] = (dp[i + 1] + dp[i + 2]) % 1000000007;
}
cout << dp[0] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
int main() {
int n, m, k;
cin >> n >> m;
set<int> drop;
rep(i, m) {
cin >> k;
drop.insert(k);
}
vector<int> dp(n + 2);
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (drop.count(i))
dp[i] = 0;
else
dp[i] = (dp[i + 1] + dp[i + 2]) % 1000000007;
}
cout << dp[0] << endl;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.remove",
"expression.operation.compare.replace.remove",
"assignment.replace.add",
"misc.typo"
] | 825,297 | 825,298 | u436733497 | 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>;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 1);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 825,310 | 825,311 | u108108663 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m; //入力
vector<ll> broken(n); //壊れた段を記録する配列
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
} //壊れた段を1として記録
vector<ll> dp(n + 1); // DP配列
dp[1] = 1;
dp[2] = 2; // 1、2段目が壊れていないときの初期条件
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
} // 1段目が壊れているときの初期条件
if (broken[2] != 0)
dp[2] = 0; // 2段目が壊れているときの初期条件
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = dp[i - 1] % MOD + dp[i - 2] % MOD;
else
dp[i] = 0;
} // 3段目以降DPをする
cout << dp[n] % MOD << endl; //出力
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m;
vector<ll> broken(n + 1);
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
}
vector<ll> dp(n + 1);
dp[1] = 1;
dp[2] = 2;
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
}
if (broken[2] != 0)
dp[2] = 0;
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = dp[i - 1] % MOD + dp[i - 2] % MOD;
else
dp[i] = 0;
}
cout << dp[n] % MOD << endl;
return 0;
} | [
"assignment.change"
] | 825,333 | 825,334 | u443971699 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m; //入力
vector<ll> broken(n); //壊れた段を記録する配列
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
} //壊れた段を1として記録
vector<ll> dp(n + 1); // DP配列
dp[1] = 1;
dp[2] = 2; // 1、2段目が壊れていないときの初期条件
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
} // 1段目が壊れているときの初期条件
if (broken[2] != 0)
dp[2] = 0; // 2段目が壊れているときの初期条件
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = dp[i - 1] % MOD + dp[i - 2] % MOD;
else
dp[i] = 0;
} // 3段目以降DPをする
cout << dp[n] % MOD << endl; //出力
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m; //入力
vector<ll> broken(n + 1); //壊れた段を記録する配列
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
} //壊れた段を1として記録
vector<ll> dp(n + 1); // DP配列
dp[1] = 1;
dp[2] = 2; // 1、2段目が壊れていないときの初期条件
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
} // 1段目が壊れているときの初期条件
if (broken[2] != 0)
dp[2] = 0; // 2段目が壊れているときの初期条件
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = dp[i - 1] % MOD + dp[i - 2] % MOD;
else
dp[i] = 0;
} // 3段目以降DPをする
cout << dp[n] % MOD << endl; //出力
return 0;
}
| [
"assignment.change"
] | 825,335 | 825,336 | u023958502 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m; //入力
vector<ll> broken(n); //壊れた段を記録する配列
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
} //壊れた段を1として記録
vector<ll> dp(n + 1); // DP配列
dp[1] = 1;
dp[2] = 2; // 1、2段目が壊れていないときの初期条件
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
} // 1段目が壊れているときの初期条件
if (broken[2] != 0)
dp[2] = 0; // 2段目が壊れているときの初期条件
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
else
dp[i] = 0;
} // 3段目以降DPをする
cout << dp[n] % MOD << endl; //出力
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m; //入力
vector<ll> broken(n + 1); //壊れた段を記録する配列
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
} //壊れた段を1として記録
vector<ll> dp(n + 1); // DP配列
dp[1] = 1;
dp[2] = 2; // 1、2段目が壊れていないときの初期条件
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
} // 1段目が壊れているときの初期条件
if (broken[2] != 0)
dp[2] = 0; // 2段目が壊れているときの初期条件
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = dp[i - 1] % MOD + dp[i - 2] % MOD;
else
dp[i] = 0;
} // 3段目以降DPをする
cout << dp[n] % MOD << endl; //出力
return 0;
}
| [
"assignment.change"
] | 825,337 | 825,336 | u023958502 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m; //入力
vector<ll> broken(n); //壊れた段を記録する配列
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
} //壊れた段を1として記録
vector<ll> dp(n + 1); // DP配列
dp[1] = 1;
dp[2] = 2; // 1、2段目が壊れていないときの初期条件
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
} // 1段目が壊れているときの初期条件
if (broken[2] != 0)
dp[2] = 0; // 2段目が壊れているときの初期条件
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = dp[i - 1] % MOD + dp[i - 2] % MOD;
else
dp[i] = 0;
} // 3段目以降DPをする
cout << dp[n] % MOD << endl; //出力
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m; //入力
vector<ll> broken(n + 1); //壊れた段を記録する配列
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
} //壊れた段を1として記録
vector<ll> dp(n + 1); // DP配列
dp[1] = 1;
dp[2] = 2; // 1、2段目が壊れていないときの初期条件
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
} // 1段目が壊れているときの初期条件
if (broken[2] != 0)
dp[2] = 0; // 2段目が壊れているときの初期条件
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = dp[i - 1] % MOD + dp[i - 2] % MOD;
else
dp[i] = 0;
} // 3段目以降DPをする
cout << dp[n] % MOD << endl; //出力
return 0;
}
| [
"assignment.change"
] | 825,338 | 825,336 | u023958502 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m; //入力
vector<ll> broken(n); //壊れた段を記録する配列
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
} //壊れた段を1として記録
vector<ll> dp(n + 1); // DP配列
dp[1] = 1;
dp[2] = 2; // 1、2段目が壊れていないときの初期条件
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
} // 1段目が壊れているときの初期条件
if (broken[2] != 0)
dp[2] = 0; // 2段目が壊れているときの初期条件
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
else
dp[i] = 0;
} // 3段目以降DPをする
cout << dp[n] % MOD << endl; //出力
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m; //入力
vector<ll> broken(n + 1); //壊れた段を記録する配列
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
} //壊れた段を1として記録
vector<ll> dp(n + 1); // DP配列
dp[1] = 1;
dp[2] = 2; // 1、2段目が壊れていないときの初期条件
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
} // 1段目が壊れているときの初期条件
if (broken[2] != 0)
dp[2] = 0; // 2段目が壊れているときの初期条件
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
else
dp[i] = 0;
} // 3段目以降DPをする
cout << dp[n] % MOD << endl; //出力
return 0;
}
| [
"assignment.change"
] | 825,337 | 825,342 | u023958502 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m; //入力
vector<ll> broken(n); //壊れた段を記録する配列
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
} //壊れた段を1として記録
vector<ll> dp(n + 1); // DP配列
dp[1] = 1;
dp[2] = 2; // 1、2段目が壊れていないときの初期条件
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
} // 1段目が壊れているときの初期条件
if (broken[2] != 0)
dp[2] = 0; // 2段目が壊れているときの初期条件
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = dp[i - 1] % MOD + dp[i - 2] % MOD;
else
dp[i] = 0;
} // 3段目以降DPをする
cout << dp[n] % MOD << endl; //出力
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pp pair<int, int>
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
#define rep2(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define ll long long
#define ld long double
#define all(a) (a).begin(), (a).end()
#define mk make_pair
ll mod = 998244353;
int inf = 1000001000;
ll INF = 1e18 + 5;
ll MOD = 1000000007;
int main() {
ll n, m;
cin >> n >> m; //入力
vector<ll> broken(n + 1); //壊れた段を記録する配列
rep(i, m) {
ll a;
cin >> a;
broken[a]++;
} //壊れた段を1として記録
vector<ll> dp(n + 1); // DP配列
dp[1] = 1;
dp[2] = 2; // 1、2段目が壊れていないときの初期条件
if (broken[1] != 0) {
dp[1] = 0;
dp[2] = 1;
} // 1段目が壊れているときの初期条件
if (broken[2] != 0)
dp[2] = 0; // 2段目が壊れているときの初期条件
rep2(i, 3, n + 1) {
if (broken[i] == 0)
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
else
dp[i] = 0;
} // 3段目以降DPをする
cout << dp[n] % MOD << endl; //出力
return 0;
}
| [
"expression.operation.binary.remove"
] | 825,338 | 825,342 | u023958502 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define All(a) a.begin(), a.end()
#define INF 1000000007
const int MOD = 1000000007;
// accumulate(vec.begin(), vec.end(), 0)
// std::sort(v.begin(), v.end(), std::greater<Type>());
ll n, m;
vector<bool> A;
int main() {
cin >> n >> m;
A.assign(n + 1, true);
for (int i = 0; i < m; i++) {
ll a;
cin >> a;
A[a] = false;
}
vector<ll> DP(n + 1, 0);
DP[0] = 1;
if (A[1])
DP[1] = 1;
for (int i = 2; i < n + 1; i++) {
if (A[i - 1])
DP[i] += DP[i - 1];
if (A[i - 2])
DP[i] += DP[i - 2];
DP[i] % MOD;
}
cout << DP[n] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define All(a) a.begin(), a.end()
#define INF 1000000007
const int MOD = 1000000007;
// accumulate(vec.begin(), vec.end(), 0)
// std::sort(v.begin(), v.end(), std::greater<Type>());
ll n, m;
vector<bool> A;
int main() {
cin >> n >> m;
A.assign(n + 1, true);
for (int i = 0; i < m; i++) {
ll a;
cin >> a;
A[a] = false;
}
vector<ll> DP(n + 1, 0);
DP[0] = 1;
if (A[1])
DP[1] = 1;
for (int i = 2; i < n + 1; i++) {
if (A[i - 1])
DP[i] += DP[i - 1];
if (A[i - 2])
DP[i] += DP[i - 2];
DP[i] %= MOD;
}
cout << DP[n] << endl;
}
| [
"assignment.compound.arithmetic.replace.add",
"expression.operator.arithmetic.replace.remove",
"expression.operation.binary.change"
] | 825,386 | 825,387 | u229427161 | cpp |
p03013 | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define DEBUG
#define _GLIBCXX_DEBUG
#ifdef DEBUG
#define s(...) show(__VA_ARGS__);
#define sl(...) \
show(__VA_ARGS__); \
cout << endl;
#else
#define s(...)
#define sl(...)
#endif
void show() {}
template <class Head, class... Args> void show(Head t, Args... args) {
std::cout << t << " ";
show(args...);
}
#define REP(i, n) for (ll i = 1; i <= n; i++)
#define REPR(i, n) for (ll i = n; i >= 1; i--)
#define FOR(i, m, n) for (ll i = m; i <= n; i++)
#define INF 1e9 + 123
#define VEC(type, A, N) vector<type> A(N + 10)
#define VEC2(type, A, N, M) vector<vector<type>> A(N + 10, vector<type>(M + 10))
#define ALL(v) v.begin() + 1, v.end() - 9
int main() {
int N, M;
cin >> N >> M;
vector<int> a(N + 10, 0);
vector<ll> w(N + 10, -1);
w[1] = 1;
w[2] = 2;
REP(i, M) {
cin >> a[i];
w[a[i]] = 0;
}
if (w[1] == 0)
w[2] == 0 ? 0 : 1;
FOR(i, 3, N) {
if (w[i] == -1) {
w[i] = (w[i - 1] + w[i - 2]) % 1000000007;
};
}
cout << w[N];
// sort(ALL(C),[](auto& a, auto& b) {return a[2] < b[2];});
// if(equal(D.begin(), D.end()-1, K.begin()))cout<<"Yes";else cout<<"No";
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define DEBUG
#define _GLIBCXX_DEBUG
#ifdef DEBUG
#define s(...) show(__VA_ARGS__);
#define sl(...) \
show(__VA_ARGS__); \
cout << endl;
#else
#define s(...)
#define sl(...)
#endif
void show() {}
template <class Head, class... Args> void show(Head t, Args... args) {
std::cout << t << " ";
show(args...);
}
#define REP(i, n) for (ll i = 1; i <= n; i++)
#define REPR(i, n) for (ll i = n; i >= 1; i--)
#define FOR(i, m, n) for (ll i = m; i <= n; i++)
#define INF 1e9 + 123
#define VEC(type, A, N) vector<type> A(N + 10)
#define VEC2(type, A, N, M) vector<vector<type>> A(N + 10, vector<type>(M + 10))
#define ALL(v) v.begin() + 1, v.end() - 9
int main() {
int N, M;
cin >> N >> M;
vector<int> a(N + 10, 0);
vector<ll> w(N + 10, -1);
w[1] = 1;
w[2] = 2;
REP(i, M) {
cin >> a[i];
w[a[i]] = 0;
}
if (w[1] == 0)
w[2] = w[2] == 0 ? 0 : 1;
FOR(i, 3, N) {
if (w[i] == -1) {
w[i] = (w[i - 1] + w[i - 2]) % 1000000007;
};
}
cout << w[N];
// sort(ALL(C),[](auto& a, auto& b) {return a[2] < b[2];});
// if(equal(D.begin(), D.end()-1, K.begin()))cout<<"Yes";else cout<<"No";
return 0;
}
| [
"control_flow.branch.if.condition.change",
"assignment.change"
] | 825,390 | 825,391 | u304829684 | cpp |
p03013 | #include <iostream>
#include <vector>
typedef long long int ll;
const ll mod = 1e9 + 7;
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
vector<int> a(n + 1, true);
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = false;
}
vector<ll> dp(n + 1);
dp[n] = 1;
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
if (a[i]) {
dp[i] = dp[i + 1] + dp[i + 2];
dp[i] %= mod;
} else {
dp[i] = 0;
}
}
cout << dp[0] << endl;
return 0;
} | #include <iostream>
#include <vector>
typedef long long int ll;
const ll mod = 1e9 + 7;
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
vector<int> a(n + 1, true);
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = false;
}
vector<ll> dp(n + 2);
dp[n] = 1;
dp[n - 1] = 1;
for (int i = n - 1; i >= 0; i--) {
if (a[i]) {
dp[i] = dp[i + 1] + dp[i + 2];
dp[i] %= mod;
} else {
dp[i] = 0;
}
}
cout << dp[0] << endl;
return 0;
}
| [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 825,392 | 825,393 | u749089333 | cpp |
p03013 | #include <iostream>
#include <vector>
typedef long long int ll;
const ll mod = 1e9 + 7;
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
vector<int> a(n + 1, true);
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = false;
}
vector<ll> dp(n + 1);
dp[n] = 1;
dp[n - 1] = 1;
for (int i = n - 2; i >= 0; i--) {
if (a[i]) {
dp[i] = dp[i + 1] + dp[i + 2];
dp[i] %= mod;
} else {
dp[i] = 0;
}
}
cout << dp[0] << endl;
return 0;
} | #include <iostream>
#include <vector>
typedef long long int ll;
const ll mod = 1e9 + 7;
using namespace std;
int main(void) {
int n, m;
cin >> n >> m;
vector<int> a(n + 1, true);
for (int i = 0; i < m; i++) {
int x;
cin >> x;
a[x] = false;
}
vector<ll> dp(n + 2);
dp[n] = 1;
dp[n - 1] = 1;
for (int i = n - 1; i >= 0; i--) {
if (a[i]) {
dp[i] = dp[i + 1] + dp[i + 2];
dp[i] %= mod;
} else {
dp[i] = 0;
}
}
cout << dp[0] << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one"
] | 825,392 | 825,394 | u749089333 | 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 repe(i, a, b) for (ll i = (a); i <= (b); i++)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll INF = 1LL << 60;
ll dp[100010] = {0};
int main(void) {
int n;
cin >> n;
int m;
cin >> m;
bool not_broken[n + 1];
repe(i, 0, n) { not_broken[i] = true; }
rep(i, 0, m) {
int tmp;
cin >> tmp;
not_broken[tmp] = false;
}
dp[0] = 1;
if (not_broken[1])
dp[1] = 1;
repe(i, 2, n) {
if (not_broken[i - 1])
dp[i] += dp[i - 1];
if (not_broken[i - 2])
dp[i] += dp[i - 2];
dp[n] %= 1000000007;
}
cout << dp[n] << endl;
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 repe(i, a, b) for (ll i = (a); i <= (b); i++)
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll INF = 1LL << 60;
ll dp[100010] = {0};
int main(void) {
int n;
cin >> n;
int m;
cin >> m;
bool not_broken[n + 1];
repe(i, 0, n) { not_broken[i] = true; }
rep(i, 0, m) {
int tmp;
cin >> tmp;
not_broken[tmp] = false;
}
dp[0] = 1;
if (not_broken[1])
dp[1] = 1;
repe(i, 2, n) {
if (not_broken[i - 1])
dp[i] += dp[i - 1];
if (not_broken[i - 2])
dp[i] += dp[i - 2];
dp[i] %= 1000000007;
}
cout << dp[n] << endl;
return 0;
} | [
"assignment.variable.change",
"identifier.change",
"variable_access.subscript.index.change"
] | 825,400 | 825,401 | u873269440 | cpp |
p03013 | #include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL << 31;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m, a = 0;
ll dp[100010];
cin >> n;
rep(i, n + 10) dp[i] = 0;
dp[0] = 1;
cin >> m;
rep(i, m) {
cin >> a;
dp[a] = -1;
}
for (int i = 0; i < n; i++) {
if (dp[i] != -1) {
if (dp[i + 1] != -1)
dp[i + 1] += (dp[i]);
if (dp[i + 2] != -1)
dp[i + 2] += (dp[i]);
if (dp[i + 1] != -1)
dp[i + 2] %= mod;
if (dp[i + 2] != -1)
dp[i + 2] %= mod;
}
}
cout << dp[n] << endl;
}
| #include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL << 31;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m, a = 0;
ll dp[100010];
cin >> n;
rep(i, n + 10) dp[i] = 0;
dp[0] = 1;
cin >> m;
rep(i, m) {
cin >> a;
dp[a] = -1;
}
for (int i = 0; i < n; i++) {
if (dp[i] != -1) {
if (dp[i + 1] != -1)
dp[i + 1] += (dp[i]);
if (dp[i + 2] != -1)
dp[i + 2] += (dp[i]);
if (dp[i + 1] != -1)
dp[i + 1] %= mod;
if (dp[i + 2] != -1)
dp[i + 2] %= mod;
}
}
cout << dp[n] << endl;
}
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 825,402 | 825,403 | u730499268 | cpp |
p03013 | #include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL << 31;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m, a = 0;
ll dp[100010];
cin >> n;
rep(i, n + 10) dp[i] = 0;
dp[0] = 1;
cin >> m;
rep(i, m) cin >> a;
dp[a] = -1;
for (int i = 0; i < n; i++) {
if (dp[i] != -1) {
if (dp[i + 1] != -1)
dp[i + 1] += (dp[i]);
if (dp[i + 2] != -1)
dp[i + 2] += (dp[i]);
if (dp[i + 1] != -1)
dp[i + 1] %= mod;
if (dp[i + 2] != -1)
dp[i + 2] %= mod;
}
}
cout << dp[n] << endl;
}
| #include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL << 31;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m, a = 0;
ll dp[100010];
cin >> n;
rep(i, n + 10) dp[i] = 0;
dp[0] = 1;
cin >> m;
rep(i, m) {
cin >> a;
dp[a] = -1;
}
for (int i = 0; i < n; i++) {
if (dp[i] != -1) {
if (dp[i + 1] != -1)
dp[i + 1] += (dp[i]);
if (dp[i + 2] != -1)
dp[i + 2] += (dp[i]);
if (dp[i + 1] != -1)
dp[i + 1] %= mod;
if (dp[i + 2] != -1)
dp[i + 2] %= mod;
}
}
cout << dp[n] << endl;
}
| [] | 825,404 | 825,403 | u730499268 | cpp |
p03013 | #include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL << 31;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m, a = 0;
ll dp[100010];
cin >> n;
rep(i, n + 10) dp[i] = 0;
dp[0] = 1;
cin >> m;
rep(i, m) cin >> a;
dp[a] = -1;
for (int i = 0; i < n; i++) {
if (dp[i] != -1) {
if (dp[i + 1] != -1)
dp[i + 1] += (dp[i]);
if (dp[i + 2] != -1)
dp[i + 2] += (dp[i]);
if (dp[i + 1] != -1)
dp[i + 2] %= mod;
if (dp[i + 2] != -1)
dp[i + 2] %= mod;
}
}
cout << dp[n] << endl;
}
| #include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL << 31;
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
int main() {
int n, m, a = 0;
ll dp[100010];
cin >> n;
rep(i, n + 10) dp[i] = 0;
dp[0] = 1;
cin >> m;
rep(i, m) {
cin >> a;
dp[a] = -1;
}
for (int i = 0; i < n; i++) {
if (dp[i] != -1) {
if (dp[i + 1] != -1)
dp[i + 1] += (dp[i]);
if (dp[i + 2] != -1)
dp[i + 2] += (dp[i]);
if (dp[i + 1] != -1)
dp[i + 1] %= mod;
if (dp[i + 2] != -1)
dp[i + 2] %= mod;
}
}
cout << dp[n] << endl;
}
| [
"literal.number.change",
"assignment.variable.change",
"variable_access.subscript.index.change",
"expression.operation.binary.change"
] | 825,405 | 825,403 | u730499268 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL << 31;
const int mod = 1e9 + 7;
int main() {
int n, m, a = 0;
ll dp[100010];
vector<bool> broken(100010, true);
cin >> n;
rep(i, n + 10) dp[i] = 0;
dp[0] = 1;
cin >> m;
rep(i, m) cin >> a;
broken[a] = false;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++)
if (broken[j]) {
dp[j] += (dp[i]);
dp[j] %= mod;
}
}
cout << dp[n] << endl;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL << 31;
const int mod = 1e9 + 7;
int main() {
int n, m, a = 0;
ll dp[100010];
vector<bool> broken(100010, true);
cin >> n;
rep(i, n + 10) dp[i] = 0;
dp[0] = 1;
cin >> m;
rep(i, m) {
cin >> a;
broken[a] = false;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++)
if (broken[j]) {
dp[j] += (dp[i]);
dp[j] %= mod;
}
}
cout << dp[n] << endl;
}
| [] | 825,406 | 825,407 | u730499268 | cpp |
p03013 | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL << 31;
const int mod = 1e9 + 7;
int main() {
int n, m, a = 0;
ll dp[100010];
vector<bool> broken(100010, true);
cin >> n;
rep(i, n + 10) dp[i] = 0;
dp[0] = 1;
cin >> m;
rep(i, m) cin >> a;
broken[a] = -1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++)
if (broken[j]) {
dp[j] += (dp[i]);
dp[j] %= mod;
}
}
cout << dp[n] << endl;
}
| #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL << 31;
const int mod = 1e9 + 7;
int main() {
int n, m, a = 0;
ll dp[100010];
vector<bool> broken(100010, true);
cin >> n;
rep(i, n + 10) dp[i] = 0;
dp[0] = 1;
cin >> m;
rep(i, m) {
cin >> a;
broken[a] = false;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= min(n, i + 2); j++)
if (broken[j]) {
dp[j] += (dp[i]);
dp[j] %= mod;
}
}
cout << dp[n] << endl;
}
| [
"assignment.value.change"
] | 825,408 | 825,407 | u730499268 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
// 0だとOK １だと壊れてる
int a[N + 1] = {0};
for (int i = 0; i < M; i++) {
int temp;
cin >> temp;
a[temp] = 1;
}
long long int s[N + 1];
s[0] = 1;
if (a[1] == 1)
s[1] = 0;
else
s[1] = 1;
long long int mod = 1000000007;
for (int i = 2; i <= N; i++) {
if (a[i] != 1) {
s[i] = (s[i - 1] + s[i - 2]);
} else {
s[i] = 0;
}
}
cout << s[N] % mod << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
// 0だとOK １だと壊れてる
int a[N + 1] = {0};
for (int i = 0; i < M; i++) {
int temp;
cin >> temp;
a[temp] = 1;
}
long long int s[N + 1];
s[0] = 1;
if (a[1] == 1)
s[1] = 0;
else
s[1] = 1;
long long int mod = 1000000007;
for (int i = 2; i <= N; i++) {
if (a[i] != 1) {
s[i] = (s[i - 1] + s[i - 2]) % mod;
} else {
s[i] = 0;
}
}
cout << s[N] % mod << endl;
return 0;
} | [
"assignment.change"
] | 825,409 | 825,410 | u759510609 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define uli unsigned long long int
#define INF 999999999
#define rep(i, m, n) for (lli i = m; i < n; i++)
#define rrep(i, m, n) for (lli i = m; i > n; i--)
#define pb(n) push_back(n)
#define Sort(n) sort(n.begin(), n.end())
#define Rev(n) reverse(n.begin(), n.end())
#define Out(S) cout << S << endl
#define NeOut(S) cout << S
#define HpOut(S) cout << setprecision(20) << S << endl
#define Vecpr(K, L1, L2, N) vector<pair<L1, L2>> K(N)
#define Vec(K, L, N, S) vector<L> K(N, S)
#define DV(K, L, N, M, R) vector<vector<L>> K(N, vector<L>(M, R))
#define mod 1000000007
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a)
int main() {
lli A = 0, B, C, D, E, F, N, M, K, sum = 0, num = 0, cnt = 1, next = 0;
cin >> N >> K;
Vec(issafe, bool, N + 1, true);
Vec(DP, lli, N + 1, 0);
rep(i, 0, K) {
cin >> A;
issafe[A] = false;
}
DP[0] = 1;
if (issafe[1])
DP[1] = 1;
rep(i, 2, N + 1) if (issafe[i]) DP[i] = DP[i - 1] + DP[i - 2];
Out(DP[N]);
}
| #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define uli unsigned long long int
#define INF 999999999
#define rep(i, m, n) for (lli i = m; i < n; i++)
#define rrep(i, m, n) for (lli i = m; i > n; i--)
#define pb(n) push_back(n)
#define Sort(n) sort(n.begin(), n.end())
#define Rev(n) reverse(n.begin(), n.end())
#define Out(S) cout << S << endl
#define NeOut(S) cout << S
#define HpOut(S) cout << setprecision(20) << S << endl
#define Vecpr(K, L1, L2, N) vector<pair<L1, L2>> K(N)
#define Vec(K, L, N, S) vector<L> K(N, S)
#define DV(K, L, N, M, R) vector<vector<L>> K(N, vector<L>(M, R))
#define mod 1000000007
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a)
int main() {
lli A = 0, B, C, D, E, F, N, M, K, sum = 0, num = 0, cnt = 1, next = 0;
cin >> N >> K;
Vec(issafe, bool, N + 1, true);
Vec(DP, lli, N + 1, 0);
rep(i, 0, K) {
cin >> A;
issafe[A] = false;
}
DP[0] = 1;
if (issafe[1])
DP[1] = 1;
rep(i, 2, N + 1) if (issafe[i]) DP[i] = (DP[i - 1] + DP[i - 2]) % mod;
Out(DP[N]);
}
| [
"assignment.change"
] | 825,442 | 825,443 | u618604643 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define RAP(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#include <iostream>
#include <vector>
using namespace std;
//重複順列
vector<ll> buf;
void permutation(ll i, const ll size, const ll range_start,
const ll range_end) {
if (i == size) {
// ここで所望の作業を行う
for (ll itr : buf) {
cout << itr;
}
} else {
for (ll j = range_start; j <= range_end; ++j) {
buf[i] = j;
permutation(i + 1, size, range_start, range_end);
}
}
}
int main(void) {
ll n, m, a;
ll mod = pow(10, 9) + 7;
cin >> n >> m;
vector<ll> A(n + 1);
A[0] = 1;
RAP(i, n) {
cin >> a;
A[a] = -1;
}
for (ll i = 1; i <= n; i++) {
if (A[i] == -1) {
continue;
}
if (i == 1) {
A[i] = A[i - 1];
continue;
}
if (A[i - 1] == -1 && A[i - 2] == -1) {
break;
} else if (A[i - 1] == -1) {
A[i] = A[i - 2];
} else if (A[i - 2] == -1) {
A[i] = A[i - 1];
} else {
A[i] = (A[i - 1] + A[i - 2]) % mod;
}
}
cout << A[n] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define RAP(i, n) for (ll i = 0; i < (n); i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#include <iostream>
#include <vector>
using namespace std;
//重複順列
vector<ll> buf;
void permutation(ll i, const ll size, const ll range_start,
const ll range_end) {
if (i == size) {
// ここで所望の作業を行う
for (ll itr : buf) {
cout << itr;
}
} else {
for (ll j = range_start; j <= range_end; ++j) {
buf[i] = j;
permutation(i + 1, size, range_start, range_end);
}
}
}
int main(void) {
ll n, m, a;
ll mod = pow(10, 9) + 7;
cin >> n >> m;
vector<ll> A(n + 1);
A[0] = 1;
RAP(i, m) {
cin >> a;
A[a] = -1;
}
for (ll i = 1; i <= n; i++) {
if (A[i] == -1) {
continue;
}
if (i == 1) {
A[i] = A[i - 1];
continue;
}
if (A[i - 1] == -1 && A[i - 2] == -1) {
break;
} else if (A[i - 1] == -1) {
A[i] = A[i - 2];
} else if (A[i - 2] == -1) {
A[i] = A[i - 1];
} else {
A[i] = (A[i - 1] + A[i - 2]) % mod;
}
}
cout << A[n] << endl;
return 0;
}
| [] | 825,448 | 825,449 | u761994361 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
ll p = 100000007;
cin >> n >> m;
ll dp[n + 1];
dp[0] = 1;
ll num;
for (ll i = 1; i <= m; i++) {
cin >> num;
dp[num] = -1;
}
if (dp[1] == -1) {
dp[1] = 0;
} else
dp[1] = 1;
for (ll i = 2; i <= n; i++) {
if (dp[i] == -1) {
dp[i] = 0;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % p;
}
// cout<<dp[i]<<" ";
}
cout << dp[n];
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, m;
ll p = 1000000007;
cin >> n >> m;
ll dp[n + 1];
dp[0] = 1;
ll num;
for (ll i = 1; i <= m; i++) {
cin >> num;
dp[num] = -1;
}
if (dp[1] == -1) {
dp[1] = 0;
} else
dp[1] = 1;
for (ll i = 2; i <= n; i++) {
if (dp[i] == -1) {
dp[i] = 0;
} else {
dp[i] = (dp[i - 1] + dp[i - 2]) % p;
}
// cout<<dp[i]<<" ";
}
cout << dp[n];
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 825,474 | 825,475 | u781076291 | cpp |
p03013 | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repd(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define repdm(i, a, b) for (ll i = (ll)(a); i > (ll)(b); i--)
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 1);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
// 壊れている段はルートに入らないので0でcontinue
dp[i] = 0;
continue;
}
if (i == n - 1)
dp[i] = (dp[i + 1]) % mod;
continue;
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repd(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define repdm(i, a, b) for (ll i = (ll)(a); i > (ll)(b); i--)
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 1);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
// 壊れている段はルートに入らないので0でcontinue
dp[i] = 0;
continue;
}
if (i == n - 1) {
dp[i] = (dp[i + 1]) % mod;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | [] | 825,489 | 825,490 | u879674287 | cpp |
p03013 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
using ll = long long;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 1);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
using ll = long long;
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> broken(n + 1);
rep(i, m) {
int a;
cin >> a;
broken[a] = 1;
}
vector<int> dp(n + 2);
const int mod = 1000000007;
dp[n] = 1;
for (int i = n - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % mod;
}
cout << dp[0] << endl;
return 0;
} | [
"literal.number.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 825,499 | 825,500 | u489823438 | cpp |
p03013 | #include <algorithm> // std::unique
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
/*
D - Multiple of 2019
*/
int main(void) {
int stairNum;
int brokenNum;
cin >> stairNum >> brokenNum;
vector<bool> isSafeStep;
isSafeStep.assign(stairNum + 1, true);
for (int i = 0; i < brokenNum; ++i) {
int n;
cin >> n;
isSafeStep[n] = false;
}
int answer = 0;
vector<int> dp(stairNum + 1, 0);
dp[0] = 1;
if (isSafeStep[1])
dp[1] = 1;
for (int i = 2; i <= stairNum; ++i) {
if (isSafeStep[i + 1])
dp[i] += dp[i - 1];
if (isSafeStep[i + 2])
dp[i] += dp[i - 2];
dp[i] %= 1000000007;
}
auto output = dp[stairNum];
cout << output;
}
| #include <algorithm> // std::unique
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
/*
D - Multiple of 2019
*/
int main(void) {
int stairNum;
int brokenNum;
cin >> stairNum >> brokenNum;
vector<bool> isSafeStep;
isSafeStep.assign(stairNum + 1, true);
for (int i = 0; i < brokenNum; ++i) {
int n;
cin >> n;
isSafeStep[n] = false;
}
int answer = 0;
vector<int> dp(stairNum + 1, 0);
dp[0] = 1;
if (isSafeStep[1])
dp[1] = 1;
for (int i = 2; i <= stairNum; ++i) {
if (isSafeStep[i - 1])
dp[i] += dp[i - 1];
if (isSafeStep[i - 2])
dp[i] += dp[i - 2];
dp[i] %= 1000000007;
}
auto output = dp[stairNum];
cout << output;
}
| [
"misc.opposites",
"expression.operator.arithmetic.change",
"variable_access.subscript.index.change",
"control_flow.branch.if.condition.change"
] | 825,535 | 825,536 | u368138550 | cpp |
p03013 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
ll mod = 1e9 + 7;
cin >> N >> M;
vector<ll> hole(N, 0);
for (ll i = 0; i < M; ++i) {
ll a;
cin >> a;
hole[a] = 1;
}
ll dp[N + 10];
fill(dp, dp + N + 10, 0);
dp[0] = 1;
for (ll i = 0; i < N + 5; i++) {
for (ll j = 1; j <= 2; ++j) {
if (hole[i + j])
continue;
else {
dp[i + j] = dp[i + j] + dp[i];
dp[i + j] %= mod;
}
}
}
cout << dp[N] << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N, M;
ll mod = 1e9 + 7;
cin >> N >> M;
vector<ll> hole(N + 10, 0);
for (ll i = 0; i < M; ++i) {
ll a;
cin >> a;
hole[a] = 1;
}
ll dp[N + 10];
fill(dp, dp + N + 10, 0);
dp[0] = 1;
for (ll i = 0; i < N + 5; i++) {
for (ll j = 1; j <= 2; ++j) {
if (hole[i + j])
continue;
else {
dp[i + j] = dp[i + j] + dp[i];
dp[i + j] %= mod;
}
}
}
cout << dp[N] << endl;
} | [
"assignment.change"
] | 825,565 | 825,566 | u883725898 | cpp |
p03013 | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <vector>
#define _(x) \
{ cout << #x << " = " << x << " "; }
const double E = 1e-8;
const double PI = acos(-1);
const int MOD = 1e9 + 7;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<bool> sb(m + 1, false);
for (int i = 0, a; i < m; ++i) {
cin >> a;
sb[a] = true;
}
vector<int> dp(n + 1, 0);
dp[0] = 1;
dp[1] = !sb[1];
for (int i = 2; i <= n; ++i) {
if (sb[i])
dp[i] = 0;
else {
dp[i] = (dp[i - 1] % MOD + dp[i - 2] % MOD) % MOD;
}
}
cout << dp[n] << '\n';
return 0;
}
| #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <vector>
#define _(x) \
{ cout << #x << " = " << x << " "; }
const double E = 1e-8;
const double PI = acos(-1);
const int MOD = 1e9 + 7;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<bool> sb(n + 1, false);
for (int i = 0, a; i < m; ++i) {
cin >> a;
sb[a] = true;
}
vector<long long> dp(n + 1, 0);
dp[0] = 1;
dp[1] = !sb[1];
for (int i = 2; i <= n; ++i) {
if (sb[i])
dp[i] = 0;
else {
dp[i] = (dp[i - 1] % MOD + dp[i - 2] % MOD) % MOD;
}
}
cout << dp[n] << '\n';
return 0;
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change",
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 825,578 | 825,579 | u150070357 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.