input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n,a,b = list(map(int,input().split()))
mod = 1000000007
def modpow(a,n,m):
x = 1
while n:
if n%2: x *= a
a *= a
a %= m
n //= 2
return x
def nCr(n,r,m):
a = b = 1
for i in range(r):
a *= n - i
b *= r - i
a %= m
b %= m
return a * modpow(b, m-2, m) % m
ans = modpow(2,n,mod) - 1
ans -= nCr(n,a,mod)
ans -= nCr(n,b,mod)
ans %= mod
if ans<0: ans += mod
print(ans) | M = 10**9+7
n,a,b = list(map(int,input().split()))
def nCr(n,r,m):
a = b = 1
for i in range(r):
a = a * (n-i) % m
b = b * (r-i) % m
return a * pow(b, m-2, m) % m
ans = pow(2,n,M) - 1
ans -= nCr(n,a,M)
ans -= nCr(n,b,M)
ans %= M
if ans<0: ans += M
print(ans) | p02768 |
mod = 10**9+7
n,a,b = list(map(int,input().split()))
base = pow(2,n,mod)-1
def comb(n,k):
comb = 1
for i in range(n-k+1,n+1):
comb *= i
comb %= mod
for i in range(1, k+1):
comb *= pow(i,mod-2,mod)
comb %= mod
return comb
print(((base-comb(n,a)-comb(n,b))%mod)) | mod = 10**9+7
n,a,b = list(map(int,input().split()))
def comb(k):
m = 1
c = 1
for i in range(k):
m = m*(n-i)%mod
c = c*(i+1)%mod
return (m*pow(c,mod-2,mod)%mod)
print(((pow(2,n,mod)-1-comb(a)-comb(b))%mod)) | p02768 |
n, a, b = list(map(int, input().split()))
MOD = 10**9 + 7
def comb(n: int, k: int, MOD: int) -> int:
if n < k or n < 0 or k < 0:
return 0
k = min(k, n - k)
if k == 0:
return 1
iinv = [1] * (k + 1)
ans = n
for i in range(2, k + 1):
iinv[i] = MOD - iinv[MOD % i] * (MOD // i) % MOD
ans *= (n + 1 - i) * iinv[i] % MOD
ans %= MOD
return ans
ans = ((1 << n) - 1) % MOD
ans -= comb(n, a, MOD)
ans -= comb(n, b, MOD)
ans %= MOD
print(ans)
| n, a, b = list(map(int, input().split()))
MOD = 10**9 + 7
def comb(n: int, k: int, MOD: int) -> int:
if n < k or n < 0 or k < 0:
return 0
k = min(k, n - k)
if k == 0:
return 1
iinv = [1] * (k + 1)
ans = n
for i in range(2, k + 1):
iinv[i] = MOD - iinv[MOD % i] * (MOD // i) % MOD
ans *= (n + 1 - i) * iinv[i] % MOD
ans %= MOD
return ans
# ans = ((1 << n) - 1) % MOD
ans = (pow(2, n, MOD) - 1) % MOD
ans -= comb(n, a, MOD)
ans -= comb(n, b, MOD)
ans %= MOD
print(ans)
| p02768 |
def main():
#input data
import sys
input = lambda:sys.stdin.readline().strip()
N,A,B = list(map(int,input().split()))
mod=10**9+7
#solve
#二項係数の和=2**n
#2**n-1-nCa-nCb
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def cmb(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
ans = pow(2,N,mod)-1-cmb(N,A,mod)-cmb(N,B,mod)
print((ans%mod))
if __name__=='__main__':
main() | def main():
#input data
import sys
input = lambda:sys.stdin.readline().strip()
N,A,B = list(map(int,input().split()))
mod=10**9+7
#solve
#二項係数の和=2**n
#2**n-1-nCa-nCb
def cmb(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * pow(i+1, mod-2, mod) % mod
return res
ans = pow(2,N,mod)-1-cmb(N,A,mod)-cmb(N,B,mod)
print((ans%mod))
if __name__=='__main__':
main() | p02768 |
def main():
#input data
import sys
input = lambda:sys.stdin.readline().strip()
N,A,B = list(map(int,input().split()))
mod=10**9+7
#solve
#二項係数の和=2**n
#2**n-1-nCa-nCb
def cmb(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * pow(i+1, mod-2, mod) % mod
return res
ans = pow(2,N,mod)-1-cmb(N,A,mod)-cmb(N,B,mod)
print((ans%mod))
if __name__=='__main__':
main() | def main():
#input data
import sys
input = lambda:sys.stdin.readline().strip()
N,A,B = list(map(int,input().split()))
mod=10**9+7
#solve
#二項係数の和=2**n
#2**n-1-nCa-nCb
def cmb(n, r, mod=10**9+7):
c = 1
m = 1
r = min(n - r, r)
for i in range(r):
c = c * (n - i) % mod
m = m * (i + 1) % mod
return c * pow(m, mod - 2, mod) % mod
ans = pow(2,N,mod)-1-cmb(N,A,mod)-cmb(N,B,mod)
print((ans%mod))
if __name__=='__main__':
main() | p02768 |
n, a, b = list(map(int, input().split()))
mod = 10**9+7
def extgcd(a, b):
r = [1, 0, a]
w = [0, 1, b]
while w[2] != 1:
q = r[2]//w[2]
r2 = w
w2 = [r[0]-q*w[0], r[1]-q*w[1], r[2]-q*w[2]]
r = r2
w = w2
# [x,y]
return [w[0], w[1]]
def mod_inv(a, m):
x = extgcd(a, m)[0]
return (m+x % m) % m
def comb(n, r, mod):
u = 1
d = 1
for i in range(r):
u *= n-i
d *= i+1
if u >= mod:
u %= mod
if d >= mod:
d %= mod
return u*mod_inv(d, mod)
def binary(n):
return bin(n)[2:]
def pow_by_binary_exponentiation(a, x, n): # a^x mod n
x = [int(b) for b in binary(x)]
y = a
for i in range(1, len(x)):
y = (y**2) % n
if x[i] == 1:
y = (y * a) % n
return y
ac = comb(n, a, mod)
bc = comb(n, b, mod)
ans = pow_by_binary_exponentiation(2, n, mod)
print((((ans - ac - bc - 1) % mod)//1))
| n, a, b = list(map(int, input().split()))
mod = 10**9+7
def binary(n):
return bin(n)[2:]
# a^x mod n : ans = pow_by_binary_exponentiation(2, 1000, 10**9+7)
def pow_by_binary_exponentiation(a, x, n):
x = [int(b) for b in binary(x)]
y = a
for i in range(1, len(x)):
y = (y**2) % n
if x[i] == 1:
y = (y * a) % n
return y
def combination(n, r, mod=10**9+7):
n1, r = n+1, min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
ac = combination(n, a, mod)
bc = combination(n, b, mod)
ans = pow_by_binary_exponentiation(2, n, mod)
print((((ans - ac - bc - 1) % mod)//1))
| p02768 |
from functools import reduce
N, A, B = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def f(A):
num = reduce(lambda x, y: x * y % MOD, list(range(N, N - A, -1)))
den = reduce(lambda x, y: x * y % MOD, list(range(1, A + 1)))
return num * pow(den, MOD - 2, MOD) % MOD
answer = pow(2, N, MOD) - 1 - f(A) - f(B)
answer %= MOD
print(answer) | from functools import reduce
def combinations_count_mod(n, r, m):
num = reduce(lambda x, y: x * y % m, list(range(n, n - r, -1)))
den = reduce(lambda x, y: x * y % m, list(range(1, r + 1)))
return num * pow(den, m - 2, m) % m
N, A, B = list(map(int, input().split()))
MOD = 10 ** 9 + 7
answer = pow(2, N, MOD) - 1 - combinations_count_mod(N, A, MOD) - combinations_count_mod(N, B, MOD)
answer %= MOD
print(answer) | p02768 |
n,a,b=list(map(int,input().split()))
mod=10**9+7
def comb(n,r,mod):
p,q=1,1
for i in range(r):
p=p*(n-i)%mod
q=q*(i+1)%mod
return p*pow(q,mod-2,mod)%mod
nca=comb(n,a,mod)
ncb=comb(n,b,mod)
ans=pow(2,n,mod)
ans=(ans-((nca+ncb)%mod+1))%mod
print(ans) | n,a,b=list(map(int,input().split()))
mod=10**9+7
def comb(n,r,mod):
p,q=1,1
for i in range(min(r,n-r)):
p=p*(n-i)%mod
q=q*(i+1)%mod
return p*pow(q,mod-2,mod)%mod
nca=comb(n,a,mod)
ncb=comb(n,b,mod)
ans=pow(2,n,mod)
ans=(ans-((nca+ncb)%mod+1))%mod
print(ans) | p02768 |
def main():
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().split()))
ma = max(a, b)
tbl = [0] * (ma + 1)
# f = 1
# for i in range(1, ma + 1):
# f = (f * i) % mod
#
# invs = [1] * (ma + 1)
# invs[ma] = pow(f, mod - 2, mod)
# for x in range(ma - 1, 0, -1):
# invs[x] = invs[x + 1] * (x + 1) % mod
t = 1
for i in range(1, max(a, b) + 1):
t = (t * (n - i + 1) * pow(i, mod - 2, mod)) % mod
tbl[i] = t
ans = pow(2, n, mod) - 1 - tbl[a] - tbl[b]
print((ans % mod))
if __name__ == '__main__':
main()
| mod = 10 ** 9 + 7
n, a, b = list(map(int, input().split()))
def choose(n, a, mod=mod):
x, y = 1, 1
for i in range(a):
x = x * (n - i) % mod
y = y * (i + 1) % mod
return x * pow(y, mod - 2, mod)
ret = pow(2, n, mod)
ret -= 1
ret -= choose(n, a)
ret -= choose(n, b)
ret %= mod
print(ret)
| p02768 |
n,a,b=list(map(int,input().split()))
mod=(10**9)+7
ans=pow(2,n,mod)-1
comb=1
for i in range(n-a+1,n+1):
comb*=i
comb%=mod
for i in range(1,a+1):
comb*=pow(i,mod-2,mod)
comb%=mod
comb2=1
for i in range(n-b+1,n+1):
comb2*=i
comb2%=mod
for i in range(1,b+1):
comb2*=pow(i,mod-2,mod)
comb2%=mod
ans=ans-comb-comb2
ans%=mod
print(ans) | def main():
n,a,b=list(map(int,input().split()))
mod=(10**9)+7
ans=pow(2,n,mod)-1
comb=1
for i in range(n-a+1,n+1):
comb*=i
comb%=mod
for i in range(1,a+1):
comb*=pow(i,mod-2,mod)
comb%=mod
comb2=1
for i in range(n-b+1,n+1):
comb2*=i
comb2%=mod
for i in range(1,b+1):
comb2*=pow(i,mod-2,mod)
comb2%=mod
ans=ans-comb-comb2
ans%=mod
print(ans)
if __name__=="__main__":
main() | p02768 |
n,a,b = [int(x) for x in input().split()]
ans = 0
mod = 10**9+7
ans = (pow(2,n,mod)-1)%mod
com1 = 1
for i in range(n-a+1,n+1):
com1 = com1*i%mod
for i in range(1,a+1):
com1 = com1 * pow(i,mod-2,mod)%mod
com2 = 1
for i in range(n-b+1,n+1):
com2 = com2*i%mod
for i in range(1,b+1):
com2 = com2*pow(i,mod-2,mod)%mod
ans = (ans - com1 - com2)%mod
print(ans) | n,a,b = [int(x) for x in input().split()]
ans = 0
mod = 10**9+7
ans = (pow(2,n,mod)-1)%mod
com1 = 1
for i in range(n-a+1,n+1):
com1 = com1*i%mod
for i in range(1,a+1):
com1 = com1 * pow(i,mod-2,mod)%mod
com2 = 1
for i in range(n-b+1,n+1):
com2 = com2*i%mod
x = 1
for i in range(1,b+1):
x = x*i%mod
com2 = com2*pow(x,mod-2,mod)%mod
ans = (ans - com1 - com2)%mod
print(ans) | p02768 |
MOD = 1000000007
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
def __int__(self):
return self.x
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
def __truediv__(self, other):
return (
ModInt(
self.x * pow(other.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
def __mod__(self, other):
return (
ModInt(
other.x
) if isinstance(other, ModInt) else
other
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, MOD - 2, MOD))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
def __iadd__(self,other):
self.x += other.x if isinstance(other, ModInt) else other
self.x %= MOD
return self
def __isub__(self,other):
self.x += ModInt(MOD - other.x) if isinstance(other, ModInt) else ModInt(MOD - other)
return self
def __imul__(self, other):
self.x *= other.x if isinstance(other, ModInt) else other
self.x %= MOD
return self
def factorical(self,n):
tmp = ModInt(1)
for i in range(n):
tmp *= (i+1)
return tmp
#m:int MOD
def modinv(self,a,m=MOD):
b = m
u = 1
v = 0
while(b):
t = a//b
a -= t * b
a,b = b,a
u -= t * v
u,v = v,u
return ModInt(u)
def comb(self,n,r):
n = int(n)
r = int(r)
if r > n or n < 0 or r < 0:
return 0
m = n+1
nterms = min(r, n-r)
numerator = ModInt(1)
denominator = ModInt(1)
for j in range(1, nterms + 1):
numerator *= m - j
denominator *= j
return numerator * self.modinv(denominator.x)
if __name__ == "__main__":
n,a,b = list(map(int,input().split()))
c = ModInt(2)
c = c ** n
ans = ModInt(int(c-1))
ans -= ans.comb(n,a)
ans -= ans.comb(n,b)
print(ans) | MOD = 1000000007
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
def __int__(self):
return self.x
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
def __truediv__(self, other):
return (
ModInt(
self.x * pow(other.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
def __mod__(self, other):
return (
ModInt(
other.x
) if isinstance(other, ModInt) else
self.x
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, MOD - 2, MOD))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
def __iadd__(self,other):
self.x += other.x if isinstance(other, ModInt) else other
self.x %= MOD
return self
def __isub__(self,other):
self.x += ModInt(MOD - other.x) if isinstance(other, ModInt) else ModInt(MOD - other)
return self
def __imul__(self, other):
self.x *= other.x if isinstance(other, ModInt) else other
self.x %= MOD
return self
def factorical(self,n):
tmp = ModInt(1)
for i in range(n):
tmp *= (i+1)
return tmp
#m:int MOD
def modinv(self,a,m=MOD):
b = m
u = 1
v = 0
while(b):
t = a//b
a -= t * b
a,b = b,a
u -= t * v
u,v = v,u
return ModInt(u)
def comb(self,n,r):
n = int(n)
r = int(r)
if r > n or n < 0 or r < 0:
return 0
m = n+1
nterms = min(r, n-r)
numerator = ModInt(1)
denominator = ModInt(1)
for j in range(1, nterms + 1):
numerator *= m - j
denominator *= j
return numerator * self.modinv(denominator.x)
if __name__ == "__main__":
n,a,b = list(map(int,input().split()))
c = ModInt(2)
c = c ** n
ans = ModInt(c-1)
ans -= ans.comb(n,a)
ans -= ans.comb(n,b)
print(ans) | p02768 |
n,a,b = list(map(int,input().split()))
m = 10**9 + 7
comb_a = 1
comb_b = 1
a_num = list(range(1,a+1))
j = 0
for i in range(1,a+1):
comb_a *= (n-i+1)
comb_a *= pow(a_num[i-1],m-2,m)
comb_a = comb_a % m
b_num = list(range(1,b+1))
j = 0
for i in range(1,b+1):
comb_b *= (n-i+1)
comb_b *= pow(b_num[i-1],m-2,m)
comb_b = comb_b % m
ans = pow(2,n,m) - comb_a - comb_b - 1
print((int(ans) % m)) | def comb_mod(n,r,m):
ans = 1
for i in range(1,r+1):
ans *= (n-i+1) % m
ans *= pow(i,m-2,m) % m
ans = ans % m
return ans
n,a,b = list(map(int,input().split()))
m = 10**9 + 7
ans = pow(2,n,m) - comb_mod(n,a,m) - comb_mod(n,b,m) - 1
print((int(ans) % m)) | p02768 |
def modpow(a,n,mod=10**9+7):
res=1
while n>0:
if n&1:
res=res*a%mod
a=a*a%mod
n>>=1
return res%mod
def modcmb(n,r,mod=10**9+7):
res=1
div=min(r,n-r)
for i in range(div):
res=res*(n-i)*modpow(div-i,mod-2)%mod
return res%mod
n,a,b=[int(i) for i in input().split()]
ans=modpow(2,n)-1
ans-=modcmb(n,a)
ans%=10**9+7
ans-=modcmb(n,b)
ans%=10**9+7
print(ans) | def modcmb(n,r,mod=10**9+7):
res=1
div=min(r,n-r)
for i in range(div):
res=res*(n-i)*pow(div-i,mod-2,mod)%mod
return res%mod
n,a,b=[int(i) for i in input().split()]
mod=10**9+7
ans=pow(2,n,mod)-1
ans-=modcmb(n,a)
ans%=mod
ans-=modcmb(n,b)
ans%=mod
print(ans) | p02768 |
n, a, b = list(map(int,input().split()))
MOD = 10**9 + 7
ans = pow(2,n,MOD)-1
def cmb(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])
result %= MOD
return result
ans -= (cmb(n,a) + cmb(n,b))
print((ans%MOD))
| MOD = 10**9 + 7
def nCr(n, r, MOD):
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])
result %= MOD
return result
n, a, b = list(map(int,input().split()))
ans = pow(2,n,MOD)-1-nCr(n,a,MOD)-nCr(n,b,MOD)
while ans < 0:
ans += MOD
print(ans)
| p02768 |
n,a,b = list(map(int,input().split()))
mod = 10 ** 9 + 7
# 乗法のmod逆元 (mod-2乗)
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
# nCr mod m
# modinvが必要
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
ans = pow(2, n, mod)
ans -= combination(n,a) + combination(n,b) + 1
print((ans % mod))
| n,a,b = list(map(int,input().split()))
mod = 10 ** 9 + 7
# 乗法のmod逆元 (mod-2乗)
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
# nCr mod m
# modinvが必要
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
r = min(r, n-r)
x = 1
y = 1
for i in range(r):
x *= (n - i)
y *= (i + 1)
x %= mod
y %= mod
return (x * modinv(y, mod)) % mod
ans = pow(2, n, mod)
ans -= combination(n,a) + combination(n,b) + 1
print((ans % mod))
| p02768 |
mod = 10**9 +7
n, a, b = list(map(int, input().split()))
nb = str(bin(n))[2:]
nblis = []
for k in range(len(nb)):
if nb[-k-1] == '1':
nblis.append(k)
two = [2]
for k in range(len(nb)-1):
two.append(two[-1]*two[-1]%mod)
ans = 1
for item in nblis:
ans = ans * two[item] %mod
bi = str(bin(mod-2))[2:]
blis = []
for k in range(len(bi)):
if bi[-k-1] == '1':
blis.append(k)
def modinv(N):
if N == 1:
return 1
else:
res = 1
li = []
for _ in range(len(bi)):
li.append(N%mod)
N = N*N%mod
for item in blis:
res = res * li[item] %mod
return res
ans_a = 1
for k in range(n-a+1, n+1):
ans_a = ans_a*k%mod
for k in range(2, a+1):
ans_a = ans_a*modinv(k)%mod
ans_b = 1
for k in range(n-b+1, n+1):
ans_b = ans_b*k%mod
for k in range(2, b+1):
ans_b = ans_b*modinv(k)%mod
print(((ans-ans_a-ans_b-1)%mod)) | mod = 10**9 +7
n, a, b = list(map(int, input().split()))
nb = str(bin(n))[2:]
nblis = []
for k in range(len(nb)):
if nb[-k-1] == '1':
nblis.append(k)
two = [2]
for k in range(len(nb)-1):
two.append(two[-1]*two[-1]%mod)
ans = 1
for item in nblis:
ans = ans * two[item] %mod
bi = str(bin(mod-2))[2:]
blis = []
for k in range(len(bi)):
if bi[-k-1] == '1':
blis.append(k)
def modinv(N):
if N == 1:
return 1
else:
res = 1
li = []
for _ in range(len(bi)):
li.append(N%mod)
N = N*N%mod
for item in blis:
res = res * li[item] %mod
return res
ans_a = 1
for k in range(n-a+1, n+1):
ans_a = ans_a*k%mod
amother = 1
for k in range(2, a+1):
amother = amother * k % mod
ans_a = ans_a*modinv(amother)%mod
ans_b = 1
for k in range(n-b+1, n+1):
ans_b = ans_b*k%mod
bmother = 1
for k in range(2, b+1):
bmother = bmother * k % mod
ans_b = ans_b*modinv(bmother)%mod
print(((ans-ans_a-ans_b-1)%mod)) | p02768 |
MOD = 10**9 + 7
n, a, b = list(map(int, input().split()))
def comb(n, k):
x, y = 1, 1
for i in range(n, n-k, -1):
x = x * i % MOD
for i in range(2, k+1):
y = y * pow(i, MOD-2, MOD) % MOD
return x*y % MOD
ans = (pow(2, n, MOD)-1-comb(n,a)-comb(n,b)) % MOD
print(ans) | from functools import reduce
MOD = 10**9 + 7
n, a, b = list(map(int, input().split()))
def comb(n, k):
def mul(a, b):
return a*b%MOD
x = reduce(mul, list(range(n, n-k, -1)))
y = reduce(mul, list(range(1, k+1)))
return x*pow(y, MOD-2, MOD) % MOD
ans = (pow(2, n, MOD)-1-comb(n,a)-comb(n,b)) % MOD
print(ans) | p02768 |
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def MI(): return map(int, input().split())
def S(): return input()
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def show(*inp, end='\n'):
if show_flg:
print(*inp, end=end)
YNL = {False: 'No', True: 'Yes'}
YNU = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
# sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
# show_flg = True
show_flg = False
def f(n):
r = (n - 2)
m = (4 * (1 - pow(2, r, MOD))) // (1 - 2)
return (3 + m) % MOD
def modinv(a):
return pow(a, MOD-2, MOD)
def cmb(n, r):
p = 1
c = 1
for i in range(r):
p *= (n - i)
c *= (i + 1)
p = p % MOD
c = c % MOD
return p * modinv(c) % MOD
def main():
n, a, b = MI()
first = cmb(n, a)
second = cmb(n, b)
ans = f(n)
print((ans - first - second) % MOD)
if __name__ == '__main__':
main()
| from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def MI(): return map(int, input().split())
def S(): return input()
def MS(): return map(str, input().split())
def LI(): return [int(i) for i in input().split()]
def LI_(): return [int(i)-1 for i in input().split()]
def StoI(): return [ord(i)-97 for i in input()]
def ItoS(nn): return chr(nn+97)
def input(): return sys.stdin.readline().rstrip()
def show(*inp, end='\n'):
if show_flg:
print(*inp, end=end)
YNL = {False: 'No', True: 'Yes'}
YNU = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
# sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
# show_flg = True
show_flg = False
def modinv(a):
return pow(a, MOD-2, MOD)
def cmb(n, r):
p = 1
c = 1
for i in range(r):
p *= (n - i)
c *= (i + 1)
p = p % MOD
c = c % MOD
return p * modinv(c) % MOD
def main():
n, a, b = MI()
first = cmb(n, a)
second = cmb(n, b)
ans = pow(2, n, MOD) - 1
print((ans - first - second) % MOD)
if __name__ == '__main__':
main()
| p02768 |
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
mod = 10**9+7
n,a,b = list(map(int, input().split()))
def comb(n, k):
c = 1
for i in range(n - k + 1, n + 1):
c *= i
c %= mod
for i in range(1, k + 1):
c *= pow(i, mod - 2, mod)
c %= mod
return c
ans = pow(2, n, mod) - 1 - comb(n, a) - comb(n, b)
print((ans % mod))
| import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
mod = 10**9+7
n,a,b = list(map(int, input().split()))
# def comb(n, k):
# c = 1
# for i in range(n - k + 1, n + 1):
# c *= i
# c %= mod
#
# for i in range(1, k + 1):
# c *= pow(i, mod - 2, mod)
# c %= mod
#
# return c
def comb(n, k):
c = 1
for i in range(k):
c *= n - i
c %= mod
d = 1
for i in range(1, k + 1):
d *= i
d %= mod
return (c * pow(d, mod - 2, mod)) % mod
ans = pow(2, n, mod) - 1 - comb(n, a) - comb(n, b)
print((ans % mod))
| p02768 |
n,a,b=list(map(int,input().split()))
m=10**9+7
def c(x,r=1):
for i in range(x):r=r*(n-i)*pow(i+1,m-2,m)%m
return r
print(((pow(2,n,m)-1-c(a)-c(b))%m)) | n,a,b=list(map(int,input().split()))
m=10**9+7
s=r=1
for i in range(b):
r=r*(n-i)*pow(i+1,m-2,m)%m
if i+1in[a,b]:s+=r
print(((pow(2,n,m)-s)%m)) | p02768 |
def get_exp_mod(base, exp, mod):
exp_bin = str(format(exp, 'b')) # ２進表現
res = 1
for i in range(len(exp_bin)):
if exp_bin[-i - 1] == '1':
res = res * base % mod
base = base * base % mod # base^2^nをmodで割ったあまり
return res
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().split()))
## TODO:0の時
# 2^n -1のmodを求める
all_case = (get_exp_mod(2, n, mod) - 1) % mod
#print(all_case)
# nCa modを求める
case_a = 1
for i in range(a):
case_a = case_a * (n - i) % mod
case_a = case_a * get_exp_mod(i+1, mod-2, mod) % mod
#print(case_a)
case_b = 1
for i in range(b):
case_b = case_b * (n - i) % mod
case_b = case_b * get_exp_mod(i+1, mod-2, mod) % mod
#print(case_b)
print(((all_case - case_a - case_b) % mod))
| def get_exp_mod(base, exp, mod):
exp_bin = str(format(exp, 'b')) # ２進表現
res = 1
for i in range(len(exp_bin)):
if exp_bin[-i - 1] == '1':
res = res * base % mod
base = base * base % mod # base^2^nをmodで割ったあまり
return res
def comb(n, r, mod):
X = 1
Y = 1
for i in range(r):
X = X * (n - i) % mod
Y = Y * (i + 1) % mod
return X * get_exp_mod(Y, mod - 2, mod) % mod
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().split()))
# 2^n -1のmodを求める
all_case = (get_exp_mod(2, n, mod) - 1) % mod
# nCa modを引く
print(((all_case - comb(n, a, mod) - comb(n, b, mod)) % mod))
| p02768 |
from functools import reduce
def comb(n, k, p):
a = reduce(lambda x,y: x*y%p, list(range(n,n-k,-1)))
b = reduce(lambda x,y: x*y%p, list(range(1,k+1)))
return (a*pow(b, p-2, p))%p
n, a, b = list(map(int, input().split()))
MOD = 10**9 + 7
print(((pow(2,n,MOD) - 1 - comb(n, a, MOD) - comb(n, b, MOD))%MOD)) | from functools import reduce
def perm(n, k, p):
ret = 1
for i in range(n, n-k, -1):
ret = (ret * i)%p
return ret
def comb(n, k, p):
"""power_funcを用いて(nCk) mod p を求める"""
a = perm(n, k, p)
b = perm(k, k, p)
return (a*pow(b, p-2, p))%p
n, a, b = list(map(int, input().split()))
MOD = 10**9 + 7
print(((pow(2,n,MOD) - 1 - comb(n, a, MOD) - comb(n, b, MOD))%MOD)) | p02768 |
n,a,b=list(map(int,input().split()))
mod=pow(10,9)+7
def pow_speed(x,n,mod):
res = 1
while n > 0:
if n & 1 == 1:
res *= x
x *= x
x%=mod
n >>= 1
return res
def comb(n,x):
rec=1
for i in range(n-x+1,n+1):
rec=rec*i%mod
rec2=1
for i in range(1,x+1):
rec2=rec2*i%mod
rec2=pow_speed(rec2,mod-2,mod)
return rec*rec2
print(((pow_speed(2,n,mod)-comb(n,a)-comb(n,b)-1)%mod)) | n,a,b=list(map(int,input().split()))
mod=10**9+7
#modあり
def pow_speed(x,n):
res = 1
while n > 0:
if n & 1 == 1:
res *= x
x *= x
x%=mod
n >>= 1
return res
#nCx(mod)
def comb_speed(n,x):
rec=1
for i in range(n-x+1,n+1):
rec=rec*i%mod
rec2=1
for i in range(1,x+1):
rec2=rec2*i%mod
rec2=pow_speed(rec2,mod-2)
return (rec*rec2)%mod
print(((pow_speed(2,n)-comb_speed(n,a)-comb_speed(n,b)-1)%mod)) | p02768 |
n,a,b = list(map(int,input().split()))
mod = 10**9+7
ans = pow(2,n,mod)-1
comb1 = 1
for i in range(n-a+1, n+1):
comb1 *= i
comb1 %= mod
for i in range(1, a+1):
comb1 *= pow(i, mod-2, mod)
comb1 %= mod
comb2 = 1
for i in range(n-b+1, n+1):
comb2 *= i
comb2 %= mod
for i in range(1, b+1):
comb2 *= pow(i, mod-2, mod)
comb2 %= mod
ans -= (comb1 + comb2)
print((ans % mod)) | def comb(n,k):
nCk = 1
mod = 10**9+7
for i in range(n-k+1, n+1):
nCk *= i
nCk %= mod
for i in range(1, k+1):
nCk *= pow(i, mod-2, mod)
nCk %= mod
return nCk
n,a,b = list(map(int,input().split()))
mod = 10**9+7
print(((pow(2,n,mod) - 1 - comb(n,a) - comb(n,b))%mod))
| p02768 |
n,a,b = list(map(int,input().split()))
mod = 10**9+7
a = min(a,n-a)
b = min(b,n-b)
m = max(a,b)
X = [0]*(m+1)
Y = [0]*(m+1)
X[0] = 1
X[1] = n
Y[0] = Y[1] = 1
for i in range(2,m+1):
X[i] = X[i-1]*(n-i+1)%mod
Y[i] = Y[i-1]*i%mod
ans = (((pow(2,n,mod)-1)%mod-X[a]*pow(Y[a],mod-2,mod)%mod)%mod-X[b]*pow(Y[b],mod-2,mod)%mod)%mod
print(ans) | n,a,b = list(map(int,input().split()))
mod = 10**9+7
def combmod(n,k,mod):
x = y = 1
for i in range(min(k,n-k)):
x = x*(n-i)%mod
y = y*(i+1)%mod
return x * pow(y, mod-2, mod) % mod
ans = (((pow(2, n, mod) - 1)%mod - combmod(n, a, mod))%mod - combmod(n, b, mod))%mod
print(ans) | p02768 |
n,a,b = [int(i) for i in input().split()]
mod = 10**9+7
def mpow(a,n):
if n == 1:
return a
x = mpow(a,n//2)
ans = x*x%mod
if n%2==1:
ans *= a
return ans
def comb(n,a,b):
if a < b:
s, l = a, b
else:
s, l = b, a
rs = 1
for i in range(s):
rs = rs*(n-i)%mod
rl = rs
for i in range(s,l):
rl = rl*(n-i)%mod
L = 1
for i in range(1,s+1):
L = L*mpow(i,mod-2)%mod
rs = rs*L%mod
rl = rl*L%mod
for i in range(s+1,l+1):
rl = rl*mpow(i,mod-2)%mod
if a < b:
nCa, nCb = rs, rl
else:
nCa, nCb = rl, rs
return nCa, nCb
nCa,nCb = comb(n,a,b)
print(((mpow(2,n)-1-nCa-nCb)%mod))
# print(nCa,nCb) | import math
n,a,b = [int(i) for i in input().split()]
mod = 10**9+7
def comb(n,k):
ans = 1
for i in range(k):
ans = ans*(n-i)%mod
for i in range(1,k+1):
ans = ans*pow(i,mod-2,mod)%mod
return ans
print(((pow(2,n,mod)-1-comb(n,a)-comb(n,b))%mod))
# print(comb(n,a))
| p02768 |
n,a,b = [int(i) for i in input().split()]
mod = 10**9+7
def mpow(a,n):
if n == 1:
return a
x = mpow(a,n//2)
ans = x*x%mod
if n%2==1:
ans *= a
return ans
def comb(n,a,b):
if a < b:
s, l = a, b
else:
s, l = b, a
rs = 1
for i in range(s):
rs = rs*(n-i)%mod
rl = rs
for i in range(s,l):
rl = rl*(n-i)%mod
L = 1
for i in range(1,s+1):
L = L*mpow(i,mod-2)%mod
rs = rs*L%mod
rl = rl*L%mod
for i in range(s+1,l+1):
rl = rl*mpow(i,mod-2)%mod
if a < b:
nCa, nCb = rs, rl
else:
nCa, nCb = rl, rs
return nCa, nCb
nCa,nCb = comb(n,a,b)
print(((mpow(2,n)-1-nCa-nCb)%mod))
# print(nCa,nCb)
| def comb_mod(n,r):
mod = 10**9+7
ans = 1
for i in range(r):
ans *= n-i
ans %= mod
for i in range(1,r+1):
ans *= pow(i,mod-2,mod)
ans %= mod
return ans
def solve():
n, a, b = list(map(int, input().split()))
mod = 10**9+7
ans = pow(2,n,mod)-comb_mod(n,a)-comb_mod(n,b)-1
ans %= mod
return ans
print((solve())) | p02768 |
def comb_mod(n,r):
mod = 10**9+7
ans = 1
for i in range(r):
ans *= n-i
ans %= mod
for i in range(1,r+1):
ans *= pow(i,mod-2,mod)
ans %= mod
return ans
def solve():
n, a, b = list(map(int, input().split()))
mod = 10**9+7
ans = pow(2,n,mod)-comb_mod(n,a)-comb_mod(n,b)-1
ans %= mod
return ans
print((solve()))
| def comb_mod(n,r):
mod = 10**9+7
ans = 1
for i in range(r):
ans *= n-i
ans %= mod
for i in range(1,r+1):
ans *= pow(i,-1,mod)
ans %= mod
return ans
def solve():
n, a, b = list(map(int, input().split()))
mod = 10**9+7
ans = pow(2,n,mod)-comb_mod(n,a)-comb_mod(n,b)-1
ans %= mod
return ans
print((solve())) | p02768 |
import math
N ,a,b= list(map(int,input().split(' ')))
M = 10**9+7
def pow(x,n):
if n==0:
return 1
res = pow((x*x)%M,n//2)
if (n%2)==1:
res = (res*x)%M
return res
def power(x,n):
res = 1
if(n>0):
res = power(x,n//2)
if (n%2)==0:
res = (res*res)%M
else:
res = (((res*res)%M)*x)%M
return res
def comb(n,a):
ans = 1
for i in range(a):
ans = (ans*(n-i))%M
ans = (ans*power(i+1,M-2))%M
return ans
#print(pow(10,2))
#print(power(5,8))
print(((power(2,N)-1-comb(N,a)-comb(N,b))%M)) | N ,a,b= list(map(int,input().split(' ')))
M = 10**9+7
def pow(x,n):
if n==0:
return 1
res = pow((x*x)%M,n//2)
if (n%2)==1:
res = (res*x)%M
return res
def power(x,n):
res = 1
if(n>0):
res = power(x,n//2)
if (n%2)==0:
res = (res*res)%M
else:
res = (((res*res)%M)*x)%M
return res
def comb(n,a):
ans = 1
for i in range(a):
ans = (ans*(n-i))%M
ans = (ans*power(i+1,M-2))%M
return ans
#print(pow(10,2))
#print(power(5,8))
print(((power(2,N)-1-comb(N,a)-comb(N,b))%M)) | p02768 |
n,a,b = list(map(int,input().split()))
mod = 10**9+7
total = pow(2,n,mod) - 1 # 制約なしの全パターン_n**2-1※'-1'は0本の花束
# n個からr個を選択した時のパターン総数
# n! / (r! * (n-r)!) → nが大き過ぎて出来ない →変形→ n*(n-1)*･･･(n-r+1) ↓関数化
def nCr(n, r, mod):
numerator=1 #分子
for i in range(n-r+1, n+1):
numerator = (numerator*i) % mod
denominator=1 #分母
for j in range(1,r+1):
denominator = (denominator*j) % mod
# 割るとよくない → 逆元を掛ける
# フェルマーの小定理_modが素数なら1/aの逆元は a**(mod-2)
return (numerator * pow(denominator,mod-2,mod)) % mod
ans = (total - nCr(n,a,mod) - nCr(n,b,mod)) % mod
print(ans) | n,a,b = list(map(int,input().split()))
mod = 10**9+7
total = pow(2,n,mod) - 1 # 制約なしの全パターン_n**2-1※'-1'は0本の花束
# n個からr個を選択した時のパターン総数_組み合わせ重複なし
# n! / (r! * (n-r)!) → nが大き過ぎて出来ない →変形→ n*(n-1)*･･･(n-r+1)/r! ↓関数化
def nCr(n, r, mod):
numerator=1 #分子_n*(n-1)*･･･(n-r+1)
for i in range(n-r+1, n+1):
numerator = (numerator*i) % mod
denominator=1 #分母_r!
for j in range(1,r+1):
denominator = (denominator*j) % mod
# 剰余の計算において割るとよくない → 割るのではなく逆元を掛ける
# フェルマーの小定理_pが素数なら整数aのmod pにおける逆元は a**(p-2) ※aとpは互いに素
return (numerator * pow(denominator,mod-2,mod)) % mod
ans = (total - nCr(n,a,mod) - nCr(n,b,mod)) % mod
print(ans) | p02768 |
# coding: utf-8
n,a_,b_=list(map(int,input().split()))
l=[min(a_,n-a_),min(b_,n-b_)]
a,b=min(l),max(l)
mod=10**9+7
def pow_k(x,n):
k=1
#kは漏れたやつ
while n>1:
if n%2==1:
k*=x
n-=1
k=k%mod
x**=2
x=x%mod
n//=2
return (k * x) % mod
#ans=pow_k(2,1000000000)
def modcomb(n,r,mod):
X, Y = 1, 1
r = min(r, n-r)
for i in range(1,r+1):
X = X * (n-i+1) % mod
Y = Y * i % mod
return (X * pow_k(Y, mod-2) % mod) % mod
ans=pow_k(2,n)-1-modcomb(n,a,mod)-modcomb(n,b,mod)
print((ans%mod)) | # coding: utf-8
n,a_,b_=list(map(int,input().split()))
l=[min(a_,n-a_),min(b_,n-b_)]
a,b=min(l),max(l)
mod=10**9+7
def pow_k(x,n):#いらない
k=1
#kは漏れたやつ
while n>1:
if n%2==1:
k*=x
n-=1
k=k%mod
x**=2
x=x%mod
n//=2
return (k * x) % mod
#ans=pow_k(2,1000000000)
def modcomb(n,r,mod):
X, Y = 1, 1
r = min(r, n-r)
for i in range(1,r+1):
X = X * (n-i+1) % mod
Y = Y * i % mod
return X * pow(Y,mod-2,mod) % mod
ans=pow(2,n,mod)-1-modcomb(n,a,mod)-modcomb(n,b,mod)
print((ans%mod)) | p02768 |
n,a,b=list(map(int,input().split()))
mod=10**9+7
def pow2(n,base):
if n==1:return base
if n%2==0:return pow2(n//2,base)**2%mod
else:return base*pow2(n//2,base)**2%mod
def fac(n,a):
ans=1
for i in range(n,n-a,-1):
ans*=i
ans%=mod
return ans
def inv_fac(n):
ans=1
for i in range(1,n+1):
ans*=pow2(mod-2,i)
ans%=mod
return ans
ans=pow2(n,2)-fac(n,a)*inv_fac(a)-fac(n,b)*inv_fac(b)
print((ans%mod-1)) | n,a,b=list(map(int,input().split()))
mod=10**9+7
def fac(n,a):
ans=1
for i in range(n,n-a,-1):
ans*=i
ans%=mod
return ans%mod
def inv_fac(n):
ans=pow(fac(n,n-1),mod-2,mod)
return ans%mod
ans=pow(2,n,mod)-fac(n,a)*inv_fac(a)-fac(n,b)*inv_fac(b)
print((ans%mod-1)) | p02768 |
n, a, b = list(map(int, input().split()))
mod = 10 ** 9 + 7
N = min(n, 2 * 10**5)
fac = [1, 1]
finv = [1, 1]
inv = [0, 1]
def comb(n, r):
return fac[n] * ( finv[r] * finv[n-r] % mod ) % mod
for i in range(2, N + 1):
fac.append( ( fac[-1] * i ) % mod )
inv.append( mod - ( inv[mod % i] * (mod // i) % mod ) )
finv.append( finv[-1] * inv[-1] % mod )
def frac_rev(n, r):
x = 1
for i in range(n, n-r, -1):
x = x * i % mod
return x
if n <= 2 * 10**5:
print((( pow(2, n, mod) - 1 - comb(n, a) -comb(n, b) ) % mod))
else:
print((( pow(2, n, mod) - 1 - frac_rev(n, a) * finv[a] % mod - frac_rev(n, b) * finv[b] % mod) % mod)) | n, a, b = list(map(int, input().split()))
mod = 10 ** 9 + 7
def frac_rev(n, r):
x = 1
for i in range(n, n-r, -1):
x = x * i % mod
return x
def frac(n):
x = 1
for i in range(1, n+1):
x = x * i % mod
return x
print((( pow(2, n, mod) - 1 - frac_rev(n, a) * pow(frac(a), mod-2, mod) % mod - frac_rev(n, b) * pow(frac(b), mod-2, mod) % mod) % mod)) | p02768 |
# refer to https://qiita.com/k_karen/items/653ba7025a92f5ac1363
# ONE = '1'.freeze
MOD = (10**9) + 7
# def inv(x)
# res = 1 # 最終的に x^(MOD-2) になる変数です
# beki = x # x^2^n を格納する変数です
# # MOD-2の２進数展開を下位のbitから見ていきます。
# (MOD - 2).to_s(2).reverse.chars do |digest|
# # bitが立っている <=> digest == ONE
# # なら resにbekiを掛けます。
# # ここで、掛け算は計算の都度MODを取れます
# res = (beki * res) % MOD if digest == ONE
# # 次のループに備えて、自乗を計算します。
# # 計算の都度MODを取れます(とても大事なので二回言います)
# beki = (beki * beki) % MOD
# end
# res
# end
# def fact(s, e)
# (s..e).reduce(1) { |r, i| (r * i) % MOD }
# end
# def nCk(n, k)
# k = n - k if k > n - k
# (fact(k + 1, n) * inv(fact(1, n - k) % MOD)) % MOD
# end
def cmb(n, r, p):
if r > n - r:
r = n - r
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
N = 10 ** 6 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
def f(t,k,mod):
res = 1
for i in range(k):
res = res * t % mod
t -= 1
return res
def nCk(n,r):
if r > n - r:
r = n - r
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
res = 1
for i in range(r):
res *= n - i
res /= i + 1
return int(res)
def fact(n,k,mod):
res = 1
for i in range(k):
res = res * (n-i) % mod
return res % mod
def pow2(x, n):
ans = 1
while(n > 0):
if(bin(n & 1) == bin(1)):
ans = ans*x
x = x*x
n = n >> 1 #ビットシフト
return ans
# A_inv = pow(A,P-2,P)
mod = 10 ** 9 + 7
# n = gets.to_i
# s = gets.chomp
# n,a,b = gets.split.map(&:to_i)
n, a, b = list(map(int, input().split()))
cnt_a = cnt_b = 0
# def xgcd(a, b):
# x0, y0, x1, y1 = 1, 0, 0, 1
# while b != 0:
# q, a, b = a // b, b, a % b
# x0, x1 = x1, x0 - q * x1
# y0, y1 = y1, y0 - q * y1
# return a, x0, y0
# def modinv(a, m):
# g, x, y = xgcd(a, m)
# if g != 1:
# raise Exception('modular inverse does not exist')
# else:
# return x % m
ans = pow(2,n,mod)
ans -= 1
# p [n,ans]
# print(ans)
# print(f(n,a,mod))
# print(f(n,b,mod))
# print(f(4,1,mod))
# p nCk(a,n)
# p fact(b,n)
ans = (ans - fact(n,a,mod)*pow(fact(a,a,mod),mod-2,mod)) % mod
ans = (ans - fact(n,b,mod)*pow(fact(b,b,mod),mod-2,mod)) % mod
# print(fact(n,a,mod)*pow(fact(a,a,mod),mod-2,mod))
# print(a)
# print(fact(a,a,mod))
# print(pow(n,b,mod))
# print(pow(n,b,mod)*modinv(pow(b,b,mod),mod))
print(ans) | mod = 10 ** 9 + 7
def fact(n,k,mod):
res = 1
for i in range(k):
res = res * (n-i) % mod
return res % mod
n, a, b = list(map(int, input().split()))
ans = pow(2,n,mod) - 1
ans = (ans - fact(n,a,mod)*pow(fact(a,a,mod),mod-2,mod)) % mod
ans = (ans - fact(n,b,mod)*pow(fact(b,b,mod),mod-2,mod)) % mod
print(ans) | p02768 |
mod = 10 ** 9 + 7
# permutation: n * (n-1) * …… * (n-k+1) (mod p)
def prm(n, k, p=10**9+7):
res = 1
for i in range(k):
res = res * (n-i) % p
return res
# combination: nPk / k! (mod p), note: p must be a prime number
def cmb(n, k, p=10**9+7):
k = min(k, n - k)
return prm( n, k ) * pow( prm(k, k), p-2, p ) % p
n, a, b = list(map(int, input().split()))
#何も選ばない1通りを除く
ans = pow(2,n,mod) - 1 - cmb(n,a) - cmb(n,b)
print((ans % mod)) | mod = 10 ** 9 + 7
# permutation: n * (n-1) * …… * (n-k+1) (mod p)
def prm(n, k, p=10**9+7):
res = 1
for i in range(k):
res = res * (n-i) % p
return res
# note: p must be a prime number
# フェルマーの小定理より
def modinv(a, p):
return pow( a, p-2, p )
# combination: nPk / k! (mod p), note: p must be a prime number
def cmb(n, k, p=10**9+7):
k = min(k, n - k)
return prm( n, k ) * modinv( prm(k, k), p ) % p
n, a, b = list(map(int, input().split()))
#何も選ばない1通りを除く
ans = pow(2,n,mod) - 1 - cmb(n,a) - cmb(n,b)
print((ans % mod)) | p02768 |
import sys
import math
MOD = 10 ** 9 + 7
def extgcd(a,b):
r = [1,0,a]
w = [0,1,b]
while w[2]!=1:
q = r[2]//w[2]
r2 = w
w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]
r = r2
w = w2
#[x,y]
return [w[0],w[1]]
def mod_inv(a):
x = extgcd(a,MOD)[0]
return (MOD+x%MOD)%MOD
input = sys.stdin.readline
n,a,b = list(map(int,input().split()))
x1 = 1
a = min(a,n-a)
b = min(b,n-b)
if a > b:
a,b = b,a
for i in range(n-a+1,n+1):
x1 = x1 * i % MOD
x11 = 1
for i in range(1,a+1):
x11 = x11 * i % MOD
x1 = x1 * mod_inv(x11) % MOD
x2 = x1
for i in range(n-b+1,n-a+1):
x2 = x2 * i % MOD
x21 = 1
for i in range(a+1,b+1):
x21 = x21 * i % MOD
x2 = x2 * mod_inv(x21) % MOD
t = []
nn = n
while nn > 0:
t.append(nn % 2)
nn //= 2
x0 = 1
for i in range(len(t)):
x0 = x0 ** 2
x0 = x0 % MOD
if t[len(t)-i-1] == 1:
x0 *= 2
x0 = x0 % MOD
print(((x0 - x1 - x2 - 1) % MOD))
| import sys
import math
MOD = 10 ** 9 + 7
input = sys.stdin.readline
n,a,b = list(map(int,input().split()))
x1 = 1
a = min(a,n-a)
b = min(b,n-b)
if a > b:
a,b = b,a
for i in range(n-a+1,n+1):
x1 = x1 * i % MOD
x11 = 1
for i in range(1,a+1):
x11 = x11 * i % MOD
x1 = x1 * pow(x11,MOD-2,MOD) % MOD
x2 = x1
for i in range(n-b+1,n-a+1):
x2 = x2 * i % MOD
x21 = 1
for i in range(a+1,b+1):
x21 = x21 * i % MOD
x2 = x2 * pow(x21,MOD-2,MOD) % MOD
t = []
nn = n
while nn > 0:
t.append(nn % 2)
nn //= 2
x0 = 1
for i in range(len(t)):
x0 = x0 ** 2
x0 = x0 % MOD
if t[len(t)-i-1] == 1:
x0 *= 2
x0 = x0 % MOD
print(((x0 - x1 - x2 - 1) % MOD))
| p02768 |
n,a,b = [int(x) for x in input().split()]
mod = 10**9 + 7
def comb(x,y):
child = 1
mother = 1
for i in range(y):
child = child * (x-i)%mod
mother = mother * (i+1)%mod
return child * pow(mother,mod-2,mod) % mod
ans = pow(2,n,mod) - 1
ans -= comb(n,a)
ans %= mod
ans -= comb(n,b)
ans %= mod
print(ans) | n,a,b = [int(x) for x in input().split()]
mod = 10**9 + 7
def comb(x,y):
child = 1
mother = 1
for i in range(y):
child = child * (x-i)%mod
mother = mother * (i+1)%mod
return child * pow(mother,mod-2,mod) % mod
ans = pow(2,n,mod) - 1 - comb(n,a) - comb(n,b)
print((ans%mod)) | p02768 |
M=10**9+7
n,a,b=list(map(int,input().split()))
s=r=1
for i in range(b):r=r*(n-i)*pow(i+1,M-2,M)%M;s+=r*(i+1in(a,b))
print(((pow(2,n,M)-s)%M)) | M=10**9+7
n,a,b=list(map(int,input().split()))
s=r=1
for i in range(b):r=r*(n-i)*pow(i+1,M-2,M)%M;s+=r*(i+1==a)
print(((pow(2,n,M)-s-r)%M)) | p02768 |
# AtCoder用のライブラリ
# 参照
# https://qiita.com/drken/items/3b4fdf0a78e7a138cd9a
# a ** n mod m
def mod_pow(a, n, m=10 ** 9 + 7):
res = 1
while n > 0:
if n & 1 == 1:
res = res * a % m
a = a * a % m
n >>= 1
return res
# aの-1乗をmで割ったときの商を求める
def mod_inv(a, m=10 ** 9 + 7):
b = m
u = 1
v = 0
while b > 0:
t = a // b
a -= t * b
c = a
a = b
b = c
u -= t * v
c = u
u = v
v = c
u %= m
return u
# 組み合わせ数(nCk)を計算させる。
# nを固定しながら複数のkに対して計算させることができるようにしてあるため、
# 計算量はO(max(k)*log(mod))のため、実質O(max(k))。
class ModCombination:
def __init__(self, n, mod=10 ** 9 + 7):
self.N = n
self.MOD = mod
self.inv_fact_list = [1]
self.P_list = [1]
def combination(self, r):
if r > len(self.inv_fact_list) - 1:
self._list_extend(r)
return self.inv_fact_list[r] * self.P_list[r] % self.MOD
def _list_extend(self, needed):
now = len(self.inv_fact_list)
while now <= needed:
self.P_list.append(self.P_list[-1] * (self.N - now + 1) % self.MOD)
self.inv_fact_list.append(self.inv_fact_list[-1] * mod_inv(now) % self.MOD)
now += 1
n, a, b = list(map(int, input().split()))
MOD = 10 ** 9 + 7
c = ModCombination(n)
ans = (mod_pow(2, n) - c.combination(b) - c.combination(a) - 1) % MOD
print(ans) | # AtCoder用のライブラリ
# 参照
# https://qiita.com/drken/items/3b4fdf0a78e7a138cd9a
n, a, b = list(map(int, input().split()))
MOD = 10 ** 9 + 7
# a ** n mod m
def mod_pow(a, n, m=10 ** 9 + 7):
res = 1
while n > 0:
if n & 1 == 1:
res = res * a % m
a = a * a % m
n >>= 1
return res
# aの-1乗をmで割ったときの商を求める
def mod_inv(a, m=10 ** 9 + 7):
b = m
u = 1
v = 0
while b > 0:
t = a // b
a -= t * b
c = a
a = b
b = c
u -= t * v
c = u
u = v
v = c
u %= m
return u
inv_fact_list = [1]
P_list = [1]
def combination(r):
if r > len(inv_fact_list) - 1:
_list_extend(r)
return inv_fact_list[r] * P_list[r] % MOD
def _list_extend(needed):
now = len(inv_fact_list)
while now <= needed:
P_list.append(P_list[-1] * (n - now + 1) % MOD)
inv_fact_list.append(inv_fact_list[-1] * mod_inv(now) % MOD)
now += 1
ans = (mod_pow(2, n) - combination(b) - combination(a) - 1) % MOD
print(ans) | p02768 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
def pow_r_mod(x, n, mod=10**9+7):
"""
O(log n)
"""
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)+1
inv_t = [0]+[1]
for i in range(2,N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
mca = mcb = 1
for i in range(1, a+1):
mca *= (m-i+1) * inv_t[i]
mca %= P
for i in range(1, b+1):
mcb *= (m-i+1) * inv_t[i]
mcb %= P
print(((pow_r_mod(2, m)-1-mca-mcb) % P)) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
def pow_r_mod(x, n, mod=10**9+7):
# 計算量 : log N
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
def mod_pow(a:int, b:int, mod:int)->int:
if b % 2 == 0:
return (mod_pow(a, b//2, mod) ** 2) % mod
elif b == 1:
return a % mod
else:
return ((mod_pow(a, b//2, mod) ** 2) * a) % mod
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)+1
inv_t = [0]+[1]
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
mca = mcb = 1
for i in range(1, a+1):
mca *= (m-i+1) * inv_t[i]
mca %= P
for i in range(1, b+1):
mcb *= (m-i+1) * inv_t[i]
mcb %= P
#print((pow_r_mod(2, m)-1-mca-mcb) % P)
print(((mod_pow(2, m, P)-1-mca-mcb) % P)) | p02768 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
def pow_r_mod(x, n, mod=10**9+7):
# 計算量 : log N
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
def mod_pow(a:int, b:int, mod:int)->int:
if b % 2 == 0:
return (mod_pow(a, b//2, mod) ** 2) % mod
elif b == 1:
return a % mod
else:
return ((mod_pow(a, b//2, mod) ** 2) * a) % mod
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)+1
inv_t = [0]+[1]
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
mca = mcb = 1
for i in range(1, a+1):
mca *= (m-i+1) * inv_t[i]
mca %= P
for i in range(1, b+1):
mcb *= (m-i+1) * inv_t[i]
mcb %= P
#print((pow_r_mod(2, m)-1-mca-mcb) % P)
print(((mod_pow(2, m, P)-1-mca-mcb) % P)) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
def pow_r_mod(x:int, n:int, mod=10**9+7)->int:
# 計算量 : log N
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
def mod_pow(a:int, b:int, mod:int)->int:
if b % 2 == 0:
return (mod_pow(a, b//2, mod) ** 2) % mod
elif b == 1:
return a % mod
else:
return ((mod_pow(a, b//2, mod) ** 2) * a) % mod
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)+1
inv_t = [0]+[1]
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
mca = mcb = 1
for i in range(1, a+1):
mca *= (m-i+1) * inv_t[i]
mca %= P
for i in range(1, b+1):
mcb *= (m-i+1) * inv_t[i]
mcb %= P
print(((pow_r_mod(2, m)-1-mca-mcb) % P))
#print((mod_pow(2, m, P)-1-mca-mcb) % P) | p02768 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
def pow_r_mod(x:int, n:int, mod=10**9+7)->int:
# 計算量 : log N
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
def mod_pow(a:int, b:int, mod:int)->int:
if b % 2 == 0:
return (mod_pow(a, b//2, mod) ** 2) % mod
elif b == 1:
return a % mod
else:
return ((mod_pow(a, b//2, mod) ** 2) * a) % mod
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)+1
inv_t = [0]+[1]
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
mca = mcb = 1
for i in range(1, a+1):
mca *= (m-i+1) * inv_t[i]
mca %= P
for i in range(1, b+1):
mcb *= (m-i+1) * inv_t[i]
mcb %= P
print(((pow_r_mod(2, m)-1-mca-mcb) % P))
#print((mod_pow(2, m, P)-1-mca-mcb) % P) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
# 繰り返し二乗法
def pow_r_mod(x:int, n:int, mod=10**9+7)->int:
# 計算量 : log N
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)+1
inv_t = [0]+[1]
# 逆元
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
mca = mcb = 1
for i in range(1, a+1):
mca *= (m-i+1) * inv_t[i]
mca %= P
mcb = mca
for i in range(a+1, b+1):
mcb *= (m-i+1) * inv_t[i]
mcb %= P
print(((pow_r_mod(2, m)-1-mca-mcb) % P))
#print((mod_pow(2, m, P)-1-mca-mcb) % P)
| p02768 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
# 繰り返し二乗法
def pow_r_mod(x:int, n:int, mod=10**9+7)->int:
# 計算量 : log N
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
def table(n:int, p=10**9+7):
global fact, factinv, inv
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, n+1):
#fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
#factinv.append((factinv[-1] * inv[-1]) % p)
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)
#inv_t = [0]+[1]
# 逆元
#for i in range(2, N):
#inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
table(N)
mca = 1
for i in range(1, a+1):
mca *= (m-i+1) * inv[i]
mca %= P
mcb = mca
for i in range(a+1, b+1):
mcb *= (m-i+1) * inv[i]
mcb %= P
print(((pow_r_mod(2, m)-1-mca-mcb) % P))
#print((mod_pow(2, m, P)-1-mca-mcb) % P) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
# 繰り返し二乗法
def pow_r_mod(x:int, n:int, mod=10**9+7)->int:
# 計算量 : log N
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
def table(n:int, p=10**9+7):
global fact, factinv, inv
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, n+1):
#fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
#factinv.append((factinv[-1] * inv[-1]) % p)
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)
table(N)
mca = 1
for i in range(1, a+1):
mca *= (m-i+1) * inv[i]
mca %= P
mcb = mca
for i in range(a+1, b+1):
mcb *= (m-i+1) * inv[i]
mcb %= P
print(((pow_r_mod(2, m)-1-mca-mcb) % P))
| p02768 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
def table(n:int, p=10**9+7):
global fact, factinv, inv
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, n+1):
#fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
#factinv.append((factinv[-1] * inv[-1]) % p)
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)
table(N)
mca = 1
for i in range(1, a+1):
#mca *= (m-i+1) * inv[i]
mca *= (m-i+1) * pow(i, P-2, P)
mca %= P
mcb = mca
for i in range(a+1, b+1):
#mcb *= (m-i+1) * inv[i]
mca *= (m-i+1) * pow(i, P-2, P)
mcb %= P
print(((pow(2, m, P)-1-mca-mcb) % P)) | import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
def table(n:int, p=10**9+7):
global fact, factinv, inv
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2, n+1):
#fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
#factinv.append((factinv[-1] * inv[-1]) % p)
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)
table(N)
mca = bunshi= 1
for i in range(1, a+1):
#mca *= (m-i+1) * inv[i]
mca *= (m-i+1)
bunshi *= i
mca %= P
bunshi %= P
mcb = mca
mca = mca * pow(bunshi, P-2, P)
mca %= P
for i in range(a+1, b+1):
#mcb *= (m-i+1) * inv[i]
mcb *= (m-i+1)
bunshi *= i
mcb %= P
bunshi %= P
mcb = mcb * pow(bunshi, P-2, P)
mcb %= P
print(((pow(2, m, P)-1-mca-mcb) % P)) | p02768 |
def modinv(a,m):
return pow(a,m-2,m)
n,a,b = list(map(int,input().split()))
P = 10**9+7
nCa = 1
for i in range(1,a+1):
nCa = nCa*(n+1-i)*modinv(i,P)%P
nCb = nCa
for j in range(a+1,b+1):
nCb = nCb*(n+1-j)*modinv(j,P)%P
ans = (pow(2,n,P) -1 - nCa - nCb + 2*P)%P
print(ans)
| def comb(n, r, mod):
r = min(r, n-r)
mol = 1
for i in range(n-r+1, n+1):
mol = (mol * i) % mod
deno = 1
for i in range(1, r+1):
deno = (deno * i) % mod
ret = mol * pow(deno, mod-2, mod) % mod
return ret
n,a,b = list(map(int,input().split()))
P = 10**9+7
nCa = comb(n, a, P)
nCb = comb(n, b, P)
ans = (pow(2,n,P) -1 - nCa - nCb + 2*P)%P
print(ans)
| p02768 |
import math
import sys
sys.setrecursionlimit(int(10**9))
mod = 10**9 + 7
def power(x, y):
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y/2)**2 % mod
else : return power(x, y//2)**2 * x % mod
def fact(n):
if n == 1:
return 1
else:
return (fact(n-1)*n)%mod
def comb(n, k):
ans = 1
for i in range(k):
ans *= (n-i)
ans //= i+1
return ans % mod
n, a, b = list(map(int, input().split()))
now = 1
for i in range(a):
now = (now*(n-i)*power(i+1,mod-2))%mod
cnka = now
for i in range(a,b):
now = (now*(n-i)*power(i+1,mod-2))%mod
cnkb = now
ans = power(2, n)%mod - cnka - cnkb - 1
print((ans % mod)) | import math
import sys
sys.setrecursionlimit(int(10**9))
mod = 10**9 + 7
def power(x, y):
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y/2)**2 % mod
else : return power(x, y//2)**2 * x % mod
def fact(n):
if n == 1:
return 1
else:
return (fact(n-1)*n)%mod
def comb(n, k):
ans = 1
for i in range(k):
ans *= (n-i)
ans //= i+1
return ans % mod
n, a, b = list(map(int, input().split()))
now = 1
for i in range(a):
now = (now*(n-i))%mod
cnka = (now * power(math.factorial(a),mod-2) )% mod
for i in range(a,b):
now = (now*(n-i))%mod
cnkb = (now * power(math.factorial(b),mod-2) )% mod
ans = power(2, n)%mod - cnka - cnkb - 1
print((ans % mod)) | p02768 |
import sys
def alg_combination_mod(n, r, mod):
r = min(n - r, r)
if r == 0:
return 1
else:
denominator = 1
for i in range(n, n - r, -1):
denominator = (denominator * i) % mod
molecule = 1
for i in range(1, r + 1):
molecule = (molecule * i) % mod
return denominator * pow(molecule, mod - 2, mod) % mod
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().rstrip('\n').split()))
all_cnt = pow(2, n, mod) + mod
a_cnt = alg_combination_mod(n, a, mod)
b_cnt = alg_combination_mod(n, b, mod)
print(((all_cnt - a_cnt - b_cnt - 1) % mod))
if __name__ == '__main__':
solve()
| import sys
def alg_combination_mod(n, r, mod):
r = min(n - r, r)
if r == 0:
return 1
else:
denominator = 1
for i in range(n, n - r, -1):
denominator = (denominator * i) % mod
molecule = 1
for i in range(1, r + 1):
molecule = (molecule * i) % mod
return denominator * pow(molecule, mod - 2, mod) % mod
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, a, b = list(map(int, input().rstrip('\n').split()))
all_cnt = pow(2, n, mod)
a_cnt = alg_combination_mod(n, a, mod)
b_cnt = alg_combination_mod(n, b, mod)
print(((all_cnt - a_cnt - b_cnt - 1) % mod))
if __name__ == '__main__':
solve()
| p02768 |
n,a,b=list(map(int, input().split()))
def comb(n, r,MOD):
p, q = 1, 1
for i in range(r):
p = p * (n-i) % MOD
q = q * (i+1) % MOD
return p * pow(q, MOD-2, MOD) % MOD
mod=10**9+7
A=comb(n,a,mod)
B=comb(n,b,mod)
C=pow(2,n,mod)
if n==2:
print((0))
else:
print(((C-1-A-B)%mod)) | n,a,b=list(map(int, input().split()))
def comb(n, r,MOD):
p, q = 1, 1
for i in range(r):
p = p * (n-i) % MOD
q = q * (i+1) % MOD
return p * pow(q, MOD-2, MOD) % MOD
mod=10**9+7
if n==2:
print((0))
else:
print(((pow(2,n,mod)-1-comb(n,a,mod)-comb(n,b,mod))%mod)) | p02768 |
n,a,b=list(map(int, input().split()))
def comb(n, r,MOD):
p, q = 1, 1
for i in range(r):
p = p * (n-i) % MOD
q = q * (i+1) % MOD
return p * pow(q, MOD-2, MOD) % MOD
mod=10**9+7
if n==2:
print((0))
else:
print(((pow(2,n,mod)-1-comb(n,a,mod)-comb(n,b,mod))%mod)) | n,a,b=list(map(int, input().split()))
def comb(n, r,mod):
r=min(r,n-r)
p, q = 1, 1
for i in range(r):
p = p * (n-i) % mod
q = q * (i+1) % mod
return p * pow(q, mod-2, mod) % mod
mod=10**9+7
if n==2:
print((0))
else:
print(((pow(2,n,mod)-1-comb(n,a,mod)-comb(n,b,mod))%mod)) | p02768 |
def sq(a, b, mod): # aのb乗を剰余,kは初期値#20191116-D-Knight
if b == 0:
return 1
elif b % 2 == 0:
return sq(a, b // 2, mod)**2 % mod
else:
return sq(a, b - 1, mod) * a % mod
def nCk(n, k, mod=10 ** 9 + 7):
x = max(k, n - k)
y = min(k, n - k)
kkai = 1
for i in range(2, y + 1):
kkai = (kkai * i) % mod
nkkai = 1
for i in range(x + 1, n + 1):
nkkai = (nkkai * i) % mod
answer = sq(kkai, mod - 2, mod) * nkkai % mod
return answer
mod = 10**9+7
n, a, b = list(map(int, input().split()))
def modpow(x, y):
res = 1
while y > 0:
if y & 1:
res = res*x % (10**9+7)
x = x*x%(10**9+7)
y >>= 1
y = int(y)
return res
ans = 0
ans -= nCk(n, b)
ans -= nCk(n, a)
ans -= 1
ans += modpow(2, n)
print(((ans+10**9+7)%(10**9+7))) | def sq(a, b, mod): # aのb乗を剰余,kは初期値#20191116-D-Knight
if b == 0:
return 1
elif b % 2 == 0:
return sq(a, b // 2, mod)**2 % mod
else:
return sq(a, b - 1, mod) * a % mod
def nCk(n, k, mod=10 ** 9 + 7):
x = max(k, n - k)
y = min(k, n - k)
kkai = 1
for i in range(2, y + 1):
kkai = (kkai * i) % mod
nkkai = 1
for i in range(x + 1, n + 1):
nkkai = (nkkai * i) % mod
answer = sq(kkai, mod - 2, mod) * nkkai % mod
return answer
n, a, b = list(map(int, input().split()))
mod = 10**9 + 7
ans = pow(2, n, mod) + mod
ans -= nCk(n, a)
ans -= nCk(n, b)
print(((ans-1)%mod)) | p02768 |
def cmb(n, r, p):
r = min(r, n - r)
res = 1
for i in range(r):
res *= pow(i+1, p-2, p) # 分母の逆元(フェルマーの定理)
res *= n-i # 分子
res %= p
return res
p = 10 ** 9 + 7
n, a, b = list(map(int, input().split()))
ans = pow(2, n, p) - 1
ans -= cmb(n, a, p) + cmb(n, b, p)
print((ans % p))
| from functools import reduce
def cmb(n, r, p):
r = min(n - r, r)
if r == 0:
return 1
numer = reduce(lambda x, y: (x*y)%p, list(range(n, n - r, -1)))
denom = reduce(lambda x, y: (x*y)%p, list(range(1, r + 1)))
return (numer * pow(denom, p-2, p)) % p
p = 10 ** 9 + 7
n, a, b = list(map(int, input().split()))
ans = pow(2, n, p) - 1
ans -= cmb(n, a, p) + cmb(n, b, p)
print((ans % p))
| p02768 |
from math import factorial
def framod(n, mod, a=1):
for i in range(1,n+1):
a=a * i % mod
return a
def power(n, r, mod):
if r == 0: return 1
if r%2 == 0:
return power(n*n % mod, r//2, mod) % mod
if r%2 == 1:
return n * power(n, r-1, mod) % mod
def comb(n, k, mod):
a=framod(n, mod)
b=framod(k, mod)
c=framod(n-k, mod)
return (a * power(b, mod-2, mod) * power(c, mod-2, mod)) % mod
n,a,b=list(map(int, input().split()))
mo=10**9+7
fn=2*10**5
fac=[0]*fn
fac[1]=n
for i in range(2,fn):
fac[i]=fac[i-1]*(n-i+1)*power(i, mo-2, mo) % mo
print(((power(2, n, mo)-1-fac[a]-fac[b])%mo)) | import time
from math import factorial
def framod(n, mod, a=1):
for i in range(1,n+1):
a=a * i % mod
return a
def power(n, r, mod):
if r == 0: return 1
if r%2 == 0:
return power(n*n % mod, r//2, mod) % mod
if r%2 == 1:
return n * power(n, r-1, mod) % mod
def comb(n, k, mod):
a=1
for i in range(n, n-k, -1):
a=a * i % mod
b=framod(k, mod)
return (a * power(b, mod-2, mod)) % mod
n,a,b=list(map(int, input().split()))
mo=10**9+7
fn=2*10**5
fac=[0]*fn
fac[1]=n
print(((power(2, n, mo)-1-comb(n,a,mo)-comb(n,b,mo))%mo))
| p02768 |
n, a, b = list(map(int, input().split()))
MOD = 10**9+7
def COM(n, r):
X = Y = 1
if n-r < r:
r = n-r
for i in range(1, r+1):
Y = Y*i % MOD
Y = pow(Y, MOD-2, MOD)
while 0 < r:
X = X*n % MOD
n -= 1
r -= 1
return X*Y
ans = pow(2, n, MOD)-1 - COM(n, a)-COM(n, b)
ans %= MOD
print(ans)
| n, a, b = list(map(int, input().split()))
MOD = 10**9+7
def COM(n, r):
X = Y = 1
if n-r < r:
r = n-r
for i in range(1, r+1):
Y = Y*i % MOD
X = X*(n-i+1) % MOD
Y = pow(Y, MOD-2, MOD)
return X*Y
ans = pow(2, n, MOD)-1 - COM(n, a)-COM(n, b)
ans %= MOD
print(ans)
| p02768 |
n, a, b = list(map(int, input().split()))
MOD = 10**9+7
def COM(n, r):
X = Y = 1
if n-r < r:
r = n-r
for i in range(1, r+1):
Y = Y*i % MOD
X = X*(n-i+1) % MOD
Y = pow(Y, MOD-2, MOD)
return X*Y
ans = pow(2, n, MOD)-1 - COM(n, a)-COM(n, b)
ans %= MOD
print(ans)
| n, a, b = list(map(int, input().split()))
MOD = 10**9+7
ans = pow(2, n, MOD)-1
X = Y = 1
for i in range(1, b+1):
Y = Y*i % MOD
X = X*(n-i+1) % MOD
if i == a or i == b:
ans -= X*pow(Y, MOD-2, MOD)
print((ans % MOD)) | p02768 |
class Combination:
'''MOD上の
計算量：階乗・逆元テーブルの作成O(N)
nCkを求めるO(1)'''
def __init__(self, n, MOD):
self.fact = [1]
for i in range(1, n + 1):
self.fact.append(self.fact[-1] * i % MOD)
self.inv_fact = [pow(self.fact[i], MOD - 2, MOD) for i in range(n + 1)]
self.MOD = MOD
def factorial(self, k):
"""k!を求める O(1)"""
return self.fact[k]
def inverse_factorial(self, k):
"""k!の逆元を求める O(1)"""
return self.inv_fact[k]
def permutation(self, k, r):
"""kPrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[r]) % self.MOD
def combination(self, k, r):
"""kCrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD
def combination2(self, k, r):
"""kCrを求める O(r)
kが大きいときに使える
"""
if k < r:
return 0
res = 1
for l in range(r):
res *= (k - l)
res %= self.MOD
return (res * self.inv_fact[r]) % self.MOD
n, a, b = list(map(int, input().split()))
MOD = 10 ** 9 + 7
comb = Combination(2 * 10 ** 5 + 10, MOD)
ptn_a = comb.combination2(n, a)
ptn_b = comb.combination2(n, b)
ptn_n = pow(2, n, MOD) - 1
print(((ptn_n - ptn_a - ptn_b) % MOD))
| class Combination:
"""階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""
def __init__(self, n, MOD):
self.fact = [1]
for i in range(1, n + 1):
self.fact.append(self.fact[-1] * i % MOD)
self.inv_fact = [0] * (n + 1)
self.inv_fact[n] = pow(self.fact[n], MOD - 2, MOD)
for i in reversed(list(range(n))):
self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % MOD
self.MOD = MOD
def factorial(self, k):
"""k!を求める O(1)"""
return self.fact[k]
def inverse_factorial(self, k):
"""k!の逆元を求める O(1)"""
return self.inv_fact[k]
def permutation(self, k, r):
"""kPrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[k - r]) % self.MOD
def combination(self, k, r):
"""kCrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD
def combination2(self, k, r):
"""kCrを求める O(r) kが大きいが、r <= nを満たしているときに使用"""
if k < r:
return 0
res = 1
for l in range(r):
res *= (k - l)
res %= self.MOD
return (res * self.inv_fact[r]) % self.MOD
n, a, b = list(map(int, input().split()))
MOD = 10 ** 9 + 7
comb = Combination(2 * 10 ** 5 + 10, MOD)
all_ptn =pow(2, n, MOD)
a_ptn = comb.combination2(n, a)
b_ptn = comb.combination2(n, b)
ans = (all_ptn - (a_ptn + b_ptn) - 1) % MOD
print(ans) | p02768 |
class Combination:
"""階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""
def __init__(self, n, MOD):
self.fact = [1]
for i in range(1, n + 1):
self.fact.append(self.fact[-1] * i % MOD)
self.inv_fact = [0] * (n + 1)
self.inv_fact[n] = pow(self.fact[n], MOD - 2, MOD)
for i in reversed(list(range(n))):
self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % MOD
self.MOD = MOD
def factorial(self, k):
"""k!を求める O(1)"""
return self.fact[k]
def inverse_factorial(self, k):
"""k!の逆元を求める O(1)"""
return self.inv_fact[k]
def permutation(self, k, r):
"""kPrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[k - r]) % self.MOD
def combination(self, k, r):
"""kCrを求める O(1)"""
if k < r:
return 0
return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD
def combination2(self, k, r):
"""kCrを求める O(r) kが大きいが、r <= nを満たしているときに使用"""
if k < r:
return 0
res = 1
for l in range(r):
res *= (k - l)
res %= self.MOD
return (res * self.inv_fact[r]) % self.MOD
n, a, b = list(map(int, input().split()))
MOD = 10 ** 9 + 7
comb = Combination(2 * 10 ** 5 + 10, MOD)
all_ptn =pow(2, n, MOD)
a_ptn = comb.combination2(n, a)
b_ptn = comb.combination2(n, b)
ans = (all_ptn - (a_ptn + b_ptn) - 1) % MOD
print(ans) | import sys
input = sys.stdin.buffer.readline
def combination(k, r, MOD):
"""kCrを求める"""
if k < r:
return 0
r = min(r, k - r)
numer, denom = 1, 1
for l in range(r):
numer *= (k - l)
numer %= MOD
denom *= l + 1
denom %= MOD
return numer * pow(denom, MOD - 2, MOD) % MOD
n, a, b = list(map(int, input().split()))
MOD = 10 ** 9 + 7
all_ptn = pow(2, n, MOD)
a_ptn = combination(n, a, MOD)
b_ptn = combination(n, b, MOD)
ans = (all_ptn - (a_ptn + b_ptn) - 1) % MOD
print(ans) | p02768 |
n,a,b = list(map(int,input().split()))
M = 10**9+7
# 2**n
twon = pow(2,n,M)
# nCr+1 = nCr * (n-r)/(r+1)
# nCr = A(r)とおくと ※nは固定
# A(r+1) = A(r) * (n-r)/(r+1)
# ここでmod M では、フェルマーの小定理より
# 1/(r+1) === (r+1)**(M-2) ※===は合同記号の意味
# よって A(r+1) = A(r) * (n-r) * (r+1)**(M-2)
L = [0] * (2*(10**5) + 1)
L[0] = 1
for i in range(len(L)-1):
L[i+1] = ( L[i] * (n-i) * pow(i+1,M-2,M) ) % M
# nCa
nCa = L[a]
# nCb
nCb = L[b]
ans = twon - 1 - nCa - nCb
print((ans % M)) | import time
n,a,b = list(map(int,input().split()))
start = time.time() # 時間計測開始
M = 10**9+7
# 2**n
twon = pow(2,n,M)
# nCr+1 = nCr * (n-r)/(r+1)
# nCr = A(r)とおくと ※nは固定
# A(r+1) = A(r) * (n-r)/(r+1)
# ここでmod M では、フェルマーの小定理より
# 1/(r+1) === (r+1)**(M-2) ※===は合同記号の意味
# よって A(r+1) = A(r) * (n-r) * (r+1)**(M-2)
# L = [0] * (2*(10**5) + 1)
# L[0] = 1
# for i in range(len(L)-1):
# L[i+1] = ( L[i] * (n-i) * pow(i+1,M-2,M) ) % M
def comb_mod(n,r,mod):
x = 1
y = 1
for i in range(r):
x = (x*(n-i)) % mod
y = (y*(i+1)) % mod
return (x * pow(y,mod-2,mod))
# nCa
# nCa = L[a]
nCa = comb_mod(n,a,M)
# nCb
# nCb = L[b]
nCb = comb_mod(n,b,M)
ans = twon - 1 - nCa - nCb
elapsed_time = time.time() - start # 時間計測終了
# print(elapsed_time)
print((ans % M))
| p02768 |
n, a, b = list(map(int, input().split()))
# 全通り - nCa - nCb
mod = 10 ** 9 + 7
def inv(x):
return pow(x, mod - 2, mod)
# n ~ n - k + 1
def c(n, k):
res = 1
for i in range(0, k):
res = res * (n - i) * inv(i + 1) % mod
return res
print((((pow(2, n, mod) - c(n, a) - c(n, b) - 1) % mod + mod) % mod))
| n, a, b = list(map(int, input().split()))
mod = 10 ** 9 + 7
def inv(x):
return pow(x, mod - 2, mod)
def c(n, k):
ue, sita = 1, 1
for i in range(0, k):
ue = ue * (n - i) % mod
sita = sita * (i + 1) % mod
return ue * inv(sita) % mod
print((((pow(2, n, mod) - c(n, a) - c(n, b) - 1) % mod + mod) % mod))
| p02768 |
n,a,b=list(map(int,input().split()))
mod=10**9+7
def comb(n,k):
temp=1
k=min(k,n-k)
for i in range(1,k+1):
temp=temp*pow(i,mod-2,mod)
temp=temp*(n-i+1)%mod
return temp%mod
#二分累乗法を勉強する
ans=pow(2,n,mod)-1-comb(n,a)-comb(n,b)
print((ans%mod)) | n,a,b=list(map(int,input().split()))
mod=10**9+7
def C(n,k,mod):
k=min(k,n-k)
comb=1
for i in range(k):
temp=(n-i)*pow(i+1,mod-2,mod)
comb=comb*temp%mod
return comb
ans=pow(2,n,mod)-1-C(n,a,mod)-C(n,b,mod)
print((ans%mod)) | p02768 |
def cmb(n, r, p):
# nume/deno === nume * pow(deno, p - 2, p) (mod p)
nume, deno = 1, 1
for i in range(r):
nume = nume * (n - i) % p
deno = deno * (i + 1) % p
return nume * pow(deno, p - 2, p) % p
if __name__ == "__main__":
n, a, b = list(map(int, input().split()))
p = 10 ** 9 + 7
print(((pow(2, n, p) - cmb(n, a, p) - cmb(n, b, p) - 1) % p))
| def comb(n, r, p):
num, den = 1, 1
r = min(r, n - r)
for i in range(1, r + 1):
num = num * (n - i + 1) % p
den = den * i % p
return num * pow(den, p - 2, p) % p
n, a, b = list(map(int, input().split()))
MOD = 1_000_000_007
ans = pow(2, n, MOD)
ans %= MOD
ans -= comb(n, a, MOD)
ans %= MOD
ans -= comb(n, b, MOD)
ans %= MOD
ans -= 1
ans %= MOD
print(ans)
| p02768 |
n, a, b = list(map(int, input().split()))
mod = 10 ** 9 + 7
class ModInt:
def __init__(self, num, mod):
self.num = num
self.mod = mod
def __str__(self):
return str(self.num)
def __repr__(self):
return "ModInt(num: {}, mod: {}".format(self.num, self.mod)
def __add__(self, other):
ret = self.num + other.num
ret %= self.mod
return ModInt(ret, self.mod)
def __sub__(self, other):
ret = self.num - other.num
ret %= self.mod
return ModInt(ret, self.mod)
def __mul__(self, other):
ret = self.num * other.num
ret %= self.mod
return ModInt(ret, self.mod)
def pow(self, times):
pw = pow(self.num, times, self.mod)
return ModInt(pw, self.mod)
def inverse(self):
return self.pow(self.mod - 2)
def __truediv__(self, other):
num = self * other.inverse()
return ModInt(num, self.mod)
class CombinationSmall:
def __init__(self, n, k, mod):
self.n = n
self.k = k
self.mod = mod
self.fact = [ModInt(1, mod)]
self.inverse = [ModInt(1, mod)]
for i in range(1, k + 1):
self.fact.append(self.fact[-1] * ModInt(n - i + 1, mod))
self.inverse.append(self.inverse[-1] * ModInt(i, mod).inverse())
def comb(self, k):
if k > self.k:
return ModInt(0, self.mod)
return self.fact[k] * self.inverse[k]
comb = CombinationSmall(n, min(n, 2 * 10 ** 5), mod)
ans = ModInt(2, mod).pow(n) - ModInt(1, mod)
ans -= comb.comb(a)
ans -= comb.comb(b)
print(ans)
| n, a, b = list(map(int, input().split()))
mod = 10 ** 9 + 7
MAX = 2 * 10 ** 5
fact = [1] * (MAX + 1)
for i in range(1, MAX + 1):
fact[i] = (fact[i-1] * i) % mod
inv = [1] * (MAX + 1)
for i in range(2, MAX + 1):
inv[i] = inv[mod % i] * (mod - mod // i) % mod
ans = pow(2, n, mod) - 1
def comb(k):
ret = 1
for i in range(1, k + 1):
ret *= n - i + 1
ret %= mod
ret *= inv[i]
ret %= mod
return ret
ans -= comb(a)
ans -= comb(b)
ans %= mod
print(ans)
| p02768 |
M = 10**9 + 7
n,a,b = list(map(int, input().split()))
def modinv(n):
return pow(n, M-2, M)
def comb(n, r):
num = 1
for i in range(n,n-r,-1):
cur = i
while cur%M == 0:
cur //= M
num = (num*cur)%M
denom = 1
for i in range(1,r+1):
cur = i
while cur%M == 0:
cur //= M
denom = (denom*cur)%M
return num * modinv(denom) % M
print(((pow(2, n, M) - comb(n, a) - comb(n, b) - 1) % M)) | M = 10**9 + 7
n,a,b = list(map(int, input().split()))
def modinv(n):
return pow(n, M-2, M)
def comb(n, r):
num = denom = 1
for i in range(1,r+1):
num = (num*(n+1-i))%M
denom = (denom*i)%M
return num * modinv(denom) % M
print(((pow(2, n, M) - comb(n, a) - comb(n, b) - 1) % M)) | p02768 |
from math import factorial
n, a, b = list(map(int, input().split()))
mod = 10**9+7
def inv(a, mod):
r = [1, 0, a]
w = [0, 1, mod]
while w[2] != 1:
q = r[2]//w[2]
r_new = [r[0]-q*w[0], r[1]-q*w[1], r[2]-q*w[2]]
r = w
w = r_new
x, y = w[0], w[1] # a*x+y*mod = 1
return (mod+x % mod) % mod
max_num = 2*10**5+1
fact = [0 for _ in range(max_num)]
ifact = [0 for _ in range(max_num)]
fact[0] = fact[1] = 1
ifact[0] = ifact[1] = 1
for i in range(2, max_num):
fact[i] = fact[i-1] * i % mod
ifact[i] = ifact[i-1] * inv(i, mod) % mod
def comb(x, y):
tmp = 1
for i in range(1, y+1):
tmp *= (n+1-i)
tmp %= mod
tmp *= ifact[y]
tmp %= mod
return tmp
po = [2]
for i in range(1, 100):
po.append((po[-1]**2) % mod)
nb = list(bin(n)[2:])[::-1]
n2 = 1
for i in range(len(nb)):
if nb[i] == '1':
n2 *= po[i]
n2 %= mod
print(((n2-1-comb(n, a)-comb(n, b))%mod))
| n, a, b = list(map(int, input().split()))
mod = 10**9+7
def comb(x, y):
numer = 1
denom = 1
for i in range(1, y+1):
numer *= n+1-i
numer %= mod
denom *= i
denom %= mod
denom = pow(denom, mod-2, mod)
return numer * denom
print(((pow(2, n, mod)-1-comb(n, a)-comb(n, b)) % mod))
| p02768 |
import math
n,a,b = list(map(int,input().split()))
def mod_inv(x,mod):
return pow(x,mod-2,mod)
def mod_inv_table(k):
table = [-1] * (k+1)
for i in range(1,k+1):
table[i] = mod_inv(i,10**9+7)
return table
def binomial(n,k,table):
ret = 1
for i in range(k):
ret *= n-i
ret *=table[i+1]
ret %= 10**9+7
return ret
tablea = mod_inv_table(a)
tableb = mod_inv_table(b)
ka = binomial(n,a,tablea)
kb = binomial(n,b,tableb)
alla = pow(2,n,10**9+7)
z = alla - ka -kb -1
print((z%(10**9+7))) | n,a,b = list(map(int,input().split()))
mod = 10**9 + 7
aue,bue = 1,1
for i in range(a):
aue = aue * (n-i) % mod
for i in range(b):
bue = bue * (n-i) % mod
asita,bsita = 1,1
for i in range(1,a+1):
asita = asita*i %mod
for i in range(1,b+1):
bsita = bsita*i %mod
at = aue * pow(asita,mod-2,mod)
bt = bue * pow(bsita,mod-2,mod)
ans = (pow(2,n,mod) - 1 -at -bt)%mod
print(ans) | p02768 |
mod = 1000000007
def pw(x, n):
if n == 0: return 1
elif n == 1: return x
elif n % 2 == 0:
return pw(x, n // 2) ** 2 % mod
else:
return x * pw(x, n // 2) ** 2 % mod
def dv(x, y):
return x * pow(y, mod - 2, mod) % mod
def comb(n, r):
p, q = 1, 1
if n < r or n < 0 or r < 0: return 0
for i in range(r):
p = p * (n - i) % mod
q = q * (i + 1) % mod
return dv(p, q)
n, a, b = list(map(int, input().split()))
ans = pow(2, n, mod) - 1 + mod * 10
if a <= n: ans -= comb(n, a)
if b <= n: ans -= comb(n, b)
print((ans % mod)) | def dv(x, y, mod):
# x / y = x * (y ** (mod - 2))
return x * pow(y, mod - 2, mod) % mod
def comb(n, r, mod):
# p / q = p * (q ** (mod - 2))
p, q = 1, 1
if n < r or n < 0 or r < 0: return 0
for i in range(r):
p = p * (n - i) % mod
q = q * (i + 1) % mod
return dv(p, q, mod)
mod = 1000000007
n, a, b = list(map(int, input().split()))
# pow(a, b, c) = (a ** b) % c
ans = pow(2, n, mod) - 1
if 0 <= n: ans -= comb(n, a, mod)
if 0 <= n: ans -= comb(n, b, mod)
print((ans % mod)) | p02768 |
n, a, b = list(map(int, input().split()))
MOD = 1000000007
def comb(n, r):
x = 1
y = 1
for i in range(r):
x = x * (n - i) % MOD
y = y * (i + 1) % MOD
return x * pow(y, MOD - 2, MOD) % MOD
ans = pow(2, n, MOD)
ans -= 1
ans -= comb(n, a)
ans -= comb(n, b)
while ans < 0:
ans += MOD
print(ans) | n, a, b = list(map(int, input().split()))
MOD = 1000000007
ans = pow(2, n, MOD)
ans -= 1
x = 1
y = 1
for i in range(b):
x = x * (n - i) % MOD
y = y * (i + 1) % MOD
if i == a - 1:
ans -= x * pow(y, MOD - 2, MOD) % MOD
ans -= x * pow(y, MOD - 2, MOD) % MOD
while ans < 0:
ans += MOD
print(ans)
| p02768 |
n, a, b = list(map(int, input().split(' ')))
# 二項係数 mod [検索]
mmm = 1000000000 + 7
fac = []
inv = []
inv_fac = []
def init(n):
fac.append(1)
fac.append(1)
inv.append(0)
inv.append(1)
inv_fac.append(1)
inv_fac.append(1)
for i in range(2, n):
fac.append(fac[-1] * i % mmm)
inv.append(mmm - inv[mmm%i] * (mmm // i) % mmm)
inv_fac.append(inv_fac[-1] * inv[-1] % mmm)
def choice(a, b):
if a < b:
return 0
v = 1
for i in range(b):
v = (v * (n-i)) % mmm
return v * inv_fac[b]
init(int(2e5) + 1)
ans = pow(2, n, mmm) - 1 # v, e, mod
bunshi = 1
for i in range(a):
bunshi = (bunshi * (n-i)) % mmm
ans -= choice(n, a)
ans -= choice(n, b)
print((ans % mmm))
'''
4, 1, 3 => 4c2 + 4c4 -> 6+1 = 7
4 + 6 + 4 + 1 - 4c1 - 4c2
1 1
11 2
121 4
1331 8
14641 16, 0が無いので-1, 大きい combination -> 二項係数 mod [検索]
''' | n, a, b = list(map(int, input().split(' ')))
# 二項係数 mod [検索]
mmm = 1000000000 + 7
fac = []
inv = []
inv_fac = []
def init(n):
fac.append(1)
fac.append(1)
inv.append(0)
inv.append(1)
inv_fac.append(1)
inv_fac.append(1)
for i in range(2, n):
fac.append(fac[-1] * i % mmm)
inv.append(mmm - inv[mmm%i] * (mmm // i) % mmm)
inv_fac.append(inv_fac[-1] * inv[-1] % mmm)
def choice(a, b):
if a < b:
return 0
v = 1
for i in range(b):
v = (v * (a-i)) % mmm # 偶然通っていたけどここはnではなくa (eの途中で気づいた)
return v * inv_fac[b]
init(int(2e5) + 1)
ans = pow(2, n, mmm) - 1 # v, e, mod
bunshi = 1
for i in range(a):
bunshi = (bunshi * (n-i)) % mmm
ans -= choice(n, a)
ans -= choice(n, b)
print((ans % mmm))
'''
4, 1, 3 => 4c2 + 4c4 -> 6+1 = 7
4 + 6 + 4 + 1 - 4c1 - 4c2
1 1
11 2
121 4
1331 8
14641 16, 0が無いので-1, 大きい combination -> 二項係数 mod [検索]
'''
| p02768 |
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def cmb(n, r, p):
a=1
for i in range(r):
a*=n
a%=mod
n-=1
b=1
for i in range(1,r+1):
b*=i
b%=mod
inv_b=mod_inv(b,mod)
# print(a,inv_b)
return a*inv_b
def pow_k(x, n):
"""
O(log n)
"""
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
K%=mod
x *= x
n //= 2
x%=mod
return (K * x)%mod
def extgcd(a,b):
r = [1,0,a]
w = [0,1,b]
while w[2]!=1:
q = r[2]//w[2]
r2 = w
w2 = [r[0]-q*w[0],r[1]-q*w[1],r[2]-q*w[2]]
r = r2
w = w2
#[x,y]
return [w[0],w[1]]
def mod_inv(a,m):
x = extgcd(a,m)[0]
return (m+x%m)%m
def main():
n,a,b=LI()
if n==2:
if a!=b:
return 0
else:
return 1
ans=pow_k(2,n)
ans-=(cmb(n,a,mod)%mod)
ans-=(cmb(n,b,mod)%mod)
ans-=1
ans%=mod
if ans<0:
ans+=mod
return ans
# main()
print((main()))
| import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
# n^p(mod m) -- START --
def powMod(n,p,m):
if p==0:
return 1
if p%2==0:
t=powMod(n,p//2,m)
return t*t%m
return n*powMod(n,p-1,m)%m
# n^p(mod m) --- END ---
def main():
n,a,b=LI()
ans=powMod(2,n,mod)
ans-=1
ans%=mod
pattern_a1=1
for i in range(a):
pattern_a1*=n-i
pattern_a1%=mod
pattern_a2=1
for i in range(1,a+1):
pattern_a2*=i
pattern_a2%=mod
pattern_a=pattern_a1*pow(pattern_a2,mod-2,mod)
pattern_b1=1
for i in range(b):
pattern_b1*=n-i
pattern_b1%=mod
pattern_b2=1
for i in range(1,b+1):
pattern_b2*=i
pattern_b2%=mod
pattern_b=pattern_b1*pow(pattern_b2,mod-2,mod)
ans-=pattern_a
ans%=mod
if ans<0:
ans+=mod
ans-=pattern_b
ans%=mod
if ans<0:
ans+=mod
return ans
# main()
print((main()))
| p02768 |
n,a,b=list(map(int,input().split()))
mod=10**9+7
def repmod(n,m):
if n==1:return 2
nn = n // 2
te = repmod(nn, m)
if n%2==0:
ans=(te*te)%mod
return ans
elif n%2==1:
ans=(2*te*te)%mod
return ans
def extgcd(a,b):
a0,b0=a,b
x0,y0=1,0
x1,y1=0,1
while b0!=0:
q = a0 // b0
r = a0 % b0
a0,b0=b0,r
temp=x1
x0,x1=x1,x0-q*x1
y0,y1=y1,y0-q*y1
return a0,x0,y0
def mo(x,m):
return (m+x%m)%m
def inv(a,m):
g,x,y=extgcd(a,m)
ans=mo(x,m)
return ans
total=repmod(n,mod)-1
c=max(a,b)
temp=1
s=0
for i in range(c):
temp=(temp*(n-i))%mod
invi=inv(i+1,mod)
temp=temp*invi
if i+1==a:
s+=temp
if i+1==b:
s+=temp
ans=(total-s)%mod
print(ans) | def inv(N):
#n^-1
inv=[1,1]
for i in range(2,N+1):
inv.append(mod-mod//i*inv[(mod%i)]%mod)
return inv
n,a,b=list(map(int,input().split()))
mod=10**9+7
def repmod(n,m):
if n==1:return 2
nn = n // 2
te = repmod(nn, m)
if n%2==0:
ans=(te*te)%mod
return ans
elif n%2==1:
ans=(2*te*te)%mod
return ans
total=repmod(n,mod)-1
c=max(a,b)
temp=1
s=0
invlist=inv(c)
for i in range(c):
temp=(temp*(n-i))%mod
invi=invlist[i+1]
temp=temp*invi
if i+1==a:
s+=temp
if i+1==b:
s+=temp
ans=(total-s)%mod
print(ans)
| p02768 |
n,a,b = list(map(int,input().split()))
mod = 10**9+7
import sys
sys.setrecursionlimit(10**9)
ans = 1
now = n
def power(x, y):
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y//2)**2 % mod
else : return power(x, y//2)**2 * x % mod
ans = power(2,n)
com = [0]*(b+1)
com[0]=1
N = b+1
inv_t = [0]+[1]
for i in range(2,N):
inv_t += [inv_t[mod % i] * (mod - int(mod / i)) % mod]
for i in range(1,b+1):
com[i] = ((com[i-1]*(n-i+1))%mod)*(inv_t[i])%mod
ans -= com[a]+com[b]+1
print((ans%mod)) | n,a,b = list(map(int,input().split()))
mod = 10**9+7
ans = pow(2,n,mod)-1
inv_t = [0]+[1]
for i in range(2,b+1):
inv_t += [inv_t[mod % i] * (mod - int(mod / i)) % mod]
nCk = [1]*(b+1)
for i in range(1,b+1):
nCk[i]=(((nCk[i-1]*(n-i+1))%mod)*inv_t[i])%mod
ans -= nCk[a]+nCk[b]
print((ans%mod)) | p02768 |
def d_bouquet(MOD=10**9 + 7):
N, A, B = [int(i) for i in input().split()]
from operator import mul
from functools import reduce
def cmb(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])
result %= MOD
return result
ans = pow(2, N, MOD) - 1
ans -= cmb(N, A)
ans -= cmb(N, B)
return (ans + MOD) % MOD
print((d_bouquet())) | from functools import reduce
def d_bouquet(MOD=10**9 + 7):
from functools import reduce
N, A, B = [int(i) for i in input().split()]
def comb(m, r):
numerator = reduce(lambda x, y: x * y % MOD, list(range(m, m - r, -1)))
denominator = reduce(lambda x, y: x * y % MOD, list(range(1, r + 1)))
return (numerator * pow(denominator, MOD - 2, MOD)) % MOD
return (pow(2, N, MOD) - 1 - (comb(N, A) + comb(N, B))) % MOD
print((d_bouquet())) | p02768 |
n, a, b = list(map(int, input().split()))
mod = 10 ** 9 + 7
if n == 2:
print((0))
exit()
S = pow(2, n, mod) -1
x1 = 1
y1 = 1
for i in range(a):
x1 = x1 * (n-i) % mod
y1 = y1 * (i+1) % mod
A = (x1 * pow(y1, mod - 2, mod)) % mod
x2 = 1
y2 = 1
for i in range(b):
x2 = x2 * (n-i) % mod
y2 = y2 * (i+1) % mod
B = (x2 * pow(y2, mod - 2, mod)) % mod
print(((S - A - B) % mod)) | n, a, b = list(map(int, input().split()))
mod = 10 ** 9 + 7
if n == 2:
print((0))
exit()
S = pow(2, n, mod) - 1
x1 = 1
y1 = 1
for i in range(a):
x1 = x1 * (n-i) % mod
y1 = y1 * (i+1) % mod
A = (x1 * pow(y1, mod - 2, mod)) % mod
for i in range(a, b):
x1 = x1 * (n-i) % mod
y1 = y1 * (i+1) % mod
B = (x1 * pow(y1, mod - 2, mod)) % mod
print(((S - A - B) % mod)) | p02768 |
n, a, b = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def power_func(a, n, mod):
bi = bin(n)[2:]
res = 1
for i in range(len(bi)):
res = (res * res) % mod
if bi[i] == "1":
res = (res * a) % mod
return res
def modinv(a, mod):
return pow(a, mod-2, mod)
def combination(n, r, mod):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
def main():
ans = power_func(a=2, n=n, mod=MOD) - 1
ans -= combination(n=n, r=a, mod=MOD)
ans -= combination(n=n, r=b, mod=MOD)
ans %= MOD
print(ans)
if __name__ == "__main__":
main() | n, a, b = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def comb(n,r, mod):
res = 1
fac = 1
for i in range(r):
res *= n-i
res %= mod
fac *= i+1
fac %= mod
return res * pow(fac, mod-2, mod) % mod
def main():
ans = pow(2, n, MOD) - 1
ans -= comb(n=n, r=a, mod=MOD)
ans -= comb(n=n, r=b, mod=MOD)
ans %= MOD
print(ans)
if __name__ == "__main__":
main() | p02768 |
n, a, b = list(map(int, input().split()))
mod = int(1e+9) + 7
def extgcd(a, b):
if b == 0:
return 1, 0
else:
x, y, u, v, k, l = 1, 0, 0, 1, a, b
while l != 0:
x, y, u, v = u, v, x - u * (k // l), y - v * (k // l)
k, l = l, k % l
return x
def inved(x):
a = extgcd(x, mod)
return a % mod
def doubling(N, M):
y = 1
base = N
while M != 0:
if M % 2 == 1:
y *= base
y %= mod
base *= base
base %= mod
M //= 2
return y
A = doubling(2, n)
A = (A - 1) % mod
proda, prodb = 1, 1
for i in range(a):
proda *= ((n - i) * inved(i + 1)) % mod
proda %= mod
for i in range(b):
prodb *= ((n - i) * inved(i + 1)) % mod
prodb %= mod
print(((A - proda - prodb) % mod)) | n, a, b = list(map(int, input().split()))
mod = int(1e+9) + 7
def extgcd(a, b):
if b == 0:
return 1, 0
else:
x, y, u, v, k, l = 1, 0, 0, 1, a, b
while l != 0:
x, y, u, v = u, v, x - u * (k // l), y - v * (k // l)
k, l = l, k % l
return x
def inved(x):
a = extgcd(x, mod)
return a % mod
def doubling(N, M):
y = 1
base = N
while M != 0:
if M % 2 == 1:
y *= base
y %= mod
base *= base
base %= mod
M //= 2
return y
S = [inved(i+1) for i in range(b)]
A = doubling(2, n)
A = (A - 1) % mod
proda, prodb = 1, 1
for i in range(a):
proda *= ((n - i) * S[i]) % mod
proda %= mod
for i in range(b):
prodb *= ((n - i) * S[i]) % mod
prodb %= mod
print(((A - proda - prodb) % mod)) | p02768 |
n, a, b = list(map(int, input().split()))
p = 10**9+7
def comb(n, a):
ans = 1
for i in range(1, a + 1):
ans = ans * (n - i + 1) * pow(i, p - 2, p) % p
return ans
ans = (pow(2, n, p)-1-comb(n, a)-comb(n, b)) % p
print(ans)
| class Comb0():
# あらかじめO(k)の前計算をしておいてr<=kに対してnCrを高速に計算する
def __init__(self, n, k=10**6, p=10**9+7):
# num[i]=nPi
# den[i]=(i!)^(-1)
num, den = [1], [1]
a, b = 1, 1
for i in range(1, k+1):
a = (a*(n-i+1)) % p
b = (b*pow(i, p-2, p)) % p
num.append(a)
den.append(b)
self.num = num
self.den = den
self.n = n
self.p = p
def calc(self, r):
num, den = self.num, self.den
if r < 0 or self.n < r:
return 0
return (num[r] * den[r]) % self.p
n, a, b = list(map(int, input().split()))
p = 10**9+7
cmb = Comb0(n, k=max(a, b))
print(((pow(2, n, p)-1-cmb.calc(a)-cmb.calc(b)) % p))
| p02768 |
from itertools import product
def check_odd(i, j):
return (i + j) % 2 == 0
def check_even(i, j):
return i % 2 == 0
def solve(n, d1, d2):
s1, s2 = 0, 0
while d1 % 4 == 0:
d1 >>= 2
s1 += 1
while d2 % 4 == 0:
d2 >>= 2
s2 += 1
f1 = check_odd if d1 % 2 else check_even
f2 = check_odd if d2 % 2 else check_even
lim = n ** 2
buf = []
cnt = 0
for i, j in product(list(range(2 * n)), repeat=2):
if f1(i >> s1, j >> s1) and f2(i >> s2, j >> s2):
buf.append('{} {}'.format(i, j))
cnt += 1
if cnt == lim:
break
return buf
n, d1, d2 = list(map(int, input().split()))
print(('\n'.join(solve(n, d1, d2))))
| def check_odd(i, j):
return (i + j) % 2 == 0
def check_even(i, j):
return i % 2 == 0
def solve(n, d1, d2):
s1, s2 = 0, 0
while d1 % 4 == 0:
d1 >>= 2
s1 += 1
while d2 % 4 == 0:
d2 >>= 2
s2 += 1
f1 = check_odd if d1 % 2 else check_even
f2 = check_odd if d2 % 2 else check_even
lim = n ** 2
buf = []
cnt = 0
for i in range(2 * n):
_i1 = i >> s1
_i2 = i >> s2
for j in range(2 * n):
if f1(_i1, j >> s1) and f2(_i2, j >> s2):
buf.append('{} {}'.format(i, j))
cnt += 1
if cnt == lim:
return buf
n, d1, d2 = list(map(int, input().split()))
print(('\n'.join(solve(n, d1, d2))))
| p03334 |
from collections import deque
n=int(eval(input()))
alpha=['a','b','c','d','e','f','g','h','i','j','k']
q=deque(['a'])
for i in range(n-1):
qi_ans=[]
while(len(q)>0):
qi=q.popleft()
qiword_maxind=0
for j in range(len(qi)):
qi_ans.append(qi+qi[j])
qij_ind=alpha.index(qi[j])
if(qiword_maxind<qij_ind):
qiword_maxind=qij_ind
else:
qi_ans.append(qi+alpha[qiword_maxind+1])
qi_ans=sorted(list(set(qi_ans)))
# print(qi_ans)
q.extend(qi_ans)
lenq=len(q)
for i in range(lenq):
print((q.popleft()))
| from collections import deque
n=int(eval(input()))
alpha=list('abcdefghijk')
q=deque([])
q.append(alpha[0])
for i in range(1,n):
qi=deque([])
while(len(q)>0):
qij=q.popleft()
qij_setnum=len(set(list(qij)))
for j in range(qij_setnum+1):
qi.append(qij+alpha[j])
q=qi
q=list(q)
q.sort()
for i in range(len(q)):
print((q[i])) | p02744 |
n = int(input())
r = 'a',
for _ in range(n - 1):
r = [s + c for s in r for i, c in enumerate(s + chr(ord(max(s)) + 1)) if c not in s[:i]]
print(*r, sep='\n')
| n = int(input())
r = 'a',
for _ in range(n - 1):
r = [s + c for s in r for c in set(s + chr(ord(max(s)) + 1))]
print(*sorted(r), sep='\n')
| p02744 |
from itertools import groupby
n = int(input())
r = 'a',
for _ in range(n - 1):
r = [s + c for s in r for c, _ in groupby(sorted(s) + [chr(ord(max(s)) + 1)])]
print(*r, sep='\n')
| n = int(input())
r = 'a',
for _ in range(n - 1):
r = [s + c for s in r for c in set(s + chr(ord(max(s)) + 1))]
print(*sorted(r), sep='\n')
| p02744 |
from collections import *
def dfs(now):
if len(now)==N:
print((''.join(now)))
return
for i in range(ord(max(now))-ord('a')+2):
now.append(alpha[i])
dfs(now)
now.pop()
N = int(eval(input()))
alpha = 'abcdefghijklmnopqrstuvwxyz'
dfs(deque(['a'])) | from collections import *
def dfs(l):
if len(l)==N:
print((''.join(l)))
return
for a in range(ord('a'), ord(max(l))+2):
l.append(chr(a))
dfs(l)
l.pop()
N = int(eval(input()))
dfs(deque(['a'])) | p02744 |
from collections import *
def dfs(l):
if len(l)==N:
print((''.join(l)))
return
for a in range(ord('a'), ord(max(l))+2):
l.append(chr(a))
dfs(l)
l.pop()
N = int(eval(input()))
dfs(deque(['a'])) | from collections import *
def dfs(q):
if len(q)==N:
print((''.join(q)))
return
M = 'a'
for qi in q:
M = max(M, qi)
for i in range(ord(M)-ord('a')+2):
q.append(alpha[i])
dfs(q)
q.pop()
N = int(eval(input()))
alpha = 'abcdefghijklmnopqrstuvwxyz'
dfs(deque(['a'])) | p02744 |
N = int(eval(input()))
def dfs(x):
if len(x) == N:
s = "".join(chr(v + ord("a")) for v in x)
print(s)
return
val = max(x)
for i in range(val + 2):
x.append(i)
dfs(x)
x.pop()
dfs([0])
|
N = int(eval(input()))
def func(x):
if len(x) == N:
print(("".join(x)))
return
last = ord(max(x)) - ord("a") + 1 if x else 0
for i in range(min(26, last) + 1):
x.append(chr(ord("a") + i))
func(x)
x.pop()
func([])
| p02744 |
import math
def div_with_mod(x, y, mod):
# Fermat's little theorem
return x*pow(y, mod - 2, mod)
def comb(n, r, mod):
# calculates C(n,r) with mod (assuming mod is prime)
nc = n
for rc in range(1, r):
nc -= 1
n = n*nc % mod
r = r*rc % mod
return div_with_mod(n, r, mod)
def solve():
N = int(input())
# ord("a") Unicode コードポイントを返す
codepoint = ord("a")
def dfs(word, dep):
if len(word) == N:
return print(word)
for i in range(dep):
dfs(word + chr(codepoint+i), dep)
dfs(word + chr(codepoint+dep), dep+1)
dfs("a", 1)
# Solve
if __name__ == "__main__":
solve()
| def solve():
N = int(input())
# ord("a") Unicode コードポイントを返す
codepoint = ord("a")
# たどるグラフの深さ
i = 1
# 標準形文字列とその次の辞書順
ans = [["a", 1]]
# 一つづつ潜る
while i < N:
# 次の深さをtmpとする
tmp = []
# 各ノード
for w, j in ans:
# 辞書順で追加していく
for k in range(j+1):
if k != j:
tmp.append([w + chr(codepoint+k), j])
# 辞書順のインクリメント
else:
tmp.append([w + chr(codepoint+k), j+1])
ans = tmp
i += 1
[print(a[0]) for a in ans]
# Solve
if __name__ == "__main__":
solve()
| p02744 |
from itertools import permutations
N = int(eval(input()))
ans = []
for p in permutations(list(range(N))):
D = [-1] * N
A = []
for i in range(N):
for j in range(N):
if D[j] < p[i]:
D[j] = p[i]
A.append(j)
break
ans.append(tuple(A))
ans = sorted(set(ans))
for a in ans:
s = ''.join([chr(x+97) for x in a])
print(s) | N = int(eval(input()))
def f(s):
if len(s) == N:
print(s)
return
for i in range(97, ord(max(list(s)))+1+1):
ns = s + chr(i)
f(ns)
f('a') | p02744 |
from itertools import product
N = int(input())
X = [chr(ord('a') + i) for i in range(N)]
first_presence = {x: i for x, i in zip(X, list(range(N)))}
ans = ['a']
R = ['a']
# 何文字目以降を変更するか
for i in range(1, N):
nr = []
for r in R:
mr = max(r)
for x in X:
nr.append(r + x)
if mr == x:
break
nr.append(r + chr(ord(mr) + 1))
R = nr
ans = list(set(R))
ans.sort()
print(*ans, sep="\n")
| N = int(input())
X = [chr(ord('a') + i) for i in range(N)]
first_presence = {x: i for x, i in zip(X, list(range(N)))}
R = ['a']
for i in range(1, N):
next_r = []
for r in R:
max_s = max(r)
for x in X[:first_presence[max_s] + 2]:
next_r.append(r + x)
R = next_r
ans = R
ans.sort()
print(*ans, sep="\n")
| p02744 |
# D - String Equivalence
from string import ascii_lowercase
def dfs(n: int) -> list:
if n == 1:
return ["a"]
cur = dfs(n - 1)
result = []
for s in cur:
for c in ascii_lowercase[: len(set(s)) + 1]:
result.append(s + c)
return result
def main():
N = int(eval(input()))
result = dfs(N)
result.sort()
print(("\n".join(result)))
if __name__ == "__main__":
main()
| # D - String Equivalence
abc = "abcdefghij"
def dfs(n: int) -> list:
if n == 1:
return ["a"]
cur = dfs(n - 1)
result = []
for s in cur:
for c in abc[: len(set(s)) + 1]:
result.append(s + c)
return result
def main():
N = int(eval(input()))
result = dfs(N)
result.sort()
print(("\n".join(result)))
if __name__ == "__main__":
main()
| p02744 |
from itertools import product
N = int(eval(input()))
added = set()
ans = []
a = [[chr(97+i) for i in range(j)] for j in range(1,N+1)]
for x in product(*a):
appeared = set('a')
d = ['a']
temp = [0]
for y in x[1:]:
if y not in appeared:
appeared.add(y)
d.append(y)
temp.append(d.index(y))
else:
temp.append(d.index(y))
t = tuple(temp)
if t not in added:
print((''.join(x)))
added.add(t) | def dfs(s,n):
if len(s) == n:
print(s)
else:
for i in range(len(set(s))+1):
dfs(''.join([s,chr(97+i)]),n)
N = int(eval(input()))
dfs('a',N) | p02744 |
import copy
def make(n, data):
out = []
# print(ord(data[-1]) + 1 - ord("a"))
key = data[1]
for i in range(key + 1):
# print(key)
out.append([data[0] + chr(ord("a") + i), max(key, i + 1)])
return out
n = int(eval(input()))
ans = [["a", 1]]
for i in range(1, n):
tmp = []
for j in range(len(ans)):
tmp += make(i + 1, ans[j])
# print
if len(tmp) >= 1:
ans = copy.deepcopy(tmp)
# print(ans)
for i in ans:
print((i[0])) | def solve(n, s, mx):
# print(n, s, mx)
if n == 0:
print(s)
else:
for i in range(mx):
solve(n - 1, s + chr(ord("a") + i), max(mx, i + 2))
n = int(eval(input()))
solve(n - 1, 'a', 2) | p02744 |
def dfs(a='', b=chr(ord('a'))):
if len(a) == N:
print(a)
else:
i = chr(ord('a'))
while i < b:
dfs(a + i, b)
i = chr(ord(i) + 1)
dfs(a + b, chr(ord(b) + 1))
N = int(eval(input()))
dfs() | def dfs(a='', b='a'):
if len(a) == N:
print(a)
else:
i = 'a'
while i < b:
dfs(a + i, b)
i = chr(ord(i) + 1)
dfs(a + b, chr(ord(b) + 1))
N = int(eval(input()))
dfs() | p02744 |
import itertools
import bisect
def main():
N = int(eval(input()))
letterset = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
check = []
for i in range(1, N+1):
iters = itertools.product(letterset[:i], repeat=N)
for tmp in iters:
if len(set(tmp)) == i:
flag = True
if tmp[0] != 'a':
flag = False
for k in range(N-1):
if not tmp[k+1] in letterset[:len(set(tmp[:k+1]))+1]:
flag = False
if flag:
check.append(''.join(tmp))
check.sort()
for ans in check:
print(ans)
if __name__ == "__main__":
main()
| import sys
sys.setrecursionlimit(10**7)
strlist = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
def dfs(n, before):
lensetbefore = len(set(before))
if n == 1:
print(before)
if n > 1:
for s in strlist[:lensetbefore+1]:
dfs(n-1, before+s)
def main():
N = int(eval(input()))
dfs(N, 'a')
if __name__ == "__main__":
main()
| p02744 |
n=int(input())-1
l=[[] for _ in range(10)]
l[0].append('a')
for i in range(n):
for w in l[i]:
s = sorted(set(w))
for c in s:
l[i+1].append(w+c)
l[i+1].append(w+chr(ord(s[-1])+1))
print(*l[n],sep='\n')
| a='a'
for _ in range(int(input())-1):
a=[s+c for s in a for c in sorted(set(s+chr(ord(max(s))+1)))]
print(*a,sep='\n')
| p02744 |
N = int(input())
s = set()
def solve(n):
global s
if n == N:
return
if len(s) == 0:
s.add('a')
solve(n+1)
else:
new_s = set()
for v in s:
xc = chr(ord(max(v))+1)
for vc in v:
new_s.add(v + vc)
new_s.add(v + xc)
s = new_s
solve(n+1)
solve(0)
ans = sorted(s)
print(*ans, sep='\n')
| N = int(input())
s = {'a'}
def solve(n):
global s
if n == N:
return
new_s = set()
for v in s:
xc = chr(ord(max(v))+1)
for vc in v:
new_s.add(v + vc)
new_s.add(v + xc)
s = new_s
solve(n+1)
solve(1)
ans = sorted(s)
print(*ans, sep='\n')
| p02744 |
n = int(eval(input()))
L = [0]*n
for i in range(n):
L[i] = chr(i+ord('a'))
#print(L)_
ans = []
def dfs(A):
if len(A) == n:
ans.append(''.join(A))
return
for v in L[0:len(set(A))+1]:
A.append(v)
dfs(A)
A.pop()
dfs([])
ans.sort()
for i in range(len(ans)):
print((ans[i]))
| n = int(eval(input()))
ans = []
def dfs(A):
if len(A) == n:
ans.append(''.join(A))
return
for i in range(len(set(A))+1):
v = chr(i+ord('a'))
A.append(v)
dfs(A)
A.pop()
dfs([])
ans.sort()
for i in range(len(ans)):
print((ans[i]))
| p02744 |
def cur(n):
if ans[n]!=[]: return ans[n]
for x in cur(n-1):
tmp1=[0]+[x[i] for i in range(n-1)]
tmp2=[0]+[x[i]+1 for i in range(n-1)]
ans[n].append(tmp1)
ans[n].append(tmp2)
if max(x)!=0:
for k in range(1,max(x)+1):
tmp3=[0]+[x[i] for i in range(n-1)]
for i in range(1,n):
if tmp3[i]==k: tmp3[i]=0
elif tmp3[i]<k: tmp3[i]+=1
ans[n].append(tmp3)
return ans[n]
def pri(x):
s=""
for i in range(p):
s+=chr( ord("a")+x[i] )
print(s)
p=int(eval(input()))
ans=[[] for i in range(11)]
ans[1]=[[0]]
ans[2]=[[0,0],[0,1]]
cur(p)
ans[p].sort()
pri(ans[p][0])
for i in range(1,len(ans[p])):
if ans[p][i]!=ans[p][i-1]: pri(ans[p][i])
| n=int(eval(input()))
def cur(x):
if len(x)==n:
s="".join([chr( ord("a")+x[i]) for i in range(n)])
print(s)
else:
for i in range(max(x)+2):
cur(x+[i])
cur([0]) | p02744 |
from collections import deque
N = int(eval(input()))
alphabet = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
unvisited = deque(alphabet[0 : N])
visited = deque()
st = deque([["a", visited, unvisited]]) # stack
while len(st) > 0:
str, visited, unvisited = st.popleft()
if str[-1] not in visited:
visited.append(str[-1])
unvisited.popleft()
if len(str) == N:
print(str)
else:
# すでに使った文字を使う
for x in visited:
st.append([str + x, deque(visited), deque(unvisited)])
# まだ使っていない文字を使う
if len(unvisited) > 0:
x = unvisited[0]
st.append([str + x, deque(visited), deque(unvisited)])
| from collections import deque
N = int(eval(input()))
alphabet = "abcdefghij"
visited = 1
st = deque([["a", visited]])
while len(st) > 0:
str, visited = st.popleft()
if len(str) == N:
print(str)
else:
# すでに使った文字を使う
for x in alphabet[0 : visited]:
st.append([str + x, visited])
# まだ使っていない文字を使う
# len(str) < Nだから、visited < N
st.append([str + alphabet[visited], visited + 1])
| p02744 |
from collections import deque
N = int(eval(input()))
alphabet = "abcdefghij"
visited = 1
st = deque([["a", visited]])
while len(st) > 0:
str, visited = st.popleft()
if len(str) == N:
print(str)
else:
# すでに使った文字を使う
for x in alphabet[0 : visited]:
st.append([str + x, visited])
# まだ使っていない文字を使う
# len(str) < Nだから、visited < N
st.append([str + alphabet[visited], visited + 1])
| from collections import deque
N = int(eval(input()))
alphabet = "abcdefghij"
visited = 1
st = deque([("a", visited)])
while len(st) > 0:
str, visited = st.popleft()
if len(str) == N:
print(str)
else:
# すでに使った文字を使う
for x in alphabet[0 : visited]:
st.append((str + x, visited))
# まだ使っていない文字を使う
# len(str) < Nだから、visited < N
st.append((str + alphabet[visited], visited + 1)) | p02744 |
N = int(eval(input()))
def DFS(N, S):
if len(S) == N:
print(S)
else:
next_chrs = []
if S:
next_max_chr = ord(max(S)) + 1
else:
next_max_chr = ord("a")
for i in range(0, next_max_chr - ord("a") + 1):
DFS(N, "".join([S, chr(ord("a") + i)]))
DFS(N, "") | N = int(eval(input()))
def DFS(N, S):
if len(S) == N:
print(S)
else:
if S:
next_max_chr = ord(max(S)) + 1
else:
next_max_chr = ord("a")
for i in range(0, next_max_chr - ord("a") + 1):
DFS(N, S + chr(ord("a") + i))
DFS(N, "") | p02744 |
def dfs(n):
adj = [chr(i+97) for i in range(26)]
stack = ['a']
while stack:
node = stack.pop(0)
if len(node) == n:
print(node)
else:
limit = ord(max(node))%97+2
for child in adj[:limit]:
stack.append(node+child)
return -1
def main():
import sys
def input(): return sys.stdin.readline().rstrip()
n = int(eval(input()))
dfs(n)
if __name__ == '__main__':
main() | def dfs(s,n,adj):
adj = 'abcdefghij'
if len(s) == n:
print(s)
else:
for child in adj[:len(set(s))+1]:
dfs(s+child,n,adj)
return -1
def main():
import sys
def input(): return sys.stdin.readline().rstrip()
n = int(eval(input()))
adj = 'abcdefghij'
dfs('a',n,adj)
if __name__ == '__main__':
main() | p02744 |
N = int(eval(input()))
import itertools
from collections import deque
ans = deque()
l = []
r = deque()
for i in range(N):
l.append(chr(97+i))
r.append(l.copy())
p = [[] for _ in range(N)]
p[0].append('a')
for i in range(1,N):
for j in r[i]:
for k in p[i-1]:
p[i].append(k+j)
p = p[-1]
for i in p:
a = [0]*10
for j in i:
x = ord(j)-97
a[x]=1
if x==0:
judge = True
continue
elif a[x-1]==1:
judge = True
continue
else:
judge = False
break
if judge:
ans.append(i)
ans = set(ans)
ans = sorted(list(ans))
for a in ans:
print(a) | N = int(eval(input()))
from collections import deque
import itertools
ans = deque()
l = []
r = deque()
for i in range(N):
l.append(chr(97+i))
r.append(l.copy())
p = [[[] for _ in range(N)] for _ in range(N)]
p[0][0].append('a')
for i in range(1,N):
for j in r[i]:
x = ord(j)-97
for n,k in enumerate(p[i-1][max(0,x-1):],max(0,x-1)):
for m in k:
p[i][max(n,x)].append(m+j)
p = p[-1]
p = list(itertools.chain.from_iterable(p))
p = sorted(p)
for q in p:
print(q) | p02744 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.