input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
# ここから
import sys
input = sys.stdin.readline
def resolve():
n, m = list(map(int, input().split()))
aa = [int(eval(input())) for _ in range(m)]
dp = [0] * (n+1)
dp[0] = 1
dp[1] = 0 if 1 in aa else 1
for i in range(2, n+1):
if i in aa:
dp[i] = 0
else:
dp[i] = (dp[i-2] + dp[i-1]) % 1000000007
print((dp[n]))
resolve()
|
# ここから
import sys
input = sys.stdin.readline
def resolve():
n, m = list(map(int, input().split()))
aa = [False] * (n+1)
for i in range(m):
a = int(eval(input()))
aa[a] = True
dp = [0] * (n+1)
dp[0] = 1
dp[1] = 0 if aa[1] else 1
for i in range(2, n+1):
if aa[i]:
dp[i] = 0
else:
dp[i] = (dp[i-2] + dp[i-1]) % 1000000007
print((dp[n]))
resolve()
|
p03013
|
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
# from fractions import gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop
INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: list(map(int, INPUT().split()))
S_MAP = lambda: list(map(str, INPUT().split()))
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
def main():
N, M = MAP()
A = [INT() for i in range(M)]
dp = [1] * (N + 1)
for a in A:
dp[a] = 0
for i in range(N-1):
if not i+2 in A:
dp[i+2] = (dp[i] + dp[i+1]) % mod
else:
dp[i+2] = 0
print((dp[N]))
if __name__ == '__main__':
main()
|
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
# from fractions import gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop
INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: list(map(int, INPUT().split()))
S_MAP = lambda: list(map(str, INPUT().split()))
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
def main():
N, M = MAP()
A = [INT() for i in range(M)]
dp = [1] * (N + 1)
for a in A:
dp[a] = 0
for i in range(N-1):
dp[i+2] = dp[i+2] * (dp[i] + dp[i+1]) % mod
print((dp[N]))
if __name__ == '__main__':
main()
|
p03013
|
n, m = list(map(int, input().split() ))
broken = [int(eval(input())) for _ in range(m)]
mod = 10**9+7
num_way = [0] * (n+1)
num_way[0] = 1
if 1 in broken:
num_way[1] = 0
else:
num_way[1] = 1
for i in range(2, (n+1)):
if i in broken:
num_way[i] = 0
else:
num_way[i] = (num_way[i-1] + num_way[i-2]) % mod
print((num_way[n]))
|
n, m = list(map(int, input().split() ))
broken = [int(eval(input())) for _ in range(m)]
broken.append(-1) #番兵
broken_idx = 0
mod = 10**9+7
num_way = [0] * (n+1)
num_way[0] = 1
if broken[broken_idx] == 1:
num_way[1] = 0
broken_idx += 1
else:
num_way[1] = 1
for i in range(2, (n+1)):
if broken[broken_idx] == i:
num_way[i] = 0
broken_idx += 1
else:
num_way[i] = (num_way[i-1] + num_way[i-2]) % mod
print((num_way[n]))
|
p03013
|
# !/usr/bin/env python3
import sys
from operator import itemgetter
# gcd
# from fractions import gcd
# 切り上げ，切り捨て
# from math import ceil, floor
# リストの真のコピー（変更が伝播しない）
# from copy import deepcopy
# 累積和。list(accumulate(A))としてAの累積和
# from itertools import accumulate
# l = ['a', 'b', 'b', 'c', 'b', 'a', 'c', 'c', 'b', 'c', 'b', 'a']
# S = Counter(l) # カウンタークラスが作られる。S=Counter({'b': 5, 'c': 4, 'a': 3})
# print(S.most_common(2)) # [('b', 5), ('c', 4)]
# print(S.keys()) # dict_keys(['a', 'b', 'c'])
# print(S.values()) # dict_values([3, 5, 4])
# print(S.items()) # dict_items([('a', 3), ('b', 5), ('c', 4)])
# from collections import Counter
# import math
# from functools import reduce
#
# input関係の定義
# fin = open('in_3.txt', 'r')
# sys.stdin = fin
# 提出時はコメントアウト+上のshebangを有効にする
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())
def debug(*args): return print(*args, file=sys.stderr)
# template
MOD = 1000000007 # type: int
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
class Modint():
'''
自動でMODで割った余りを計算してくれる整数。MODは素数である必要があり，デフォルトは10**9+7。
Parameters
----------
n (int) : Modintの初期値
MOD=10^9+7 (int) : 余りを計算するMOD。素数である必要がある。
Methods
----------
inverse(n: int) -> Modint
n の逆元を返す。
'''
def __init__(self, n: int, mod=MOD):
if n >= 0:
self.n = n % mod
else:
self.n = (mod - (-n) % mod) % mod
self.mod = mod
def __eq__(self, other):
return self.n == int(other)
def __ne__(self, other):
return not self == other
def __neg__(self):
return self.__class__(-self.n)
def __str__(self):
return str(self.n)
def __int__(self):
return self.n
def __iadd__(self, other):
self.n += int(other)
self.n %= self.mod
return self
def __radd__(self, other):
return self.__add__(other)
def __isub__(self, other):
self.n -= int(other)
self.n %= self.mod
return self
def __rsub__(self, other):
return self.__sub__(other)
def __imul__(self, other):
self.n = self.n * int(other) % self.mod
return self
def __rmul__(self, other):
return self.__mul__(other)
def inverse(self):
'''
フェルマーの小定理を考えると，MOD-2乗することでMODでの逆元を求めることができる。これは組み込み関数のpowを使うと十分に早い（O(log MOD)）。
'''
return self.__class__(pow(self.n, self.mod - 2, self.mod))
def __ifloordiv__(self, other):
self *= pow(int(other), self.mod - 2, self.mod)
return self
def __rfloordiv__(self, other):
return self.__class__(other).__floordiv__(self)
def __add__(self, other):
return self.__class__(self.n + int(other))
def __sub__(self, other):
return self.__class__(self.n - int(other))
def __mul__(self, other):
return self.__class__(self.n * int(other))
def __floordiv__(self, other):
return self.__class__(self.n * Modint(int(other)).inverse())
# def comb(self, n: int, k: int):
# '''
# コンビネーション絡みの定義。comb(n,k):特に前処理をせずnCkを求める
# 毎回O(N)かかるので死ぬ覚悟でO(N^2)を投げるくらいしか無理
# ちなみにですが，これでABC132_D()を出すとPyPy3で1932msくらいですれすれセーフ
# '''
# if n < k or k < 0:
# return Modint(0)
# res = Modint(1)
# for i in range(int(k)):
# res *= Modint(n - i)
# res //= Modint(i + 1)
# return res
# def H(self, n: int, k: int):
# if n < 0 or k < 0:
# return Modint(0)
# elif n == 0 and k == 0:
# return Modint(1)
# else:
# return self.comb(n + k - 1, n)
COMBINATION_MAX = 2 * 10**5
class Combination():
def __init__(self, sz=COMBINATION_MAX):
'''
Nまでの階乗とその逆元（割り算用）を計算しておく。前処理にO(N)，P, C, Hそれぞれの計算はO(1)。N = 200000なら割と余裕で通る。
'''
self._fact = [Modint(0)] * (sz + 1)
self._rfact = [Modint(0)] * (sz + 1)
self._fact[0] = Modint(1)
self._rfact[sz] = Modint(1)
for i in range(1, sz + 1):
self._fact[i] = self._fact[i - 1] * Modint(i)
self._rfact[sz] = self._fact[sz].inverse()
for i in range(sz - 1, -1, -1):
self._rfact[i] = self._rfact[i + 1] * Modint(i + 1)
def fact(self, k: int) -> int:
"""階乗の計算"""
return self._fact[k]
def rfact(self, k: int) -> int:
"""階乗の逆元の計算"""
return self._rfact[k]
def P(self, n: int, k: int) -> Modint:
'''
nPkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int) : nPkのn (0<=n<=N)
k (int) : nPkのk （0<=k<=n）
Returns
----------
Modint : nPkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return Modint(0)
return self._fact[n] * self._rfact[n - k]
def C(self, n: int, k: int) -> Modint:
'''
nCkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int) : nCkのn(0<=n<=N)
k (int) : nCkのk（0<=k<=n）
Returns
----------
Modint : nCkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return Modint(0)
if n - k < k:
k = n - k
return self._fact[n] * self._rfact[k] * self._rfact[n - k]
def H(self, n: int, k: int) -> Modint:
'''
nHkの値を返す。nはあらかじめ前処理された n+k-1 以下でないとダメ
ちなみにnHkはn個の区別できないものをk個の箱に分けるパターンの数で，結局n+k-1Cnになる。
Parameters
----------
n (int) : nHkのn(0<=n<=N)
k (int) : nHkのk（0<=k<=n）
Returns
----------
Modint : nHkをModint型で返す。Modintに依存。
'''
if n < 0 or k < 0:
return Modint(0)
elif k == 0:
return Modint(1)
return self.C(n + k - 1, k)
# END CUT HERE
if __name__ == '__main__':
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
a = {int(next(tokens)) for _ in range(M)} # type: "List[int]"
# write code
dp = [Modint(0) for i in range(N + 10)]
dp[0] = Modint(1)
if 1 not in a:
dp[1] = Modint(1)
for n in range(2, N + 2):
if n - 1 not in a:
dp[n] += dp[n - 1]
debug(n, "!")
if n - 2 not in a:
dp[n] += dp[n - 2]
debug(n, "?")
print(dp[N])
|
# !/usr/bin/env python3
import sys
from operator import itemgetter
# gcd
# from fractions import gcd
# 切り上げ，切り捨て
# from math import ceil, floor
# リストの真のコピー（変更が伝播しない）
# from copy import deepcopy
# 累積和。list(accumulate(A))としてAの累積和
# from itertools import accumulate
# l = ['a', 'b', 'b', 'c', 'b', 'a', 'c', 'c', 'b', 'c', 'b', 'a']
# S = Counter(l) # カウンタークラスが作られる。S=Counter({'b': 5, 'c': 4, 'a': 3})
# print(S.most_common(2)) # [('b', 5), ('c', 4)]
# print(S.keys()) # dict_keys(['a', 'b', 'c'])
# print(S.values()) # dict_values([3, 5, 4])
# print(S.items()) # dict_items([('a', 3), ('b', 5), ('c', 4)])
# from collections import Counter
# import math
# from functools import reduce
#
# 提出時はコメントアウト+上のshebangを有効にする
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())
def debug(*args): return print(*args, file=sys.stderr)
# template
MOD = 1000000007 # type: int
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
class Modint():
'''
自動でMODで割った余りを計算してくれる整数。MODは素数である必要があり，デフォルトは10**9+7。
Parameters
----------
n (int) : Modintの初期値
MOD=10^9+7 (int) : 余りを計算するMOD。素数である必要がある。
Methods
----------
inverse(n: int) -> Modint
n の逆元を返す。
'''
def __init__(self, n: int, mod=MOD):
if n >= 0:
self.n = n % mod
else:
self.n = (mod - (-n) % mod) % mod
self.mod = mod
def __eq__(self, other):
return self.n == int(other)
def __ne__(self, other):
return not self == other
def __neg__(self):
return self.__class__(-self.n)
def __str__(self):
return str(self.n)
def __int__(self):
return self.n
def __iadd__(self, other):
self.n += int(other)
self.n %= self.mod
return self
def __radd__(self, other):
return self.__add__(other)
def __isub__(self, other):
self.n -= int(other)
self.n %= self.mod
return self
def __rsub__(self, other):
return self.__sub__(other)
def __imul__(self, other):
self.n = self.n * int(other) % self.mod
return self
def __rmul__(self, other):
return self.__mul__(other)
def inverse(self):
'''
フェルマーの小定理を考えると，MOD-2乗することでMODでの逆元を求めることができる。これは組み込み関数のpowを使うと十分に早い（O(log MOD)）。
'''
return self.__class__(pow(self.n, self.mod - 2, self.mod))
def __ifloordiv__(self, other):
self *= pow(int(other), self.mod - 2, self.mod)
return self
def __rfloordiv__(self, other):
return self.__class__(other).__floordiv__(self)
def __add__(self, other):
return self.__class__(self.n + int(other))
def __sub__(self, other):
return self.__class__(self.n - int(other))
def __mul__(self, other):
return self.__class__(self.n * int(other))
def __floordiv__(self, other):
return self.__class__(self.n * Modint(int(other)).inverse())
# def comb(self, n: int, k: int):
# '''
# コンビネーション絡みの定義。comb(n,k):特に前処理をせずnCkを求める
# 毎回O(N)かかるので死ぬ覚悟でO(N^2)を投げるくらいしか無理
# ちなみにですが，これでABC132_D()を出すとPyPy3で1932msくらいですれすれセーフ
# '''
# if n < k or k < 0:
# return Modint(0)
# res = Modint(1)
# for i in range(int(k)):
# res *= Modint(n - i)
# res //= Modint(i + 1)
# return res
# def H(self, n: int, k: int):
# if n < 0 or k < 0:
# return Modint(0)
# elif n == 0 and k == 0:
# return Modint(1)
# else:
# return self.comb(n + k - 1, n)
COMBINATION_MAX = 2 * 10**5
class Combination():
def __init__(self, sz=COMBINATION_MAX):
'''
Nまでの階乗とその逆元（割り算用）を計算しておく。前処理にO(N)，P, C, Hそれぞれの計算はO(1)。N = 200000なら割と余裕で通る。
'''
self._fact = [Modint(0)] * (sz + 1)
self._rfact = [Modint(0)] * (sz + 1)
self._fact[0] = Modint(1)
self._rfact[sz] = Modint(1)
for i in range(1, sz + 1):
self._fact[i] = self._fact[i - 1] * Modint(i)
self._rfact[sz] = self._fact[sz].inverse()
for i in range(sz - 1, -1, -1):
self._rfact[i] = self._rfact[i + 1] * Modint(i + 1)
def fact(self, k: int) -> int:
"""階乗の計算"""
return self._fact[k]
def rfact(self, k: int) -> int:
"""階乗の逆元の計算"""
return self._rfact[k]
def P(self, n: int, k: int) -> Modint:
'''
nPkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int) : nPkのn (0<=n<=N)
k (int) : nPkのk （0<=k<=n）
Returns
----------
Modint : nPkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return Modint(0)
return self._fact[n] * self._rfact[n - k]
def C(self, n: int, k: int) -> Modint:
'''
nCkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int) : nCkのn(0<=n<=N)
k (int) : nCkのk（0<=k<=n）
Returns
----------
Modint : nCkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return Modint(0)
if n - k < k:
k = n - k
return self._fact[n] * self._rfact[k] * self._rfact[n - k]
def H(self, n: int, k: int) -> Modint:
'''
nHkの値を返す。nはあらかじめ前処理された n+k-1 以下でないとダメ
ちなみにnHkはn個の区別できないものをk個の箱に分けるパターンの数で，結局n+k-1Cnになる。
Parameters
----------
n (int) : nHkのn(0<=n<=N)
k (int) : nHkのk（0<=k<=n）
Returns
----------
Modint : nHkをModint型で返す。Modintに依存。
'''
if n < 0 or k < 0:
return Modint(0)
elif k == 0:
return Modint(1)
return self.C(n + k - 1, k)
# END CUT HERE
if __name__ == '__main__':
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
a = {int(next(tokens)) for _ in range(M)} # type: "List[int]"
# write code
issafe = [True for i in range(N + 10)]
for i in a:
issafe[i] = False
dp = [Modint(0) for i in range(N + 10)]
dp[0] = Modint(1)
if issafe[1]:
dp[1] = Modint(1)
for n in range(2, N + 2):
if issafe[n - 1]:
dp[n] += dp[n - 1]
# debug(n, "!")
if issafe[n - 2]:
dp[n] += dp[n - 2]
# debug(n, "?")
print(dp[N])
|
p03013
|
# !/usr/bin/env python3
import sys
from operator import itemgetter
# gcd
# from fractions import gcd
# 切り上げ，切り捨て
# from math import ceil, floor
# リストの真のコピー（変更が伝播しない）
# from copy import deepcopy
# 累積和。list(accumulate(A))としてAの累積和
# from itertools import accumulate
# l = ['a', 'b', 'b', 'c', 'b', 'a', 'c', 'c', 'b', 'c', 'b', 'a']
# S = Counter(l) # カウンタークラスが作られる。S=Counter({'b': 5, 'c': 4, 'a': 3})
# print(S.most_common(2)) # [('b', 5), ('c', 4)]
# print(S.keys()) # dict_keys(['a', 'b', 'c'])
# print(S.values()) # dict_values([3, 5, 4])
# print(S.items()) # dict_items([('a', 3), ('b', 5), ('c', 4)])
# from collections import Counter
# import math
# from functools import reduce
#
# input関係の定義
# fin = open('in_3.txt', 'r')
# sys.stdin = fin
# 提出時はコメントアウト+上のshebangを有効にする
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())
def debug(*args): return print(*args, file=sys.stderr)
# template
MOD = 1000000007 # type: int
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
class Modint():
'''
自動でMODで割った余りを計算してくれる整数。MODは素数である必要があり，デフォルトは10**9+7。
Parameters
----------
n (int) : Modintの初期値
MOD=10^9+7 (int) : 余りを計算するMOD。素数である必要がある。
Methods
----------
inverse(n: int) -> Modint
n の逆元を返す。
'''
def __init__(self, n: int, mod=MOD):
if n >= 0:
self.n = n % mod
else:
self.n = (mod - (-n) % mod) % mod
self.mod = mod
def __eq__(self, other):
return self.n == int(other)
def __ne__(self, other):
return not self == other
def __neg__(self):
return self.__class__(-self.n)
def __str__(self):
return str(self.n)
def __int__(self):
return self.n
def __iadd__(self, other):
self.n += int(other)
self.n %= self.mod
return self
def __radd__(self, other):
return self.__add__(other)
def __isub__(self, other):
self.n -= int(other)
self.n %= self.mod
return self
def __rsub__(self, other):
return self.__sub__(other)
def __imul__(self, other):
self.n = self.n * int(other) % self.mod
return self
def __rmul__(self, other):
return self.__mul__(other)
def inverse(self):
'''
フェルマーの小定理を考えると，MOD-2乗することでMODでの逆元を求めることができる。これは組み込み関数のpowを使うと十分に早い（O(log MOD)）。
'''
return self.__class__(pow(self.n, self.mod - 2, self.mod))
def __ifloordiv__(self, other):
self *= pow(int(other), self.mod - 2, self.mod)
return self
def __rfloordiv__(self, other):
return self.__class__(other).__floordiv__(self)
def __add__(self, other):
return self.__class__(self.n + int(other))
def __sub__(self, other):
return self.__class__(self.n - int(other))
def __mul__(self, other):
return self.__class__(self.n * int(other))
def __floordiv__(self, other):
return self.__class__(self.n * Modint(int(other)).inverse())
# def comb(self, n: int, k: int):
# '''
# コンビネーション絡みの定義。comb(n,k):特に前処理をせずnCkを求める
# 毎回O(N)かかるので死ぬ覚悟でO(N^2)を投げるくらいしか無理
# ちなみにですが，これでABC132_D()を出すとPyPy3で1932msくらいですれすれセーフ
# '''
# if n < k or k < 0:
# return Modint(0)
# res = Modint(1)
# for i in range(int(k)):
# res *= Modint(n - i)
# res //= Modint(i + 1)
# return res
# def H(self, n: int, k: int):
# if n < 0 or k < 0:
# return Modint(0)
# elif n == 0 and k == 0:
# return Modint(1)
# else:
# return self.comb(n + k - 1, n)
COMBINATION_MAX = 2 * 10**5
class Combination():
def __init__(self, sz=COMBINATION_MAX):
'''
Nまでの階乗とその逆元（割り算用）を計算しておく。前処理にO(N)，P, C, Hそれぞれの計算はO(1)。N = 200000なら割と余裕で通る。
'''
self._fact = [Modint(0)] * (sz + 1)
self._rfact = [Modint(0)] * (sz + 1)
self._fact[0] = Modint(1)
self._rfact[sz] = Modint(1)
for i in range(1, sz + 1):
self._fact[i] = self._fact[i - 1] * Modint(i)
self._rfact[sz] = self._fact[sz].inverse()
for i in range(sz - 1, -1, -1):
self._rfact[i] = self._rfact[i + 1] * Modint(i + 1)
def fact(self, k: int) -> int:
"""階乗の計算"""
return self._fact[k]
def rfact(self, k: int) -> int:
"""階乗の逆元の計算"""
return self._rfact[k]
def P(self, n: int, k: int) -> Modint:
'''
nPkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int) : nPkのn (0<=n<=N)
k (int) : nPkのk （0<=k<=n）
Returns
----------
Modint : nPkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return Modint(0)
return self._fact[n] * self._rfact[n - k]
def C(self, n: int, k: int) -> Modint:
'''
nCkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int) : nCkのn(0<=n<=N)
k (int) : nCkのk（0<=k<=n）
Returns
----------
Modint : nCkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return Modint(0)
if n - k < k:
k = n - k
return self._fact[n] * self._rfact[k] * self._rfact[n - k]
def H(self, n: int, k: int) -> Modint:
'''
nHkの値を返す。nはあらかじめ前処理された n+k-1 以下でないとダメ
ちなみにnHkはn個の区別できないものをk個の箱に分けるパターンの数で，結局n+k-1Cnになる。
Parameters
----------
n (int) : nHkのn(0<=n<=N)
k (int) : nHkのk（0<=k<=n）
Returns
----------
Modint : nHkをModint型で返す。Modintに依存。
'''
if n < 0 or k < 0:
return Modint(0)
elif k == 0:
return Modint(1)
return self.C(n + k - 1, k)
# END CUT HERE
if __name__ == '__main__':
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
a = {int(next(tokens)) for _ in range(M)} # type: "List[int]"
# write code
issafe = [True for i in range(N + 10)]
for i in a:
issafe[i] = False
dp = [Modint(0) for i in range(N + 10)]
dp[0] = Modint(1)
if issafe[1]:
dp[1] = Modint(1)
for n in range(2, N + 2):
if issafe[n - 1]:
dp[n] += dp[n - 1]
debug(n, "!")
if issafe[n - 2]:
dp[n] += dp[n - 2]
debug(n, "?")
print(dp[N])
|
# !/usr/bin/env python3
import sys
from operator import itemgetter
# gcd
# from fractions import gcd
# 切り上げ，切り捨て
# from math import ceil, floor
# リストの真のコピー（変更が伝播しない）
# from copy import deepcopy
# 累積和。list(accumulate(A))としてAの累積和
# from itertools import accumulate
# l = ['a', 'b', 'b', 'c', 'b', 'a', 'c', 'c', 'b', 'c', 'b', 'a']
# S = Counter(l) # カウンタークラスが作られる。S=Counter({'b': 5, 'c': 4, 'a': 3})
# print(S.most_common(2)) # [('b', 5), ('c', 4)]
# print(S.keys()) # dict_keys(['a', 'b', 'c'])
# print(S.values()) # dict_values([3, 5, 4])
# print(S.items()) # dict_items([('a', 3), ('b', 5), ('c', 4)])
# from collections import Counter
# import math
# from functools import reduce
#
# input関係の定義
# fin = open('in_3.txt', 'r')
# sys.stdin = fin
# 提出時はコメントアウト+上のshebangを有効にする
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())
def debug(*args): return print(*args, file=sys.stderr) if not __debug__ else None
# template
MOD = 1000000007 # type: int
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
class Modint():
'''
自動でMODで割った余りを計算してくれる整数。MODは素数である必要があり，デフォルトは10**9+7。
Parameters
----------
n (int) : Modintの初期値
MOD=10^9+7 (int) : 余りを計算するMOD。素数である必要がある。
Methods
----------
inverse(n: int) -> Modint
n の逆元を返す。
'''
def __init__(self, n: int, mod=MOD):
if n >= 0:
self.n = n % mod
else:
self.n = (mod - (-n) % mod) % mod
self.mod = mod
def __eq__(self, other):
return self.n == int(other)
def __ne__(self, other):
return not self == other
def __neg__(self):
return self.__class__(-self.n)
def __str__(self):
return str(self.n)
def __int__(self):
return self.n
def __iadd__(self, other):
self.n += int(other)
self.n %= self.mod
return self
def __radd__(self, other):
return self.__add__(other)
def __isub__(self, other):
self.n -= int(other)
self.n %= self.mod
return self
def __rsub__(self, other):
return self.__sub__(other)
def __imul__(self, other):
self.n = self.n * int(other) % self.mod
return self
def __rmul__(self, other):
return self.__mul__(other)
def inverse(self):
'''
フェルマーの小定理を考えると，MOD-2乗することでMODでの逆元を求めることができる。これは組み込み関数のpowを使うと十分に早い（O(log MOD)）。
'''
return self.__class__(pow(self.n, self.mod - 2, self.mod))
def __ifloordiv__(self, other):
self *= pow(int(other), self.mod - 2, self.mod)
return self
def __rfloordiv__(self, other):
return self.__class__(other).__floordiv__(self)
def __add__(self, other):
return self.__class__(self.n + int(other))
def __sub__(self, other):
return self.__class__(self.n - int(other))
def __mul__(self, other):
return self.__class__(self.n * int(other))
def __floordiv__(self, other):
return self.__class__(self.n * Modint(int(other)).inverse())
# def comb(self, n: int, k: int):
# '''
# コンビネーション絡みの定義。comb(n,k):特に前処理をせずnCkを求める
# 毎回O(N)かかるので死ぬ覚悟でO(N^2)を投げるくらいしか無理
# ちなみにですが，これでABC132_D()を出すとPyPy3で1932msくらいですれすれセーフ
# '''
# if n < k or k < 0:
# return Modint(0)
# res = Modint(1)
# for i in range(int(k)):
# res *= Modint(n - i)
# res //= Modint(i + 1)
# return res
# def H(self, n: int, k: int):
# if n < 0 or k < 0:
# return Modint(0)
# elif n == 0 and k == 0:
# return Modint(1)
# else:
# return self.comb(n + k - 1, n)
COMBINATION_MAX = 2 * 10**5
class Combination():
def __init__(self, sz=COMBINATION_MAX):
'''
Nまでの階乗とその逆元（割り算用）を計算しておく。前処理にO(N)，P, C, Hそれぞれの計算はO(1)。N = 200000なら割と余裕で通る。
'''
self._fact = [Modint(0)] * (sz + 1)
self._rfact = [Modint(0)] * (sz + 1)
self._fact[0] = Modint(1)
self._rfact[sz] = Modint(1)
for i in range(1, sz + 1):
self._fact[i] = self._fact[i - 1] * Modint(i)
self._rfact[sz] = self._fact[sz].inverse()
for i in range(sz - 1, -1, -1):
self._rfact[i] = self._rfact[i + 1] * Modint(i + 1)
def fact(self, k: int) -> int:
"""階乗の計算"""
return self._fact[k]
def rfact(self, k: int) -> int:
"""階乗の逆元の計算"""
return self._rfact[k]
def P(self, n: int, k: int) -> Modint:
'''
nPkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int) : nPkのn (0<=n<=N)
k (int) : nPkのk （0<=k<=n）
Returns
----------
Modint : nPkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return Modint(0)
return self._fact[n] * self._rfact[n - k]
def C(self, n: int, k: int) -> Modint:
'''
nCkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int) : nCkのn(0<=n<=N)
k (int) : nCkのk（0<=k<=n）
Returns
----------
Modint : nCkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return Modint(0)
if n - k < k:
k = n - k
return self._fact[n] * self._rfact[k] * self._rfact[n - k]
def H(self, n: int, k: int) -> Modint:
'''
nHkの値を返す。nはあらかじめ前処理された n+k-1 以下でないとダメ
ちなみにnHkはn個の区別できないものをk個の箱に分けるパターンの数で，結局n+k-1Cnになる。
Parameters
----------
n (int) : nHkのn(0<=n<=N)
k (int) : nHkのk（0<=k<=n）
Returns
----------
Modint : nHkをModint型で返す。Modintに依存。
'''
if n < 0 or k < 0:
return Modint(0)
elif k == 0:
return Modint(1)
return self.C(n + k - 1, k)
# END CUT HERE
if __name__ == '__main__':
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
a = {int(next(tokens)) for _ in range(M)} # type: "List[int]"
# write code
issafe = [True for i in range(N + 10)]
for i in a:
issafe[i] = False
dp = [Modint(0) for i in range(N + 10)]
dp[0] = Modint(1)
if issafe[1]:
dp[1] = Modint(1)
for n in range(2, N + 2):
if issafe[n - 1]:
dp[n] += dp[n - 1]
debug(n, "!")
if issafe[n - 2]:
dp[n] += dp[n - 2]
debug(n, "?")
print(dp[N])
|
p03013
|
mod = 10**9+7
n,m = list(map(int,input().split()))
a = [0]*m
for i in range(m):
a[i] = int(eval(input()))
dp = [0]*(n+1)
dp[0] = 1
for i in range(1,n+1) :
dp[i] = (dp[i-1] + dp[i-2]) % mod
if i in a :
dp[i] = 0
print((dp[n]))
|
mod = 10**9+7
n,m = list(map(int,input().split()))
a = set()
for i in range(m):
a.add(int(eval(input())))
dp = [0]*(n+1)
dp[0] = 1
for i in range(1,n+1) :
dp[i] = (dp[i-1] + dp[i-2]) % mod
if i in a :
dp[i] = 0
print((dp[n]))
|
p03013
|
N,M = list(map(int,input().split()))
a = [int(eval(input())) for _ in range(M)]
k = 10**9+7
dp = [0]*(N+1)
dp[0] = 1
d = 1
if N == 1:
print((1))
else:
for i in range(1,N+1):
if i in a:
continue
elif i==1:
dp[i] = d
elif i==2:
d += dp[1]
dp[i] = d
else:
d = d-dp[i-3]+dp[i-1]
dp[i] = dp[i-1]+dp[i-2]
print((dp[N]%k))
|
N,M = list(map(int,input().split()))
a = set([int(eval(input())) for _ in range(M)])
k = 10**9+7
dp = [0]*(N+1)
dp[0] = 1
if N == 1:
print((1))
else:
for i in range(1,N+1):
if i in a:
continue
elif i==1:
dp[1] = 1
elif i==2:
dp[i] = 1+dp[1]
else:
dp[i] = dp[i-1]+dp[i-2]
print((dp[N]%k))
|
p03013
|
n,m=list(map(int,input().split()))
a=[int(eval(input())) for i in range(m)]
dp=[0]*(n+1)
dp[0]=1
if 1 not in a:
dp[1]=1
for i in range(n-1):
if i+2 not in a:
dp[i+2]=dp[i+1]+dp[i]
else:
dp[i+2]=0
print((dp[n]%(10**9+7)))
|
n,m=list(map(int,input().split()))
a=[int(eval(input())) for i in range(m)]
dp=[1]*(n+1)
dp[0]=1
dp[1]=1
for i in range(m):
if a[i]==1:
dp[1]=0
else:
dp[a[i]]=0
for i in range(2,n+1):
if dp[i]:
dp[i]=dp[i-1]+dp[i-2]
print((dp[n]%(10**9+7)))
|
p03013
|
mod=1000000007
N,M=list(map(int,input().split()))
dp=[0]*(N+1)
dp[0]=1
A=[int(eval(input())) for i in range(M)]
for i in range(1,1+N):
if i in A:
continue
else:
if i==1:
dp[i]=dp[i-1]%mod
else:
dp[i]=(dp[i-1]+dp[i-2])%mod
print((dp[N]))
|
mod=1000000007
N,M=list(map(int,input().split()))
dp=[-1]*(N+1)
dp[0]=1
for i in range(M):
dp[int(eval(input()))]=0
for i in range(1,1+N):
if dp[i]==0:
continue
else:
if i==1:
dp[i]=dp[i-1]%mod
else:
dp[i]=(dp[i-1]+dp[i-2])%mod
if dp[N]==-1:
print((0))
else:
print((dp[N]))
|
p03013
|
n,m = list(map(int,input().split()))
h = []
a = 1
b = 0
mod = 10 ** 9 + 7
for i in range(m):
h += [int(eval(input())),]
for i in range(1,n+1):
if i in h:
a,b = 0,a
else:
a,b = a + b,a
a %= mod
print((a % mod))
|
n,m = list(map(int,input().split()))
h = []
a = 1
b = 0
mod = 10 ** 9 + 7
for i in range(m):
h += [int(eval(input())),]
h += [0,]
cur = 0
for i in range(1,n):
if i == h[cur]:
a,b = 0,a
cur += 1
else:
a,b = a + b,a
a %= mod
print(((a + b) % mod))
|
p03013
|
#N = int(input())
INF = 1000000007
N,M = list(map(int,input().split()))
a_list = [-1]
for i in range(M):
a_list.append(int(eval(input())))
a_list.append(N+1)
a_list.sort()
sa_list = []
for i in range(1,M+2):
sa_list.append(a_list[i]-a_list[i-1])
def fibonacci(n):
if (n<=1):
return (n)
else:
return(fibonacci(n-1) + fibonacci(n-2))
n=max(sa_list)+2
fib_list=[]
for i in range(n-1):
fib_list.append(fibonacci(i))
ans = 1
for sa_i in range(len(sa_list)):
sa = sa_list[sa_i]
# print(sa)
ans = ans*fib_list[sa-1]
ans = ans % INF
print(ans)
|
#N = int(input())
INF = 1000000007
N,M = list(map(int,input().split()))
a_list = [-1]
for i in range(M):
a_list.append(int(eval(input())))
a_list.append(N+1)
a_list.sort()
sa_list = []
for i in range(1,M+2):
sa_list.append(a_list[i]-a_list[i-1])
#def fibonacci(n):
# if (n<=1):
# return (n)
# else:
# return(fibonacci(n-1) + fibonacci(n-2))
n=max(sa_list)+2
fib_list = []
a, b = 0, 1
for i in range(n):
fib_list.append(a)
a, b = b, a + b
#fib_list = [i for i in fib(n)]
#for i in range(n-1):
# fib_list.append(fibonacci(i))
ans = 1
for sa_i in range(len(sa_list)):
sa = sa_list[sa_i]
# print(sa)
ans = ans*fib_list[sa-1]
ans = ans % INF
print(ans)
|
p03013
|
from sys import stdin
N,M = list(map(int,input().split()))
a = [int(stdin.readline()) for _ in range(M)]
A = [0]*(N+1)
mod = 1000000007
A[0] = 1
if not(1 in a):
A[1] = 1
for i in range(2,N+1):
if i in a:
A[i] = 0
else:
A[i] = (A[i-2] + A[i-1]) % mod
print((A[N]))
|
from sys import stdin
N,M = list(map(int,input().split()))
a = [int(stdin.readline()) for _ in range(M)]
A = [0]*(N+1)
mod = 1000000007
A[0] = 1
A[1] = 1
for i in a:
A[i] = -1
if A[1] == -1:
A[1] = 0
if not(1 in a):
A[1] = 1
for i in range(2,N+1):
if A[i] == -1:
A[i] = 0
else:
A[i] = (A[i-2] + A[i-1]) % mod
print((A[N]))
|
p03013
|
n,m=list(map(int,input().split()))
stair_m=[True]*(110000)
for i in range(m):
a=int(eval(input()))
stair_m[a]=False
dp=[0]*(110000)
dp[0]=1
for i in range(1,n+1):
if stair_m[i]:
dp[i]=dp[i-1]+dp[i-2]
else:
dp[i]=0
print((dp[n]%1000000007))
|
n,m=list(map(int,input().split()))
stair=[False]*(n+1)
for i in range(m):
a=int(eval(input()))
stair[a]=True
dp=[0]*(n+1)
dp[0]=1
for i in range(1,n+1):
if stair[i]:
dp[i]=0
else:
dp[i]=(dp[i-1]+dp[i-2])%(10**9+7)
print((dp[n]))
|
p03013
|
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(M)]
MOD = 10**9+7
n = [1, 1]
cnt = 2
while cnt!=N+1:
if cnt-1 in a:n[1]=0
n[0], n[1] = n[1], (n[0]+n[1])%MOD
cnt += 1
if n[1]==0:break
print((n[-1]%(10**9+7)))
|
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
broken= [False]*(N+1)
for i in range(M):
broken[int(eval(input()))] = True
dp = [0]*(N+1)
dp[0] = 1
if not broken[1]:dp[1] = 1
for i in range(2, N+1):
if broken[i]:continue
dp[i] = dp[i-1] + dp[i-2]
dp[i] %= (10**9 + 7)
print((dp[N]))
|
p03013
|
N, M = list(map(int, input().split()))
mod = 1000000007
dp = [0] * (N+2)
A = [int(eval(input())) for _ in range(M)]
dp[-2] = 1
for i in range(N-1, -1, -1):
if (i in A) == False:
dp[i] = (dp[i + 1] + dp[i + 2]) % mod
print((dp[0]))
|
N, M = list(map(int, input().split()))
mod = 1000000007
dp = [0] * (N+2)
A = set([int(eval(input())) for _ in range(M)])
dp[-2] = 1
for i in range(N-1, -1, -1):
if (i in A) == False:
dp[i] = (dp[i + 1] + dp[i + 2]) % mod
print((dp[0]))
|
p03013
|
INF = float("inf") #const
def main():
n,m = list(map(int,input().split()))
a = [int(eval(input())) for i in range(m)]
dp = [0]*(n+1)
dp[0],dp[1] = 1,1
for i in range(2,n+1):
if issafe(i-1,a):
dp[i] += dp[i-1]
if issafe(i-2,a):
dp[i] += dp[i-2]
print((dp[n]%(10**9+7)))
def issafe(i,a):
if i in a:
return False
else:
return True
if __name__ == "__main__":
main()
|
INF = float("inf") #const
def main():
n,m = list(map(int,input().split()))
issafe = [True]*n
for i in range(m):
a = int(eval(input()))
issafe[a] = False
dp = [0]*(n+1)
dp[0],dp[1] = 1,1
for i in range(2,n+1):
if issafe[i-1]:
dp[i] += dp[i-1]
if issafe[i-2]:
dp[i] += dp[i-2]
print((dp[n]%(10**9+7)))
if __name__ == "__main__":
main()
|
p03013
|
n,m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
p = [0]*(n+1)
p[0] = 1
if 1 not in a:
p[1] = 1
t = 1000000007
for i in range(2, n+1):
if i in a:
continue
s = p[i-1] + p[i-2]
s = s%t
p[i] = s
print((p[n]))
|
n,m = list(map(int, input().split()))
a = set([int(eval(input())) for _ in range(m)])
p = [0]*(n+1)
p[0] = 1
if 1 not in a:
p[1] = 1
t = 1000000007
for i in range(2, n+1):
if i in a:
continue
s = p[i-1] + p[i-2]
s = s%t
p[i] = s
print((p[n]))
|
p03013
|
n,m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
mod = 1000000007
dp = [0]*(n+1)
dp[0] = 1
if 1 not in a:
dp[1] = 1
else:
dp[1] = 0
for i in range(2, n+1):
if i in a:
continue
dp[i] = dp[i-1] + dp[i-2]
dp[i] %= mod
print((dp[n]))
|
n,m = list(map(int, input().split()))
a = set([int(eval(input())) for _ in range(m)])
mod = 1000000007
dp = [0]*(n+1)
dp[0] = 1
if 1 not in a:
dp[1] = 1
else:
dp[1] = 0
for i in range(2, n+1):
if i in a:
continue
dp[i] = dp[i-1] + dp[i-2]
dp[i] %= mod
print((dp[n]))
|
p03013
|
n,m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
mod = 1000000007
nums = [0]*(n+1)
nums[0] = 1
if 1 not in a: nums[1] = 1
for i in range(2,n+1):
if i in a: continue
nums[i] = nums[i-1] + nums[i-2]
print((nums[n]%mod))
|
n,m = list(map(int, input().split()))
a = set([int(eval(input())) for _ in range(m)])
mod = 1000000007
nums = [0]*(n+1)
nums[0] = 1
if 1 not in a: nums[1] = 1
for i in range(2,n+1):
if i in a: continue
nums[i] = nums[i-1] + nums[i-2]
print((nums[n]%mod))
|
p03013
|
n,m = list(map(int, input().split()))
a = list(set([int(eval(input())) for _ in range(m)]))
nums = [0]*(n+1)
nums[0] = 1
if 1 not in a: nums[1] = 1
for i in range(2,n+1):
if i not in a: nums[i] = nums[i-1] + nums[i-2]
print((nums[n]%(10**9+7)))
|
n,m = list(map(int, input().split()))
a = set([int(eval(input())) for _ in range(m)])
nums = [0]*(n+1)
nums[0] = 1
if 1 not in a: nums[1] = 1
for i in range(2,n+1):
if i not in a: nums[i] = nums[i-1] + nums[i-2]
print((nums[n]%(10**9+7)))
|
p03013
|
n,m = list(map(int ,input().split()))
a = list(set([int(eval(input())) for _ in range(m)]))
mod = 10**9+7
ans = [0]*(n+1)
ans [0] = 1
if 1 not in a: ans[1] = 1
for i in range(2,n+1):
if i in a: continue
ans[i] = ans[i-1] + ans[i-2]
print((ans[-1]%mod))
|
n,m = list(map(int ,input().split()))
a = set([int(eval(input())) for _ in range(m)])
mod = 10**9+7
ans = [0]*(n+1)
ans [0] = 1
if 1 not in a: ans[1] = 1
for i in range(2,n+1):
if i in a: continue
ans[i] = ans[i-1] + ans[i-2]
print((ans[-1]%mod))
|
p03013
|
n,m = list(map(int, input().split()))
mod = 10**9+7
#フィボナッチ数列
dp = [0 for i in range(n+2)]
dp[0] = 1
dp[1] = 1
for i in range(2,n+2):
dp[i] = dp[i-1] + dp[i-2]
#穴が無い場合
if m==0:
print((dp[n]%mod))
exit()
lst = []
for i in range(m):
lst.append(int(eval(input())))
lst.sort()
#2連続穴がある場合
for i in range(len(lst)-1):
if lst[i]+1 == lst[i+1]:
print((0))
exit()
lst2 = []
for i in range(len(lst)):
if i==0:
lst2.append(lst[0]-1)
else:
lst2.append(lst[i]-lst[i-1]-2)
lst2.append(n-lst[-1]-1)
ans = 1
for i in lst2:
ans *= dp[i]
ans %= mod
# print(lst)
# print(lst2)
print(ans)
|
n,m = list(map(int, input().split()))
mod = 10**9+7
lst = []
for i in range(m):
lst.append(int(eval(input())))
lst.sort()
#フィボナッチ数列
dp = [-1 for i in range(n+2)]
dp[0] = 1
dp[1] = 1
for i in lst:
dp[i] = 0
for i in range(2,n+2):
if dp[i]<0:
dp[i] = dp[i-1] + dp[i-2]
# print(lst)
# print(lst2)
# print(dp)
print((dp[n]%mod))
|
p03013
|
N, M = list(map(int, input().split()))
A = list(int(eval(input())) for i in range(M))
MOD = 10 ** 9 + 7
DP = [0] * (N + 10)
if 1 not in A:
DP[1] = 1
if 2 not in A and 1 in A:
DP[2] = 1
if 2 not in A and 1 not in A:
DP[2] = 2
for i in range(3, N + 1):
if i not in A:
DP[i] = (DP[i - 1] + DP[i - 2]) % MOD
print((DP[N]))
|
N, M = list(map(int, input().split()))
A = set(int(eval(input())) for i in range(M))
MOD = 10 ** 9 + 7
DP = [0] * (N + 10)
if 1 not in A:
DP[1] = 1
if 2 not in A and 1 in A:
DP[2] = 1
if 2 not in A and 1 not in A:
DP[2] = 2
for i in range(3, N + 1):
if i not in A:
DP[i] = (DP[i - 1] + DP[i - 2]) % MOD
print((DP[N]))
|
p03013
|
N, M = list(map(int, input().split()))
a = [int(eval(input())) for i in range(M)]
dp = [0]*(N+1)
dp[0] = 1
dp[1] = 1
for i in range(2, N+1):
# 壊れた床がなく単純に求める場合
#dp[i] = dp[i-1]+dp[i-2]
if not i-1 in a:
dp[i] += dp[i-1]
if not i-2 in a:
dp[i] += dp[i-2]
print((dp[N] % 1000000007))
|
N, M = list(map(int, input().split()))
A = {}
for _ in range(M):
a = int(eval(input()))
A[a] = True
dp = [0]*(N+1)
dp[0] = 1
dp[1] = 1
for i in range(2, N+1):
# 壊れた床がなく単純に求める場合
#dp[i] = dp[i-1]+dp[i-2]
if not i-1 in A:
dp[i] += dp[i-1]
if not i-2 in A:
dp[i] += dp[i-2]
print((dp[N] % 1000000007))
|
p03013
|
import math
import copy
from operator import mul
from functools import reduce
from collections import defaultdict
from collections import Counter
from collections import deque
# 直積 A={a, b, c}, B={d, e}:のとき，A×B={(a,d),(a,e),(b,d),(b,e),(c,d),(c,e)}: product(A, B)
from itertools import product
# 階乗 P!: permutations(seq), 順列 {}_len(seq) P_n: permutations(seq, n)
from itertools import permutations
# 組み合わせ {}_len(seq) C_n: combinations(seq, n)
from itertools import combinations
from bisect import bisect_left, bisect_right
# import numpy as np
# from scipy.special import perm
# from scipy.special import comb
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def i_inpl(): return int(eval(input()))
def l_inpl(): return list(map(int, input().split()))
INF = float("inf")
########
N, M = l_inpl()
a = [ i_inpl() for _ in range(M)]
# for _ in range(M):
# ai = i_inpl()
# a.append(ai)
dp = [None] * (N+1)
dp[N] = 1
# print(dp)
for i in range(N-1, -1, -1):
if i in a:
dp[i] = 0
else:
if N-1 == i:
dp[i] = 1
else:
if i+1 in a and i+2 in a:
dp[i] = 0
elif i+1 in a:
dp[i] = dp[i+2]
elif i+2 in a:
dp[i] = dp[i+1]
else:
dp[i] = dp[i+1] + dp[i+2]
print((dp[0] % 1000000007))
|
import math
import copy
from operator import mul
from functools import reduce
from collections import defaultdict
from collections import Counter
from collections import deque
# 直積 A={a, b, c}, B={d, e}:のとき，A×B={(a,d),(a,e),(b,d),(b,e),(c,d),(c,e)}: product(A, B)
from itertools import product
# 階乗 P!: permutations(seq), 順列 {}_len(seq) P_n: permutations(seq, n)
from itertools import permutations
# 組み合わせ {}_len(seq) C_n: combinations(seq, n)
from itertools import combinations
from bisect import bisect_left, bisect_right
# import numpy as np
# from scipy.special import perm
# from scipy.special import comb
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def i_inpl(): return int(eval(input()))
def l_inpl(): return list(map(int, input().split()))
INF = float("inf")
########
N, M = l_inpl()
a = { i_inpl(): True for _ in range(M)}
# for _ in range(M):
# ai = i_inpl()
# a.append(ai)
dp = [None] * (N+1)
dp[N] = 1
# print(dp)
for i in range(N-1, -1, -1):
if i in a:
dp[i] = 0
else:
if N-1 == i:
dp[i] = 1
else:
if i+1 in a and i+2 in a:
dp[i] = 0
elif i+1 in a:
dp[i] = dp[i+2]
elif i+2 in a:
dp[i] = dp[i+1]
else:
dp[i] = dp[i+1] + dp[i+2]
print((dp[0] % 1000000007))
|
p03013
|
#!/usr/bin/env python3
#ABC129 C
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n,m = LI()
a = [I() for _ in range(m)]
dp = [0]*(n+1)
dp[0],dp[1] = 1,1
for i in a:
dp[i] = -1
for i in range(2,n+1):
if dp[i] < 0:
continue
if dp[i-1] < 0:
dp[i] = dp[i-2]
continue
if dp[i-2] < 0:
dp[i] = dp[i-1]
continue
dp[i] = (dp[i-1] + dp[i-2]) % mod
if dp[-1] == -1:
print((0))
else:
print((dp[-1]))
|
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n,m = LI()
f = defaultdict(int)
for i in range(m):
a = I()
f[a] = 1
dp = [0]*(n+1)
dp[0] = 1
for i in range(1,n+1):
if f[i]:
continue
if i > 1:
dp[i] = dp[i-1] + dp[i-2]
dp[i] %= mod
else:
dp[i] = dp[i-1]
dp[i] %= mod
print((dp[n]))
|
p03013
|
N, M = list(map(int, input().split()))
mae = 0
sub = []
flag = False
for _ in range(M):
broken = int(eval(input()))
if mae == broken: # 不可能
flag = True
if flag:
continue
if mae+1 == broken:
mae = broken + 1
continue
sub.append(broken-1-mae)
mae = broken + 1
# 無理な時
if flag:
print((0))
exit()
# forの中で最後まで行ってない分の追加
if mae != N:
sub.append(N-mae)
from operator import mul
from functools import reduce
# nCrの関数
def C(n, r):
r = min(r, n - r)
numer = reduce(mul, list(range(n, n - r, -1)), 1)
denom = reduce(mul, list(range(1, r + 1)), 1)
return numer // denom
# 壊れてるやつの間の上り方の場合の数
def count(n):
ans = 1
for i in range(n//2):
ans += C(n-i-1, i+1)
return ans
ans = 1
waru = 10**9+7
for s in sub:
ans *= count(s)%waru
print((ans%waru))
|
N, M = list(map(int, input().split()))
A = [True]*N
for _ in range(M):
a = int(eval(input()))
A[a-1] = False # 壊れてるところはfalse
waru = 10**9 + 7
dp = [0]*(N+1)
dp[0], dp[1] = 1, 1 # 初期条件
if not A[0]: # 1段目が壊れてたら
dp[1] = 0
for i in range(2,N+1):
# 壊れてるところはdp=0にする
if not A[i-1]:
dp[i] = 0
else:
dp[i] = (dp[i-1] + dp[i-2])%waru
print((dp[-1]))
|
p03013
|
n,m=list(map(int,input().split()))
broken=[False for i in range(n+1)]
for i in range(m):
a=int(eval(input()))
broken[a]=True
ans=[1]
if broken[1]:
ans.append(0)
else:
ans.append(1)
for i in range(2,n+1):
if broken[i]:
ans.append(0)
else:
ans.append((ans[i-1]+ans[i-2])%1000000007)
print((ans[n]))
|
#n=int(input())
n,m=list(map(int,input().split()))
#t=int(input())
#al=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]
dp=[0]*(n+1)
mod=10**9+7
broken={i:False for i in range(1,n+1)}
for i in range(m):
a=int(eval(input()))
broken[a]=True
if broken[1]:
dp[1]=0
else:
dp[1]=1
dp[0]=1
for i in range(2,n+1):
if not broken[i]:
dp[i]=(dp[i-1]+dp[i-2])%mod
print((dp[n]))
|
p03013
|
import sys
input=sys.stdin.readline
#import fractions
#import math
#import collections
#from collections import deque
#from bisect import bisect_left
#N = int(input())
#S = list(input())
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = list(map(int,input().split()))
#A = [int(input()) for _ in range(N)]
#S = [input() for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
N,M = list(map(int,input().split()))
A = [int(eval(input())) for _ in range(M)]
ans = [0] * (N+3)
ans[0] = 1
for i in range(N):
if i not in A:
ans[i+1] += ans[i]
ans[i+1] = ans[i+1] % 1000000007
ans[i+2] += ans[i]
ans[i+2] = ans[i+2] % 1000000007
else:
ans[i] = 0
print((ans[N]))
|
import sys
input=sys.stdin.readline
#import fractions
#import math
#import collections
#from collections import deque
#from bisect import bisect_left
#N = int(input())
#S = list(input())
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = list(map(int,input().split()))
#A = [int(input()) for _ in range(N)]
#S = [input() for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
N,M = list(map(int,input().split()))
dicti = {i:True for i in range(N+2)}
for i in range(M):
a = int(eval(input()))
dicti[a] = False
ans = [0] * (N+3)
ans[0] = 1
for i in range(N):
if dicti[i]:
ans[i+1] += ans[i]
ans[i+1] = ans[i+1] % 1000000007
ans[i+2] += ans[i]
ans[i+2] = ans[i+2] % 1000000007
else:
ans[i] = 0
print((ans[N]))
|
p03013
|
n, m = list(map(int, input().split()))
a = []
for i in range(m):
a.append(int(eval(input())))
mod = 10 ** 9+ 7
com = [0, 1]
for i in range(n):
if (i + 1) in a:
com.append(0)
else:
com.append((com[-1] + com[-2]) % mod)
print((com[-1]))
|
n, m = list(map(int, input().split()))
a = []
for i in range(m):
a.append(int(eval(input())))
a = set(a)
mod = 10 ** 9+ 7
com = [0, 1]
for i in range(n):
if (i + 1) in a:
com.append(0)
else:
com.append((com[-1] + com[-2]) % mod)
print((com[-1]))
|
p03013
|
NM = list(map(int,input().split()))
N = NM[0]
M = NM[1]
A =[]
while True:
try:
A.append(int(eval(input())))
except:
break;
countlist = [1,1,2]
if N >3:
for i in range(3,N+1):
a = countlist[i-2]+countlist[i-1]
if a>1000000007:
a = a%1000000007
countlist.append(a)
t = 0
count = 0
out = []
if N >1:
for i in range(1,N+1):
count+=1
if ((t<len(A))and(i==A[t])):
t+= 1
while ((t<len(A))and(i==A[t])):
t+=1
if count > 0:
out.append(countlist[count-1])
else:
out.append(0)
break
count = -1
if count>=0:
out.append(countlist[count])
output = 1
for i in range(len(out)):
output = output*out[i]
if output > 1000000007:
output = output%1000000007
print(output)
|
N,M = list(map(int,input().split()))
p=10**9+7
A = [0]*(N+1)
flag = 0
for i in range(M):
tmp = int(eval(input()))
A[tmp]=1
if A[tmp]*A[tmp-1]>0:
flag=1
break
if flag==1:
print((0))
else:
dp = [0]*(N+1)
dp[0] = 1
dp[1] = 1-A[1]
for i in range(2,N+1):
if A[i]==1:
continue
dp[i]=(dp[i-1]+dp[i-2])%p
print((dp[-1]))
|
p03013
|
n,m=list(map(int,input().split()))
a=list(int(eval(input())) for i in range(m))
x=[0]*(n+1)
x[0]=1
for i in range(1,n+1):
x[i]=(x[i-1]+x[i-2])%(10**9+7)
if i in a:
x[i]=0
print((x[n]))
|
n,m=list(map(int,input().split()))
A=set(int(eval(input())) for i in range(m))
x=[0]*(n+1)
x[0]=1
if 1 in A:
x[1]=0
else:
x[1]=1
for j in range(2,n+1):
if j in A:
x[j]=0
else:
x[j]=(x[j-1]+x[j-2])%(10**9+7)
print((x[n]))
|
p03013
|
import math
#N = int(input())
N, M = list(map(int,input().split()))
#W =list(map(int,input().split()))
a = [(int(eval(input()))) for i in range(M)]
from operator import mul
from functools import reduce
def comb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def stair_count(start,end):
#print(start,end)
aida = end - start
total = 0
i = aida
#print("aida/2={}".format(aida/2))
kazu = 0
while i >= kazu:
total += comb(i,kazu)
kazu += 1
i -= 1
return total
start = 0
answer = 1
for i in a:
#print("i={}".format(i))
if i == start:
print((0))
exit()
else:
answer = (answer * stair_count(start, i-1))
start = i+1
answer = (answer * stair_count(start, N))
#print("answer={}".format(answer))
print((answer%1000000007))
|
#N = int(input())
N, M = list(map(int,input().split()))
#W =list(map(int,input().split()))
a = [(int(eval(input()))) for i in range(M)]
import sys
sys.setrecursionlimit(100000)
memo =[-1]*(N+2)
def stair_count(n):
if memo[n]!= -1:
return memo[n]
if n==0 or n==1:
memo[n] =1
return memo[n]
memo[n] = stair_count(n-1) + stair_count(n-2)
return memo[n]
start = 0
answer = 1
for i in a:
if i == start:
print((0))
exit()
else:
n = i-1-start
answer = (answer * stair_count(n))
start = i+1
n = N -start
answer = (answer * stair_count(n))
print((answer%1000000007))
|
p03013
|
#N = int(input())
N, M = list(map(int,input().split()))
#W =list(map(int,input().split()))
a = [(int(eval(input()))) for i in range(M)]
import sys
sys.setrecursionlimit(100000)
memo =[-1]*(N+2)
def stair_count(n):
if memo[n]!= -1:
return memo[n]
if n==0 or n==1:
memo[n] =1
return memo[n]
memo[n] = stair_count(n-1) + stair_count(n-2)
return memo[n]
start = 0
answer = 1
for i in a:
if i == start:
print((0))
exit()
else:
n = i-1-start
answer = (answer * stair_count(n))
start = i+1
n = N -start
answer = (answer * stair_count(n))
print((answer%1000000007))
|
#N = int(input())
N, M = list(map(int,input().split()))
#W =list(map(int,input().split()))
a = [(int(eval(input()))) for i in range(M)]
import sys
sys.setrecursionlimit(100000)
memo =[-1]*(N+2)
memo[0] = 1
memo[1] = 1
def stair_count(n):
for j in range(2,n+1):
memo[j] = memo[j-1] + memo[j-2]
start = 0
answer = 1
dif = []
for i in a:
if i == start:
print((0))
exit()
else:
n = i-1-start
dif.append(n)
start = i+1
dif.append(N-start)
stair_count(max(dif))
for i in dif:
answer = (answer * memo[i])
print((answer%1000000007))
|
p03013
|
N, M = list(map(int, input().split()))
a = list(int(eval(input())) for i in range(M))
DP = [0]*(N+1)
for i in range(N+1):
if i in a:
DP[i] = 0
elif i == 0 or i == 1:
DP[i] = 1
else:
DP[i] = (DP[i-1]+DP[i-2])
print((DP[-1]%1000000007))
|
N, M = list(map(int, input().split()))
a = list(int(eval(input())) for i in range(M))
DP = [0]*(N+1)
pointer = 0
for i in range(N+1):
if pointer < M:
if i == a[pointer]:
DP[i] = 0
pointer += 1
continue
if i == 0 or i == 1:
DP[i] = 1
else:
DP[i] = (DP[i-1]+DP[i-2])
print((DP[-1]%1000000007))
|
p03013
|
n, m = list(map(int,input().split()))
a = [int(eval(input())) for i in range(m)]
p = [0 for i in range(n+1)]
for i in range(1,n+1):
if i in a:
p[i] = 0
elif i == 1:
p[i] = 1
elif i == 2:
p[i] = p[1] + 1
else:
p[i] = p[i-1] + p[i-2]
print((p[n] % (10**9 + 7)))
|
n, m = list(map(int,input().split()))
p = [0 for i in range(n+1)]
a = [0 for i in range(n+1)]
for i in range(m):
a[int(eval(input()))] = 1
for i in range(1,n+1):
if a[i] == 1:
p[i] = 0
elif i == 1:
p[i] = 1
elif i == 2:
p[i] = p[1] + 1
else:
p[i] = p[i-1] + p[i-2]
print((p[n] % (10**9 + 7)))
|
p03013
|
def resolve():
import sys
read = sys.stdin.read
readline = sys.stdin.readline
N, M = list(map(int, readline().split()))
a = [int(x) for x in read().split()]
dp = [0] * (N + 2)
dp[0] = 1
for i in range(N):
one = i + 1
two = i + 2
now = dp[i]
if one not in a:
dp[one] += now
if two not in a:
dp[two] += now
print((dp[N] % 1_000_000_007))
resolve()
|
def resolve():
import sys
read = sys.stdin.read
readline = sys.stdin.readline
N, M = list(map(int, readline().split()))
a = set(int(x) for x in read().split())
dp = [0] * (N + 2)
dp[0] = 1
for i in range(N):
now = dp[i]
if i + 1 not in a:
dp[i + 1] += now
if i + 2 not in a:
dp[i + 2] += now
print((dp[N] % 1_000_000_007))
resolve()
|
p03013
|
import sys
N,M=list(map(int,input().split()))
S=set(map(int,sys.stdin))
a,b=0,1
for i in range(1,N+1):
if i in S:
a,b=b,0
else:
a,b=b,a+b
print((b%(10**9+7)))
|
import sys
N,M=list(map(int,input().split()))
bad=set(map(int,sys.stdin))
MOD=10**9+7
a,b=0,1
for i in range(1,N+1):
if i in bad:
a,b=b,0
if a==0:
break
else:
a,b=b,(a+b)%MOD
print(b)
|
p03013
|
import sys
N,M=list(map(int,input().split()))
bad=set(map(int,sys.stdin))
MOD=10**9+7
a,b=0,1
for i in range(1,N+1):
if i in bad:
a,b=b,0
if a==0:
break
else:
a,b=b,(a+b)%MOD
print(b)
|
import sys
MOD=10**9+7
N,M=list(map(int,input().split()))
bad=set(map(int,sys.stdin))
a,b=0,1
for i in range(1,N+1):
if i in bad:
a,b=b,0
if a==0:
break
else:
a,b=b,(a+b)%MOD
print(b)
|
p03013
|
from functools import lru_cache
import sys
sys.setrecursionlimit(500000)
def input() -> str:
return sys.stdin.readline().rstrip()
mod = 10**9 + 7
@lru_cache(maxsize=None)
def dp(i):
if i == n - 1:
return 1
if i == n - 2:
return 2 - int(n - 1 in a)
return (dp(i + 1) * int(i + 1 not in a) % mod + dp(i + 2) * int(i + 2 not in a) % mod) % mod
n, m = [int(i) for i in input().split()]
a = [int(eval(input())) for _ in range(m)]
print((dp(0)))
|
import sys
def input():
return sys.stdin.readline().rstrip()
mod = 10**9 + 7
n, m = [int(i) for i in input().split()]
a = [int(eval(input())) for _ in range(m)]
notin = [1] * n
for i in a:
notin[i] = 0
dp = [0] * n
dp[n - 1] = 1
if n > 1:
dp[n - 2] = 1 + notin[n - 1]
for i in range(n - 3, -1, -1):
dp[i] += dp[i + 1] * notin[i + 1] % mod
dp[i] += dp[i + 2] * notin[i + 2] % mod
dp[i] %= mod
print((dp[0]))
|
p03013
|
import sys
def input():
return sys.stdin.readline().rstrip()
mod = 10**9 + 7
n, m = [int(i) for i in input().split()]
a = [int(eval(input())) for _ in range(m)]
notin = [1] * n
for i in a:
notin[i] = 0
dp = [0] * n
dp[n - 1] = 1
if n > 1:
dp[n - 2] = 1 + notin[n - 1]
for i in range(n - 3, -1, -1):
dp[i] += dp[i + 1] * notin[i + 1] % mod
dp[i] += dp[i + 2] * notin[i + 2] % mod
dp[i] %= mod
print((dp[0]))
|
import sys
def read():
return sys.stdin.readline().rstrip()
def main():
n, m = list(map(int, read().split()))
a = {int(read()) - 1 for _ in range(m)}
if n == 1:
print((1))
return
mod = 10**9 + 7
dp = [0] * n
if 0 not in a:
dp[0] = 1
if 1 not in a:
dp[1] = 1 + dp[0]
for i in range(2, n):
if i in a:
continue
dp[i] = (dp[i - 1] + dp[i - 2]) % mod
print((dp[-1]))
if __name__ == '__main__':
main()
|
p03013
|
n, m = list(map(int, input().split()))
a = set([int(eval(input())) for _ in range(m)])
mod = 1000000007
dp = [1] + [0] * n
for i in range(1, n + 1):
if i == 1:
dp[i] = 1
else:
dp[i] = (dp[i - 1] + dp[i - 2]) % mod
if i in a:
dp[i] = 0
print((dp[-1] % mod))
|
n, m = list(map(int, input().split()))
a = set(int(eval(input())) for _ in range(m))
mod = 10 ** 9 + 7
dp = [1] + [1] + [0] * (n - 1)
for i in range(1, n + 1):
if i >= 2:
dp[i] = (dp[i - 1] + dp[i - 2]) % mod
if i in a:
dp[i] = 0
print((dp[-1] % mod))
|
p03013
|
import sys
input = sys.stdin.readline
mod=1000000007
n,m=list(map(int,input().split()))
a=[]
for i in range(m):
a.append(int(eval(input())))
al=len(a)
f=0
for i in a:
if i+1 in a:
f=1
break
if f==1:
print((0))
else:
dp=[0]*(n+1)
dp[0]=1
if 1 in a:
dp[1]=0
a.pop(0)
al-=1
else:
dp[1]=1
for i in range(2,n+1):
if al>0 and i==a[0]:
dp[i]=0
a.pop(0)
al-=1
else:
dp[i]=(dp[i-1]+dp[i-2])%mod
print((dp[n]%mod))
|
import sys
input = sys.stdin.readline
mod=1000000007
n,m=list(map(int,input().split()))
a=[]
for i in range(m):
a.append(int(eval(input())))
al=len(a)
f=0
for i in range(al-1):
if a[i+1]==a[i]+1:
f=1
break
if f==1:
print((0))
else:
dp=[0]*(n+1)
dp[0]=1
if 1 in a:
dp[1]=0
a.pop(0)
al-=1
else:
dp[1]=1
for i in range(2,n+1):
if al>0 and i==a[0]:
dp[i]=0
a.pop(0)
al-=1
else:
dp[i]=(dp[i-1]+dp[i-2])%mod
print((dp[n]%mod))
|
p03013
|
n,m =list(map(int, input().split()))
#idxへの行き方の通りをリスト化
num_list = [0]*(n+1)
num_list[0] = 1
a_list =[int(eval(input())) for _ in range(m)]
if 1 not in a_list:
num_list[1] = 1
for i in range(2,n+1):
if i not in a_list:
num_list[i] = num_list[i-1] + num_list[i-2]
print((num_list[n]%(10**9+7)))
|
n,m =list(map(int, input().split()))
#idxへの行き方の通りをリスト化
num_list = [0]*(n+1)
num_list[0] = 1
a_list =set([int(eval(input())) for _ in range(m)])
if 1 not in a_list:
num_list[1] = 1
for i in range(2,n+1):
if i not in a_list:
num_list[i] = num_list[i-1] + num_list[i-2]
print((num_list[n]%(10**9+7)))
|
p03013
|
def dp(n):
d=[0]*(n+1)
if n==1:
return 1
else:
d[0]=1
if a[1]==0:
d[1]=1
else:
d[1]=0
for i in range(2,n+1):
if a[i]==0:
d[i]=d[i-1]+d[i-2]
else:
d[i]=0
return d[n]
n,m=list(map(int, input().split()))
a=[0]*(n+1)
for i in range(0,m):
k=int(eval(input()))
a[k]=1
print((dp(n)%1000000007))
|
def dp(n):
d=[0]*(n+1)
if n==1:
return 1
else:
d[0]=1
if a[1]==0:
d[1]=1
else:
d[1]=0
for i in range(2,n+1):
if a[i]==0:
d[i]=(d[i-1]+d[i-2])%1000000007
else:
d[i]=0
return d[n]
n,m=list(map(int, input().split()))
a=[0]*(n+1)
for i in range(0,m):
k=int(eval(input()))
a[k]=1
print((dp(n)))
|
p03013
|
N, M = list(map(int, input().split()))
a = [int(eval(input())) for j in range(M)]
#dp[i]:i段目までの上がり方
div = 1000000007
dp = [0] * (N+1)
dp[0] = 1
if not 1 in a:
dp[1] = 1
def stairs():
for i in range(N-1):
if dp[i+1] == 0 and dp[i] == 0:
break
if not i+2 in a:
dp[i+2] = (dp[i+1] + dp[i]) % div
print((dp[N]))
stairs()
|
N, M = list(map(int, input().split()))
a = [int(eval(input())) for j in range(M)]
#dp[i]:i段目までの上がり方
div = 1000000007
dp = [0] * (N+1)
dp[0] = 1
if not 1 in a:
dp[1] = 1
else:
del a[0]
def stairs():
for i in range(N-1):
if dp[i+1] == 0 and dp[i] == 0:
break
if a:
if i+2 == a[0]:
del a[0]
continue
dp[i+2] = (dp[i+1] + dp[i]) % div
print((dp[N]))
stairs()
|
p03013
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from functools import lru_cache
import sys
sys.setrecursionlimit(10 ** 9)
@lru_cache(maxsize=None)
def fib(n):
if n == 0:
return 1
elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
PRIME = 10 ** 9 + 7
N, M = list(map(int, input().split()))
broken_stairs = []
for _ in range(M):
broken_stairs.append(int(eval(input())))
prev_broken = -1
cannot = False
ans = 1
for a in broken_stairs:
if a - prev_broken == 1:
cannot = True
break
ans *= fib(a - prev_broken - 2)
ans %= PRIME
prev_broken = a
ans *= fib(N - prev_broken - 1)
ans %= PRIME
if cannot:
print((0))
else:
print(ans)
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def fib_memo(n):
if n <= 1:
return 1
memo = [0] * n
memo[0] = 1
memo[1] = 2
for i in range(2, n):
memo[i] = (memo[i - 1] + memo[i - 2]) % PRIME
return memo[n-1]
PRIME = 10 ** 9 + 7
N, M = list(map(int, input().split()))
broken_stairs = []
for _ in range(M):
broken_stairs.append(int(eval(input())))
prev_broken = -1
cannot = False
ans = 1
for a in broken_stairs:
if a - prev_broken == 1:
cannot = True
break
ans *= fib_memo(a - prev_broken - 2)
ans %= PRIME
prev_broken = a
ans *= fib_memo(N - prev_broken - 1)
ans %= PRIME
if cannot:
print((0))
else:
print(ans)
|
p03013
|
n, m = list(map(int, input().split()))
a = list(int(eval(input())) for _ in range(m))
M = 10**9+7
dp = [0]*(n+1)
dp[0] = 1
for i in range(1, n+1):
if i not in a:
dp[i] = (dp[i-1] + dp[i-2])%M
print((dp[n]))
|
n, m = list(map(int, input().split()))
b = [False]*(n+2)
for _ in range(m):
i = int(eval(input()))
b[i] = True
M = 10**9+7
dp = [0]*(n+1)
dp[0] = 1
for i in range(1, n+1):
if b[i] == False:
dp[i] = (dp[i-1] + dp[i-2])%M
print((dp[n]))
|
p03013
|
n,m = list(map(int, input().split()))
a_list = []
for i in range(m):
a_list.append(int(eval(input())))
# memo = [-1 for _ in range(n)]
step_now = 0
step_1 = 0
step_2 = 0
DIV_NUM = 1000000007
if 1 in a_list:
step_now = 0
else:
step_now = 1
for i in range(1, n):
if i == 1:
step_1 = step_now
if i+1 in a_list:
step_now = 0
else:
# memo[i] = (memo[0] + 1) % DIV_NUM
step_now = step_1 + 1
else:
step_2 = step_1
step_1 = step_now
if i+1 in a_list:
step_now = 0
else:
# memo[i] = (memo[i-1] + memo[i-2]) % DIV_NUM
step_now = (step_1 + step_2) % DIV_NUM
if step_now == step_1 == step_2 == 0:
break
print(step_now)
|
n,m = list(map(int, input().split()))
a_list = []
for i in range(m):
a_list.append(int(eval(input())))
# memo = [-1 for _ in range(n)]
step_now = 0
step_1 = 0
step_2 = 0
DIV_NUM = 1000000007
if 1 in a_list:
a_list.pop(0)
step_now = 0
else:
step_now = 1
for i in range(1, n):
if i == 1:
step_1 = step_now
if i+1 in a_list:
a_list.pop(0)
step_now = 0
else:
# memo[i] = (memo[0] + 1) % DIV_NUM
step_now = step_1 + 1
else:
step_2 = step_1
step_1 = step_now
if i+1 in a_list:
a_list.pop(0)
step_now = 0
else:
# memo[i] = (memo[i-1] + memo[i-2]) % DIV_NUM
step_now = (step_1 + step_2) % DIV_NUM
if step_now == step_1 == step_2 == 0:
break
print(step_now)
|
p03013
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
def main():
# n, m = map(int, input().split())
# a = [int(input()) for i in range(m)]
n, m = list(map(int, readline().split()))
a = list(map(int, read().split()))
mod = 1000000007
# フィボナッチ数列を作る要領で行う
d = [0] * (n+1)
# 2回0が続く状況aに連番があったら即座に終了する
cnt = 0
# d[0]とd[1]を規定。aに1が含まれていることを考慮して場合分けしておく
d[0] = 1
if 1 not in a:
d[1] = 1
# else:
# d[1] = 1
# 階段番号は2~nまでを見る必要がある
for i in range(2, n+1):
if i in a:
d[i] = 0
cnt += 1
if cnt == 2:
print('0')
exit()
else:
d[i] = (d[i-1] + d[i-2]) % mod
cnt = 0
# print(d)
ans = d[n]
print(ans)
if __name__ == '__main__':
main()
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
def main():
# n, m = map(int, input().split())
# a = [int(input()) for i in range(m)]
n, m = list(map(int, readline().split()))
a = set(map(int, read().split()))
mod = 1000000007
# フィボナッチ数列を作る要領で行う
d = [0] * (n+1)
# 2回0が続く状況aに連番があったら即座に終了する
cnt = 0
# d[0]とd[1]を規定。aに1が含まれていることを考慮して場合分けしておく
d[0] = 1
if 1 not in a:
d[1] = 1
# else:
# d[1] = 1
# 階段番号は2~nまでを見る必要がある
for i in range(2, n+1):
if i in a:
d[i] = 0
cnt += 1
if cnt == 2:
print('0')
exit()
else:
d[i] = (d[i-1] + d[i-2]) % mod
cnt = 0
# print(d)
ans = d[n]
print(ans)
if __name__ == '__main__':
main()
|
p03013
|
import sys
sys.setrecursionlimit(1000000)
n,m = list(map(int,input().split()))
a_list=[]
for i in range(m):
a_list.append(int(eval(input())))
def count(now,s,e):
if now > e:
return 0
if now == e:
return 1
cnt=0
cnt+=count(now+1,s,e)
cnt+=count(now+2,s,e)
return cnt
c_mod=1000000007
start=0
end=0
ans=1
before=100000
for a in a_list:
if abs(before-a)==1:
print((0))
exit()
# 各部分の移動方法
end=a-1
ans=ans*count(start,start,end)%c_mod
start=a+1
before=a
if end<n:
end=n
ans=ans*count(start,start,end)%c_mod
print(ans)
|
c_mod=1000000007
n,m = list(map(int,input().split()))
step=[0]*(n+1)
for _ in range(m):
a=int(eval(input()))
step[a-1]=-1
if step[0]!=-1:
step[0]=1
if step[1]!=-1:
step[1]=1
for i in range(n-1):
if step[i]==-1:
continue
if step[i+1]!=-1:
step[i+1]+=step[i]
if step[i+2]!=-1:
step[i+2]+=step[i]
print((step[n-1]%c_mod))
|
p03013
|
c_mod=1000000007
n,m = list(map(int,input().split()))
step=[0]*(n+1)
for _ in range(m):
a=int(eval(input()))
step[a-1]=-1
if step[0]!=-1:
step[0]=1
if step[1]!=-1:
step[1]=1
for i in range(n-1):
if step[i]==-1:
continue
if step[i+1]!=-1:
step[i+1]+=step[i]
if step[i+2]!=-1:
step[i+2]+=step[i]
print((step[n-1]%c_mod))
|
c_mod=1000000007
n,m = list(map(int,input().split()))
a_list=[]
for i in range(m):
a_list.append(int(eval(input())))
fib=[0]*(n+1)
fib[0]=1
fib[1]=1
for i in range(2,n+1):
fib[i]=fib[i-1]+fib[i-2]
def count(s,e):
return fib[e-s]
c_mod=1000000007
start=0
end=0
ans=1
before=100000
for a in a_list:
if abs(before-a)==1:
print((0))
exit()
# 各部分の移動方法
end=a-1
ans=ans*count(start,end)%c_mod
start=a+1
before=a
if end<n:
end=n
ans=ans*count(start,end)%c_mod
print(ans)
|
p03013
|
N, M = list(map(int, input().split()))
MOD = 10 ** 9 + 7
dp = [0] * (N+1)
dp[0] = 1
a = set()
for _ in range(M):
a.add(int(eval(input())))
if 1 in a:
if 2 in a:
print((0))
exit()
dp[2] = 1
start = 3
else:
dp[1] = 1
start = 2
for i in range(start, N+1):
if i in a:
continue
dp[i] = dp[i-1] + dp[i-2]
dp[i] %= MOD
print((dp[N]))
|
N,M = list(map(int,input().split()))
A = set()
for i in range(M):
A.add(int(eval(input())))
count = [0] * (N+1)
count[0] = 1
mod = 10 ** 9 + 7
if 1 in A:
if 2 in A:
print((0))
exit()
count[2] = 1
start = 3
else:
count[1] = 1
start = 2
for i in range(start, N+1):
if i in A:
continue
count[i] = count[i-1] + count[i-2]
count[i] %= mod
print((count[N]))
|
p03013
|
def C_TypicalStairs():
N, M = list(map(int, input().split()))
am = [int(eval(input())) for i in range(M)]
n_list = [i for i in range(N+1)]
can_move = True
num_move = 0
if(M == 0):
num_move = fib(len(n_list))
else:
# 到達不可を除く
for i in range(M-1):
if ((am[i] + 1) == am[i+1]):
can_move = False
if (can_move):
num_move = fib(len(n_list[:am[0]]))
if (M <= 1):
pass
else:
for i in range(M-1):
num_move *= fib(len(n_list[am[i]+1:am[i+1]]))
num_move *= fib(len(n_list[am[M-1]+1:]))
print((num_move % 1000000007))
def fib(n):
if (n <= 1):
a0 = n
else:
a0, a1 = 0, 1
for _ in range(n):
a0, a1 = a1, a0 + a1
return a0
if __name__ == "__main__":
C_TypicalStairs()
|
def C_TypicalStairs():
N, M = list(map(int, input().split()))
am = [int(eval(input())) for i in range(M)]
can_move = True
num_move = 0
if(M == 0):
num_move = fib(N+1)
else:
# 到達不可を除く
for i in range(M-1):
if ((am[i] + 1) == am[i+1]):
can_move = False
if (can_move):
num_move = fib(am[0])
if (M <= 1):
pass
else:
for i in range(M-1):
num_move *= fib(am[i+1] - am[i] - 1)
num_move *= fib(N - am[M-1])
print((num_move % 1000000007))
def fib(n):
if (n <= 1):
a0 = n
else:
a0, a1 = 0, 1
for _ in range(n):
a0, a1 = a1, a0 + a1
return a0
if __name__ == "__main__":
C_TypicalStairs()
|
p03013
|
import sys
n, m = list(map(int, input().split()))
As = []
a_ = -1
for i in range(m):
a = int(eval(input()))
if a == a_ + 1:
print((0))
sys.exit()
As.append(a)
a_ = a
nums = [1] + [0] * n
if 1 in As:
pass
else:
nums[1] = 1
for i in range(2, n + 1):
if i in As:
continue
else:
nums[i] = (nums[i-1] + nums[i-2]) % 1000000007
print((nums[-1]))
|
import sys
n, m = list(map(int, input().split()))
if m > 0:
As = set(map(int, sys.stdin))
else:
As = set()
nums = [0] * (n + 1)
nums[0] = 1
if 1 in As:
pass
else:
nums[1] = 1
for i in range(2, n + 1):
if i in As:
continue
else:
nums[i] = (nums[i-1] + nums[i-2]) % 1000000007
print((nums[-1]))
|
p03013
|
n,m=list(map(int,input().split()))
a = [int(eval(input())) for i in range(m)]
dp=[0]*(n+1)
for i in range(n,-1,-1):
if i not in a:
if i==n or i==n-1:
dp[i]=1
else:
dp[i]=dp[i+1]+dp[i+2]
print((dp[0]%1000000007))
|
n,m=list(map(int,input().split()))
a = [int(eval(input())) for i in range(m)]
dp=[0]*(n+1)
if m==0:
for i in range(n,-1,-1):
if i==n or i==n-1:
dp[i]=1
else:
dp[i]=dp[i+1]+dp[i+2]
print((dp[0]%1000000007))
else:
j=-1
for i in range(n,-1,-1):
if i==a[j]:
if m>j*(-1):
j-=1
else:
if i==n or i==n-1:
dp[i]=1
else:
dp[i]=dp[i+1]+dp[i+2]
print((dp[0]%1000000007))
|
p03013
|
n,m=list(map(int,input().split()))
a = [int(eval(input())) for i in range(m)]
broken = set(a)
dp=[0]*(n+1)
mod = 10**9 + 7
for i in range(n,-1,-1):
if i in broken:
continue
else:
if i==n or i==n-1:
dp[i]=1
else:
dp[i]=dp[i+1]+dp[i+2]
print((dp[0]%mod))
|
n,m=list(map(int,input().split()))
a = [int(eval(input())) for i in range(m)]
broken = set(a)
dp=[0]*(n+1)
mod = 10**9 + 7
for i in range(n,-1,-1):
if i in broken:
continue
elif i==n or i==n-1:
dp[i]=1
else:
dp[i]=dp[i+1]+dp[i+2]
dp[i]%=mod
print((dp[0]))
|
p03013
|
n,m = list(map(int,input().split()))
L = []
for i in range(m):
L.append(int(eval(input())))
#print(L)
mod = 10**9+7
dp = [0]*(n+1)
dp[0]= 1
dp[1] = 1
#dp[2] = 2
for i in range(1,n+1):
if 1 in L:
dp[1] = 0
if i in L:
continue
else:
if i <= 1:
dp[i] = dp[i-1]
elif i>=2 :
dp[i] = (dp[i-1]+ dp[i-2])%mod
#print(dp)
print((dp[n]))
|
n,m = list(map(int,input().split()))
mod = 10**9+7
dp = [-1]*(n+1)
dp[0]= 0
dp[1] = 1
for i in range(m):
a = int(eval(input()))
dp[a] = 0
for i in range(2,n+1):
if dp[i] == -1:
if i <= 2:
dp[i] = dp[i-1]+1
elif i>=3 :
dp[i] = (dp[i-1]+ dp[i-2])%mod
print((dp[n]))
|
p03013
|
n, m = [int(x) for x in input().split()]
a = []
for _ in range(m):
a.append(int(eval(input())))
mod = 1000000007
dp = [0]*(n+1)
dp[0] = 1
for i in range(1, n+1):
dp[i] = (dp[i-1] + dp[i-2]) % mod
if i in a:
dp[i] = 0
print((dp[n]))
|
n, m = [int(x) for x in input().split()]
a = set([int(eval(input())) for _ in range(m)])
dp = [0]*(n+1)
dp[0] = 1
for i in range(1, n+1):
dp[i] = (dp[i-1] + dp[i-2]) % (10**9+7)
if i in a:
dp[i] = 0
print((dp[n]))
|
p03013
|
n,m = list(map(int,input().split()))
a = [0] * m
for i in range(m):
a[i] = int(eval(input()))
MOD = 10 ** 9 + 7
dp = [0] * (n + 1)
dp[0] = 1
for i in range(1, n + 1):
if i in a:
continue
x = dp[i - 1]
if i > 1:
x += dp[i - 2]
dp[i] = x % MOD
ans = dp[n]
print(ans)
|
N, M = [int(x) for x in input().split()]
a = set(int(eval(input())) for _ in range(M))
MOD = 10 ** 9 + 7
dp = [0] * (N + 1)
dp[0] = 1
for i in range(1, N + 1):
if i in a:
continue
x = dp[i - 1]
if i > 1:
x += dp[i - 2]
dp[i] = x % MOD
ans = dp[N]
print(ans)
|
p03013
|
# 2019-11-14 10:01:24(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np
mod = 10 ** 9 + 7
def main():
n, m, *broken_treads = [int(x) for x in sys.stdin.read().split()]
safe = sorted((set(range(1, n+1)) - set(broken_treads)))
p = [0, 1] # p[i] は連続するi段の、1~i段目までの登り方の総パターン
for _ in range(n):
p.append(p[-1] + p[-2])
count = 1 # 最初に0th stepを踏んでいるので1
sections = []
for i in range(1, n+1):
if i in safe:
count += 1
else:
if count >= 1:
sections.append(p[count])
count = 0
else: # countが0だったら一つ前も壊れている
print((0))
sys.exit()
if count >= 1: # if the last is not broken.
sections.append(p[count])
ans = reduce(lambda x, y: x * y % mod, sections)
print(ans)
if __name__ == "__main__":
main()
|
import sys
mod = 10 ** 9 + 7
n, m, *a = [int(x) for x in sys.stdin.read().split()]
dp = [0] * (n + 2)
dp[0] = 0
dp[1] = 1
for i in range(2, n+2):
if i - 1 in a:
if dp[i-1] == 0:
print((0))
sys.exit()
else:
dp[i] = 0
else:
dp[i] = (dp[i-1] + dp[i-2]) % mod
print((dp[-1]))
|
p03013
|
import sys
mod = 10 ** 9 + 7
n, m, *a = [int(x) for x in sys.stdin.read().split()]
dp = [0] * (n + 2)
dp[0] = 0
dp[1] = 1
for i in range(2, n+2):
if i - 1 in a:
if dp[i-1] == 0:
print((0))
sys.exit()
else:
dp[i] = 0
else:
dp[i] = (dp[i-1] + dp[i-2]) % mod
print((dp[-1]))
|
import sys
mod = 10 ** 9 + 7
n, m, *a = [int(x) for x in sys.stdin.read().split()]
safe = sorted(set(range(1,n+1)) - set(a))
dp = [0] * (n + 2)
dp[0] = 0
dp[1] = 1
for i in safe:
dp[i+1] = (dp[i] + dp[i-1]) % mod
print((dp[-1]))
|
p03013
|
import sys
mod = 10 ** 9 + 7
n, m, *a = [int(x) for x in sys.stdin.read().split()]
safe = sorted(set(range(1,n+1)) - set(a))
dp = [0] * (n + 2)
dp[0] = 0
dp[1] = 1
for i in safe:
dp[i+1] = (dp[i] + dp[i-1]) % mod
print((dp[-1]))
|
# 2019-11-14 10:01:24(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np
mod = 10 ** 9 + 7
def main():
n, m, *a = [int(x) for x in sys.stdin.read().split()]
safe = sorted(set(range(1,n+1)) - set(a))
dp = [0] * (n + 2) # dp[i+1]: i段目までいくパターン数
dp[0] = 0 # -1段目にはいけない
dp[1] = 1 # 初期条件(0段目にいる)
for i in safe:
dp[i+1] = (dp[i] + dp[i-1]) % mod
print((dp[-1]))
if __name__ == "__main__":
main()
|
p03013
|
n,m=list(map(int,input().split()))
ls=[int(eval(input())) for i in range(m)]
def dp(n,ls):
dp_table=[[0 for i in range(n+1)]]
dp_table[0][0]=1
sum=0
count=1
edge=0
while True:
row=[0]*count
previous=dp_table[-1]
for i in range(count,n+1):
if i in ls:
row.append(0)
elif i==0:
row.append(0)
elif i==1:
row.append(previous[0])
else:
row.append(previous[i-1]+previous[i-2])
if i==edge+2:
edge=i
row=row+([0]*(n-edge))
break
sum+=row[-1]
if row.count(0)==n+1:
return sum
dp_table.append(row)
count+=1
print((dp(n,ls)%1000000007))
|
n,m=list(map(int,input().split()))
ls=[int(eval(input())) for i in range(m)]
if 1 in ls:
steps=[1,0]
else:
steps=[1,1]
while len(steps)<=n:
this_step=len(steps)
if this_step in ls:
ap=0
else:
ap=steps[-1]+steps[-2]
steps.append(ap)
print((steps[-1]%1000000007))
|
p03013
|
n,m=list(map(int,input().split()))
danger=[int(eval(input())) for i in range(m)]
if 1 in danger:
steps=[1,0]
else:
steps=[1,1]
for this_step in range(2,n+1):
if this_step in danger:
ap=0
else:
ap=steps[-1]+steps[-2]
steps.append(ap)
print((steps[-1]%1000000007))
|
n,m = list(map(int,input().split()))
a = [int(eval(input())) for _ in range(m)]
a = set(a)
mod = 10**9+7
dp = [0]*(n+1)
dp[0] = 1
if 1 not in a:
dp[1] = 1
for i in range(2,n+1):
if i not in a:
dp[i] = dp[i-1]+dp[i-2]
print((dp[-1]%mod))
|
p03013
|
n,m=list(map(int,input().split()))
danger=[int(eval(input())) for i in range(m)]
steps=[0]*(n+1)
steps[0]=1
if 1 in danger:
steps[1]=0
else:
steps[1]=1
for this_step in range(2,n+1):
if this_step in danger:
ap=0
else:
steps[this_step]=steps[this_step-1]+steps[this_step-2]
print((steps[-1]%1000000007))
|
n,m=list(map(int,input().split()))
danger=[int(eval(input())) for i in range(m)]
danger=set(danger)
steps=[0]*(n+1)
steps[0]=1
if 1 in danger:
steps[1]=0
else:
steps[1]=1
for this_step in range(2,n+1):
if this_step in danger:
ap=0
else:
steps[this_step]=steps[this_step-1]+steps[this_step-2]
print((steps[-1]%1000000007))
|
p03013
|
def main():
N, M = list(map(int, input().split()))
broken = [int(eval(input())) for _ in range(M)]
div = 1000000007
comb_list = [0] * (N + 1)
comb_list[0] = 1
if 1 not in broken:
comb_list[1] = 1
for i in range(2, N + 1):
if i in broken:
continue
comb_list[i] = (comb_list[i - 1] + comb_list[i - 2]) % div
print((comb_list[-1]))
if __name__ == "__main__":
main()
|
def main():
N, M, *a = list(map(int, open(0).read().split()))
div = 1000000007
broken = set(a)
comb_list = [0] * (N + 1)
comb_list[0] = 1
if 1 not in broken:
comb_list[1] = 1
for i in range(2, N + 1):
if i in broken:
continue
comb_list[i] = (comb_list[i - 1] + comb_list[i - 2]) % div
print((comb_list[-1]))
if __name__ == "__main__":
main()
|
p03013
|
import sys
sys.setrecursionlimit(int(1e6))
n,m=list(map(int,input().split()))
memo=[0]*(n+1)
memo[0]=1
memo[1]=1
for i in range(m):
memo[int(eval(input()))]=-2
def dp(i):
if memo[i]==-2:
return 0
elif memo[i]==0:
s=dp(i-1)
if i>=2:
s+=dp(i-2)
memo[i]=s%(10**9+7)
return memo[i]
else:
return memo[i]
print((dp(n)))
|
import sys
sys.setrecursionlimit(int(1e6))
n,m=list(map(int,input().split()))
memo=[-1]*(n+1)
memo[0]=1
memo[1]=1
for i in range(m):
memo[int(eval(input()))]=-2
def dp(i): #i段目(0~n)まで行く方法
if memo[i]==-2:
return 0
elif memo[i]==-1:
s=dp(i-1)
if i>=2:
s+=dp(i-2)
memo[i]=s%(10**9+7)
return memo[i]
else:
return memo[i]
print((dp(n)))
|
p03013
|
N,M=list(map(int,input().split()))
A=[]
B=[]
a=[]
a.append(0)
x=0
d=1
A.append(1)
A.append(2)
B.append(1)
B.append(1)
for j in range(2,N):
A.append(A[j-1]+A[j-2])
B.append(B[j-1]+B[j-2])
for i in range(1,M+1):
a.append(int(eval(input())))
if a[i-1]==0:
if a[i]==1:
d=1
else:
x=A[a[i]-a[i-1]-2]
d=d*x%(10**9+7)
else:
x=B[a[i]-a[i-1]-2]
d=d*x%(10**9+7)
if i>1:
if a[i]-a[i-1]==1:
d=0
c=N-a[M]
if c==1:
print(d)
elif c==N:
x=A[c-1]
d=d*x%(10**9+7)
print(d)
else:
x=A[N-a[M]-2]
d=d*x%(10**9+7)
print(d)
|
N,M=list(map(int,input().split()))
dp=[1]*(N+1)
for _ in range(M):
a=int(eval(input()))
dp[a]=0
for i in range(2,N+1):
if dp[i]!=0:
dp[i]=dp[i-1]+dp[i-2]
print((dp[N]%(10**9+7)))
|
p03013
|
n, m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
arr = [0] * (n+1)
arr[0] = 1
for i in range(1, n+1):
if i in a:
arr[i] = 0
else:
arr[i] = (arr[i-1] + arr[i-2]) % 1000000007
print((arr[-1]))
|
n, m = list(map(int, input().split()))
a = set(int(eval(input())) for _ in range(m))
arr = [0] * (n+1)
arr[0] = 1
for i in range(1, n+1):
if i in a:
arr[i] = 0
else:
arr[i] = (arr[i-1] + arr[i-2]) % 1000000007
print((arr[-1]))
|
p03013
|
#-*- coding:utf-8 -*-
N, M = list(map(int, input().split()))
hsh = {}
for i in range(M):
hsh[int(eval(input()))] = True
acc = [0 for _ in range(N+1)]
acc[0] = 1
for i in range(1,N+1):
if i > 1 and i-2 in hsh: # 2段前が穴
if i-1 in hsh: # 1段前が穴
d = 0
else:
d = acc[i-1]
else: # 2段前が穴ではない
s = acc[i-2] if i > 1 else 0
if i-1 in hsh: # 1段前が穴
d = s
else:
d = acc[i-1] + s
acc[i] = d
# print(hsh)
# print(acc)
print((acc[-1]%1000000007))
|
#-*- coding:utf-8 -*-
N, M = list(map(int, input().split()))
hsh = {}
for i in range(M):
hsh[int(eval(input()))] = True
acc = [0 for _ in range(N+1)]
acc[0] = 1
if 1 in hsh:
acc[1] = 0
else:
acc[1] = 1
for i in range(2,N+1):
if i-2 in hsh: # 2段前が穴
if i-1 in hsh: # 1段前が穴
d = 0
else:
d = acc[i-1]
else: # 2段前が穴ではない
if i-1 in hsh: # 1段前が穴
d = acc[i-2]
else:
d = acc[i-1] + acc[i-2]
acc[i] = d
# print(hsh)
# print(acc)
print((acc[-1]%1000000007))
|
p03013
|
n, m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
b = list(range(1, n+1))
for i in a:
b.remove(i)
dp = [0] * (n+1)
dp[0] = 1
if b[0] == 1:
dp[1] = 1
b.pop(0)
else:
dp[1] = 0
for i in b:
dp[i] = (dp[i-1]%1000000007 + dp[i-2]%1000000007)%1000000007
print((dp[n]%1000000007))
|
n, m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
a.append(0)
dp = [0] * (n+1)
dp[0] = 1
acounter = 0
if a[0] == 1:
dp[1] = 0
acounter = 1
else:
dp[1] = 1
for i in range(2, n+1):
if i == a[acounter]:
dp[i]=0
acounter+=1
else:
dp[i] = (dp[i-1]%1000000007 + dp[i-2]%1000000007)%1000000007
print((dp[n]%1000000007))
|
p03013
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
n, m = list(map(int, input().split()))
a = []
for _ in range(m):
a.append(int(eval(input())))
memo = [0]*(n+1)
memo[0]=1
if not(1 in a):
memo[1]=1
for i in range(2,n+1):
#print(i)
if i in a:
continue
#print(memo[i-1],memo[i-2])
memo[i]=memo[i-2]+memo[i-1]
#print(memo)
print((memo[n]% 1000000007))
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
n, m = list(map(int, input().split()))
a = []
for _ in range(m):
a.append(int(eval(input())))
a=set(a)
memo = [0]*(n+1)
memo[0]=1
if not(1 in a):
memo[1]=1
for i in range(2,n+1):
#print(i)
if i in a:
continue
#print(memo[i-1],memo[i-2])
memo[i]=memo[i-2]+memo[i-1]
#print(memo)
print((memo[n]% 1000000007))
|
p03013
|
mod = 10 ** 9 + 7
n, m = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(m)]
dp = [0] * (n + 1)
dp[0] = 1
for i in range(1, n + 1):
if i not in A:
if i == 1:
dp[i] = dp[i - 1] % mod
else:
dp[i] = dp[i - 1] + dp[i - 2] % mod
print((dp[n] % mod))
|
mod = 10 ** 9 + 7
n, m = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(m)]
not_wet = [True] * (n + 1)
for a in A:
not_wet[a] = False
dp = [0] * (n + 1)
dp[0] = 1
for i in range(1, n + 1):
if not_wet[i]:
if i == 1:
dp[i] = dp[i - 1] % mod
else:
dp[i] = dp[i - 1] + dp[i - 2] % mod
print((dp[n] % mod))
|
p03013
|
from functools import lru_cache
import sys
sys.setrecursionlimit(1000000)
N, M = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(M)]
@lru_cache(1000000)
def dfs(pos):
if pos > N:
return 0
if pos == N:
return 1
if pos in A:
return 0
return dfs(pos + 2) + dfs(pos + 1)
print((dfs(0) % 1000000007))
|
from functools import lru_cache
import sys
sys.setrecursionlimit(1000000)
N, M = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(M)]
@lru_cache(None)
def dfs(pos):
if pos > N:
return 0
if pos == N:
return 1
if pos in A:
return 0
return dfs(pos + 2) + dfs(pos + 1)
for i in reversed(list(range(N))):
dfs(i)
print((dfs(0) % 1000000007))
|
p03013
|
# python 3.4.3
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N,M = list(map(int,input().split()))
A = list(int(eval(input())) for _ in range(M))
mod = 10**9+7
# dp[i] : i番目の階段までの場合の数
dp = [0]*(N+1)
dp[0] = 1
dp[1] = 1 if 1 not in A else 0
for i in range(2,N+1):
if i not in A:
dp[i] = dp[i-1] + dp[i-2]
dp[i] %= mod
print((dp[N]))
|
# python 3.4.3
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N,M = list(map(int,input().split()))
A = list(int(eval(input())) for _ in range(M))
mod = 10**9+7
# 床が壊れてる階段を高速に判別できるように
B = [True]*(N+1)
for a in A:
B[a] = False
# dp[i] : i番目の階段までの場合の数
dp = [0]*(N+1)
dp[0] = 1
dp[1] = 1 if 1 not in A else 0
for i in range(2,N+1):
if B[i]:
dp[i] = dp[i-1] + dp[i-2]
dp[i] %= mod
print((dp[N]))
|
p03013
|
import sys
input = sys.stdin.readline
mod = 1000000007
n, m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
ans = 0
dp = [0] * (n+1)
dp[0] = 1
for i in range(n):
dp[i] %= mod
if i in a:
continue
if i + 1 <= n:
dp[i+1] += dp[i]
if i + 2 <= n:
dp[i+2] += dp[i]
print((dp[n] % mod))
|
MOD = 10 ** 9 + 7
n, m = list(map(int, input().split()))
broken = [False] * (n + 1)
for i in range(m):
a = int(eval(input()))
broken[a] = True
dp = [0] * (n+1)
dp[0] = 1
for i in range(n):
dp[i] %= MOD
if broken[i]:
dp[i] = 0
if i + 1 <= n:
dp[i+1] += dp[i]
if i + 2 <= n:
dp[i+2] += dp[i]
print((dp[n] % MOD))
|
p03013
|
N,M = list(map(int,input().split()))
MOD = 10**9+7
dp = [0]*(N+1)
dp[0]=1
A = [int(eval(input())) for i in range(M)]
ban = [1]*(N+1)
for a in A:
ban[a]=0
for i in range(N):
if i-1>=0:
dp[i+1]=dp[i]*ban[i]+dp[i-1]*ban[i-1]
else:
dp[i+1]=dp[i]*ban[i]
dp[i+1] %= MOD
print((dp[N]))
|
N,M = list(map(int,input().split()))
A = [int(eval(input())) for i in range(M)]
MOD = 10**9+7
A = set(A)
dp = [0]*(N+1)
dp[0] = 1
for i in range(1,N+1):
if i in A:
continue
if i == 1:
dp[1] = dp[0]
else:
dp[i] = (dp[i-1]+dp[i-2])%MOD
print((dp[N]))
|
p03013
|
# input
N, M = list(map(int, input().split()))
a = []
a_append = a.append
for n in range(M):
a_append(int(eval(input())))
mod = 1000000007
# check
check = {}
for n in range(N + 1):
if n in a:
check[n] = False
else:
check[n] = True
dp = {0: 1}
if check[1] is True:
dp[1] = 1
else:
dp[1] = 0
for n in range(2, N + 1):
dp[n] = 0
if check[n - 1] is True:
dp[n] += dp[n - 1]
if check[n - 2] is True:
dp[n] += dp[n - 2]
dp[n] %= mod
print((dp[N]))
|
# input
N, M = list(map(int, input().split()))
a = []
a_append = a.append
for n in range(M):
a_append(int(eval(input())))
mod = 1000000007
# check
check = [True] * (N + 1)
for i in a:
check[i] = False
dp = {0: 1}
if check[1] is True:
dp[1] = 1
else:
dp[1] = 0
for n in range(2, N + 1):
dp[n] = 0
if check[n - 1] is True:
dp[n] += dp[n - 1]
if check[n - 2] is True:
dp[n] += dp[n - 2]
dp[n] %= mod
print((dp[N]))
|
p03013
|
import bisect
n,m = list(map(int,input().split()))
p = [0]*(n+1)
mod = 10**9+7
a = [int(eval(input())) for i in range(m)]
p[0]=1
for i in range(1,n+1):
k = bisect.bisect_left(a,i)
k2 = bisect.bisect_right(a,i)
if k == k2:
p[i] += p[i-1]
if i >= 2:
p[i] += p[i-2]
p[i] = p[i]%mod
#print(p)
print((p[-1]%mod))
|
import bisect
n,m = list(map(int,input().split()))
mod = 10**9+7
a = [int(eval(input())) for i in range(m)]
#dp[i]:i段目に来る場合の数
dp = [0]*(n+1)
dp[0]=1
for i in range(1,n+1):
k = bisect.bisect_left(a,i)
k2 = bisect.bisect_right(a,i)
if k == k2:
dp[i] += dp[i-1]
if i >= 2:
dp[i] += dp[i-2]
dp[i] = dp[i]%mod
print((dp[-1]%mod))
|
p03013
|
MOD = 10**9 + 7
N, M = list(map(int,input().split()))
A = []
for _ in range(M):
a = int(eval(input()))
A.append(a)
dp = [1] * (N+1)
if 1 in A: dp[1] = 0
for i in range(N-1):
if i+2 in A:
dp[i+2] = 0
else:
dp[i+2] = (dp[i] + dp[i+1]) % MOD
print((dp[N]))
|
MOD = 10**9 + 7
N, M = list(map(int,input().split()))
A = set()
for _ in range(M):
A.add(int(eval(input())))
dp = [1] * (N+1)
if 1 in A:
dp[1] = 0
for i in range(N-1):
if i+2 in A:
dp[i+2] = 0
else:
dp[i+2] = (dp[i] + dp[i+1]) % MOD
print((dp[N]))
|
p03013
|
N, M = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(M)]
nums = [0]*(N+1)
nums[0] = 1
if 1 not in a:
nums[1] = 1
for i in range(2, N+1):
if not i in a:
nums[i] = nums[i-1] + nums[i-2]
print((nums[N]%(1000000007)))
|
N, M = list(map(int, input().split()))
a = set([int(eval(input())) for _ in range(M)])
nums = [0]*(N+1)
nums[0] = 1
if 1 not in a:
nums[1] = 1
for i in range(2, N+1):
if not i in a:
nums[i] = nums[i-1] + nums[i-2]
print((nums[N]%(1000000007)))
|
p03013
|
def main():
N, M = list(map(int, input().split()))
A = []
for i in range(M):
A.append(int(eval(input())))
mod = 1000000007
dp = [0] * (N+1)
dp[0] = 1
for now in range(0, N):
for next in range(now+1, min(N, now+2)+1):
if next not in A:
dp[next] += dp[now]
#dp[next] %= mod
print((dp[N] % mod))
if __name__ == '__main__':
main()
|
def main():
N, M = list(map(int, input().split()))
A = set()
for i in range(M):
A.add(int(eval(input())))
mod = 1000000007
dp = [0] * (N+1)
dp[0] = 1
for now in range(0, N):
for next in range(now+1, min(N, now+2)+1):
if next not in A:
dp[next] += dp[now]
dp[next] %= mod
print((dp[N] % mod))
if __name__ == '__main__':
main()
|
p03013
|
n,m = list(map(int,input().split()))
stair = []
for i in range(m):
stair.append(int(eval(input())))
ans = [0]*(n+1)
ans[0] = 1
ans[1] = 1
for i in range(n+1):
if i in stair:
ans[i] = 0
else:
if i ==0 or i==1:
continue
else:
ans[i] = ans[i-2] + ans[i-1]
print((ans[n]%(10**9+7)))
|
n,m = list(map(int,input().split()))
ans = [1]*(n+1)
for i in range(m):
a = int(eval(input()))
ans[a] = 0
for i in range(2,n+1):
if ans[i]==0:
continue
else:
ans[i] = ans[i-2] + ans[i-1]
print((ans[n]%(10**9+7)))
|
p03013
|
n,m=list(map(int,input().split()))
a=[-1]
k=[1,1]
ansk=1
d=[]
renzoku=1
for i in range(m):
a.append(int(eval(input())))
if a[i+1]==a[i]+1:
renzoku=0
a.append(n+1)
for i in range(max(a)):
s=k[i+1]+k[i]
k.append(s)
for i in range(m+1):
d.append(a[i+1]-a[i]-1)
ansk*=k[d[i]-1]
if renzoku==1:
print((ansk%1000000007))
else:
print((0))
|
def Fib(n):
a=[0,1,1]
if n<=2:
return a[n]
else:
for i in range(n-2):
a.append(a[i+1]+a[i+2])
return a[n]
n,m=list(map(int,input().split()))
if m==0:
print((Fib(n+1)%(10**9+7)))
exit()
a=[]
for i in range(m):
a.append(int(eval(input())))
if a[0]!=1:
a.insert(0,-1)
if a[-1]!=n-1:
a.append(n+1)
b=[]
for i in range(len(a)-1):
b.append(a[i+1]-a[i]-1)
if a[i+1]-a[i]==1:
print((0))
exit()
ans=1
for i in range(len(b)):
ans*=Fib(b[i])
ans%=10**9+7
print(ans)
|
p03013
|
def Fib(n):
a=[0,1,1]
if n<=2:
return a[n]
else:
for i in range(n-2):
a.append(a[i+1]+a[i+2])
return a[n]
n,m=list(map(int,input().split()))
if m==0:
print((Fib(n+1)%(10**9+7)))
exit()
a=[]
for i in range(m):
a.append(int(eval(input())))
if a[0]!=1:
a.insert(0,-1)
if a[-1]!=n-1:
a.append(n+1)
b=[]
for i in range(len(a)-1):
b.append(a[i+1]-a[i]-1)
if a[i+1]-a[i]==1:
print((0))
exit()
ans=1
for i in range(len(b)):
ans*=Fib(b[i])
ans%=10**9+7
print(ans)
|
mod=10**9+7
n,m=list(map(int,input().split()))
a=[int(eval(input()))for _ in range(m)]
a.append(n+1)
fib=[1,1]
for i in range(n):
r=fib[-1]+fib[-2]
fib.append(r%mod)
ans=1
now=0
for x in a:
ans*=fib[x-1-now]
if x-1-now<0:
print((0))
exit()
ans%=mod
now=x+1
print(ans)
|
p03013
|
MOD = 10**9 + 7
N, M = list(map(int, input().split()))
As = [int(eval(input())) for _ in range(M)]
isBroken = [False] * (N+1)
for A in As:
isBroken[A] = True
dp = [0] * (N+1)
dp[0] = 1
for i in range(1, N+1):
if isBroken[i]: continue
if i > 1:
dp[i] += dp[i-2]
dp[i] += dp[i-1]
dp[i] %= MOD
print((dp[N]))
|
MOD = 10**9 + 7
N, M = list(map(int, input().split()))
setA = set([int(eval(input())) for _ in range(M)])
dp = [0] * (N+3)
dp[0] = 1
for i in range(N):
if i in setA: continue
dp[i] %= MOD
dp[i+1] += dp[i]
dp[i+2] += dp[i]
ans = dp[N] % MOD
print(ans)
|
p03013
|
Q = 1000000007
n, m = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(m)]
dp = {
0: 1,
1: 0 if 1 in a else 1
}
for k in range(2, n + 1):
dp[k] = (0 if k in a else dp[k - 1] + dp[k - 2]) % Q
print((dp[n]))
|
Q = 1000000007
n, m = list(map(int, input().split()))
a = set([int(eval(input())) for _ in range(m)])
dp = {
0: 1,
1: 0 if 1 in a else 1
}
for k in range(2, n + 1):
dp[k] = (0 if k in a else dp[k - 1] + dp[k - 2]) % Q
print((dp[n]))
|
p03013
|
n,m = list(map(int, input().split()))
DIV = 10**9+7
a = [0]*(n+1)
dp = [0]*(n+1)
dp[0] = 1
for _ in range(m):
broken = int(eval(input()))
a[broken] = 1
for i in range(1,n+1):
dp[i]=(dp[i-1]+dp[i-2]) % DIV
if a[i] == 1:
dp[i] = 0
print((dp[n]))
|
n, m = list(map(int, input().split()))
# 壊れた場所を集合で持っておく
a = {int(eval(input())) for _ in range(m)}
route = [0] * (n + 1)
# route[2]のために初期値は1とする
route[0] = 1
for i in range(1, n + 1):
# 壊れた場所でないなら、そこまでのルート数を計算
if not (i in a):
if i == 1:
route[i] = 1
else:
route[i] = (route[i - 1] + route[i - 2]) % (10 ** 9 + 7)
print((route[n]))
|
p03013
|
n, m = (int(i) for i in input().split())
a = [int(eval(input())) for i in range(m)]
def Fib(n):
a, b = 0, 1
if n == 1:
return a
elif n == 2:
return b
else:
for i in range(n-2):
a, b = b, a + b
return b
l = []
pre = -1
for x in a:
if x-pre == 1:
print((0))
exit()
l.append(Fib(x-pre-1 +1))
pre = x
l.append(Fib(n-pre +1))
res = 1
for x in l:
res *= x
print((res % 1000000007))
|
n, m = (int(i) for i in input().split())
a = [int(eval(input())) for i in range(m)]
def Fib(n1):
a1, b1 = 0, 1
if n1 == 1:
return a1
elif n1 == 2:
return b1
else:
for i in range(n1-2):
a1, b1 = b1, a1 + b1
return b1
l = []
pre = -1
for x in a:
if x-pre == 1:
print((0))
exit()
l.append(Fib(x-pre-1 +1))
pre = x
l.append(Fib(n-pre +1))
res = 1
for x in l:
res *= x
print((res % 1000000007))
|
p03013
|
N, M = list(map(int, input().split()))
a = [-10]
ans = -1
MOD = 10 ** 9 + 7
if N == 1:
ans = 1
else:
for i in range(M):
a += [int(eval(input()))]
if a[i + 1] - a[i] == 1:
ans = 0
break
if not ans in [0, 1]:
memo = [0] * (N + 1)
memo[0] = 1
if 1 in a:
memo[1] = 0
else:
memo[1] = 1
for i in range(N - 1):
if i + 2 in a:
continue
memo[i + 2] = memo[i] + memo[i + 1]
memo[i + 2] = memo[i + 2] % MOD
else:
ans = memo[i + 2]
print(ans)
|
N, M = list(map(int, input().split()))
a = []
ans = -1
MOD = 10 ** 9 + 7
if N == 1:
ans = 1
else:
if M > 0:
a += [int(eval(input()))]
for i in range(M - 1):
a += [int(eval(input()))]
if a[i + 1] - a[i] == 1:
ans = 0
break
a.append([-1])
if not ans in [0, 1]:
memo = [0] * (N + 1)
memo[0] = 1
memo[1] = 1
try:
if a[0] == 1:
a.pop(0)
memo[1] = 0
except:
pass
j = 0
for i in range(N - 1):
if i + 2 == a[j]:
j += 1
continue
memo[i + 2] = memo[i] + memo[i + 1]
memo[i + 2] = memo[i + 2] % MOD
else:
ans = memo[i + 2]
print(ans)
|
p03013
|
INF = (10 ** 9) + 7
N, M = list(map(int, input().split()))
aLst = set(int(eval(input())) for i in range(M))
ansLst = [0] * (N + 1)
ansLst[0] = 1
for i in range(1, N + 1):
if i in aLst:
continue
tmp = ansLst[i - 1]
if i > 1:
tmp += ansLst[i - 2]
ansLst[i] = tmp % INF
print((ansLst[N]))
|
INF = 10 ** 9 + 7
N, M = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(M)]
dp = [0] * (N + 1)
for i in range(M):
dp[a[i]] = -1
dp[0] = 1
for i in range(1, N + 1):
if dp[i] == -1: continue
tmp = 0
if dp[i - 1] != -1:
tmp += dp[i - 1]
if dp[i - 2] != -1 and i > 1:
tmp += dp[i - 2]
dp[i] = tmp % INF
print((dp[N]))
|
p03013
|
MOD=10**9+7
N,M=list(map(int,input().split()))
A=[0]*M
for i in range(M):
A[i]=(int(eval(input()))+1)
S=[0]*(N+2)
S[1]=1
for i in range(2,N+2):
if(i not in A):
S[i]=(S[i-1]+S[i-2])%MOD
else:
S[i]=0
print((S[N+1]))
|
MOD=10**9+7
N,M=list(map(int,input().split()))
A=[True]*(N+2)
for i in range(M):
a=(int(eval(input()))+1)
A[a]=False
S=[0]*(N+2)
S[1]=1
for i in range(2,N+2):
if(A[i]):
S[i]=(S[i-1]+S[i-2])%MOD
else:
S[i]=0
print((S[N+1]))
|
p03013
|
N, M = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(M)]
inf = float("inf")
dp = [inf] * (N+1)
dp[0] = 1
for i in range(1,N+1):
if i in A:
continue
if i == 1:
dp[i] = dp[0]
continue
a = dp[i-2] if dp[i-2] != inf else 0
b = dp[i-1] if dp[i-1] != inf else 0
dp[i] = (a + b) % 1000000007
print((dp[N]))
|
N, M = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(M)]
inf = float("inf")
dp = [0] * (N+1)
for i in A:
dp[i] = inf
dp[0] = 1
if dp[1] != inf:
dp[1] = 1
for i in range(2,N+1):
if dp[i] == inf:
continue
a = dp[i-2] if dp[i-2] != inf else 0
b = dp[i-1] if dp[i-1] != inf else 0
dp[i] = (a + b) % 1000000007
print((dp[N]))
|
p03013
|
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return eval(input())
def main():
N, M = LI()
A = []
for _ in range(M):
A.append(II())
A.append(INF)
dp = [0] * (N + 1)
dp[0] = 1
k = 0
if A[0] == 1:
dp[1] = 0
k = 1
else:
dp[1] = dp[0]
for i in range(2, N + 1):
if i == A[k]:
k += 1
dp[i] = 0
else:
dp[i] = (dp[i - 1] + dp[i - 2]) % MOD
ans = dp[N]
return ans
print((main()))
|
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return eval(input())
def main():
N, M = LI()
A = []
for _ in range(M):
A.append(II())
A.append(INF)
pre = 0
cur = 1
k = 0
for i in range(1, N + 1):
if i == A[k]:
k += 1
pre = cur
cur = 0
else:
tmp = cur
cur = (cur + pre) % MOD
pre = tmp
ans = cur
return ans
print((main()))
|
p03013
|
n,m = list(map(int,input().split()))
a = [int(eval(input())) for _ in range(m)]
mod = 10**9 + 7
dp = [0]*(n+1)
dp[0] = 1
for i in range(1,n+1):
if i in a:
continue
x = dp[i-1]
if i > 1:
x += dp[i-2]
dp[i] = x % mod
ans = dp[n]
print(ans)
|
n,m = list(map(int,input().split()))
a = {int(eval(input())) for _ in range(m)}
mod = 10**9 + 7
dp = [0]*(n+1)
dp[0] = 1
for i in range(1,n+1):
if i in a:
continue
x = dp[i-1]
if i > 1:
x += dp[i-2]
dp[i] = x % mod
ans = dp[n]
print(ans)
|
p03013
|
import bisect
def typical_stairs(N: int, M: int, A: list)->int:
MOD = 10**9 + 7
A.sort()
A.append(float('inf'))
dp = [0] * (N+1)
dp[0] = 1
for i in range(N):
if A[bisect.bisect_left(A, i+1)] == i+1:
dp[i+1] = 0
else:
dp[i+1] = dp[i]
if i > 0:
dp[i+1] += dp[i-1]
dp[i+1] %= MOD
# print(dp)
return dp[N]
if __name__ == "__main__":
M = 0
N, M = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(M)]
ans = typical_stairs(N, M, A)
print(ans)
|
def typical_stairs(N: int, M: int, A: list)->int:
MOD = 10**9 + 7
dp = [0] * (N+1)
dp[0] = 1
ai = 0
for i in range(N):
if ai < M and A[ai] == i+1:
dp[i+1] = 0
ai += 1
else:
dp[i+1] = dp[i]
if i > 0:
dp[i+1] += dp[i-1]
dp[i+1] %= MOD
# print(dp)
return dp[N]
if __name__ == "__main__":
M = 0
N, M = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(M)]
ans = typical_stairs(N, M, A)
print(ans)
|
p03013
|
N, M = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(M)]
MOD = 10**9 + 7
safe = [True] * (N+1)
for i in range(len(A)):
safe[A[i]] = False
dp = [0] * (N+1)
dp[0] = 1
if safe[1]:
dp[1] = 1
for i in range(2, N+1):
if(safe[i]):
dp[i] = dp[i-1] + dp[(i-2)]
dp[i] = dp[i] % MOD
else:
dp[i] = 0
print((dp[N]))
|
MOD = 10**9 + 7
N,M = list(map(int, input().split()))
a = [int(eval(input())) for _ in range(M)]
aa = [True] * (N+1)
for i in a:
aa[i] = False
dp = [0] * (N+1)
dp[0] = 1
if aa[1]:
dp[1] = 1
for i in range(2,N+1):
if (aa[i] == False):
dp[i] = 0
continue
dp[i] = dp[i-1] + dp[i-2]
dp[i] = dp[i] % MOD
print((dp[N]))
|
p03013
|
n,m = list(map(int,input().split()))
A = [int(eval(input())) for i in range(m)]
B = [0 for i in range(10**5+10)]
for i in range(len(A)):
B[A[i]] = 1
mod = 10**9 + 7
DP = [1,1]
if B[1] == 1:
DP[1] = 0
for i in range(2,n+1):
p1 = DP[i-2] % mod
p2 = DP[i-1] % mod
if B[i-2] == 1:
p1 = 0
if B[i-1] == 1:
p2 = 0
DP.append((p1+p2)%mod)
print((DP[n]))
|
n,m = list(map(int,input().split()))
A = [int(eval(input())) for i in range(m)]
B = [0 for i in range(10**5+10)]
for i in range(len(A)):
B[A[i]] = 1
mod = 10**9 + 7
DP = [1,1]
if B[1] == 1:
DP[1] = 0
for i in range(2,n+1):
if B[i] == 0:
DP.append((DP[i-1]+DP[i-2])%mod)
else:
DP.append(0)
if i >= 3:
DP[i-3]=0
print((DP[n]))
|
p03013
|
import sys
input = sys.stdin.readline
N, M = list(map(int,input().split()))
hole = [0] * (N+1)
for i in range(M):
hole[int(eval(input()))] = 1
if N == 1:
print((1))
exit()
if N == 2:
if hole[1] == 1:
print((1))
exit()
if hole[1] == 0:
print((2))
exit()
flg_one = False
flg_two = False
first = 1
second = 2
if hole[1] == 1:
first = 0
second = 1
flg_one = True
if hole[2] == 1:
first = 1
second = 0
flg_two = True
if flg_one and flg_two:
print((0))
exit()
for i in range(3,N):
if hole[i] == 1:
first = second
second = 0
continue
tmp = first + second
tmp %= 1000000007
first = second
second = tmp
tmp = first + second
tmp %= 1000000007
print(tmp)
|
MOD = 10**9 + 7
N, M = list(map(int, input().split()))
stairs = [0]*(N+1)
for _ in range(M):
stairs[int(eval(input()))] = 1
if N == 1:
print((1))
exit()
ans = [0]*(N+1)
ans[1] = 1 if stairs[1] == 0 else 0
ans[2] = 1 + ans[1] if stairs[2] == 0 else 0
for i in range(3,N+1):
if stairs[i] == 1:
ans[i] = 0
continue
ans[i] = (ans[i-1] + ans[i-2]) % MOD
print((ans[N]))
|
p03013
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.