input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
#D
def main():
mod=1000000007
x,y=list(map(int,input().split()))
k=min(x,y//2)
l=min(x//2,y)
n=k+l
Fact=[1]
for i in range(1,n+1):
Fact.append(Fact[i-1]*i%mod)
Finv=[0]*(n+1) #階乗の逆元
Finv[-1]=pow(Fact[-1],mod-2,mod)
for i in range(n-1,-1,-1):
Finv[i]=Finv[i+1]*(i+1)%mod
def comb(n,r):
if n<r:
return 0
return Fact[n]*Finv[r]*Finv[n-r]%mod
ans=0
for a in range(k+1):
if (x-a)%2!=0:
continue
if (x-a)//2==y-2*a:
b=(x-a)//2
ans+=comb(a+b,a)
ans%=mod
print(ans)
if __name__=='__main__':
main() | def main():
mod=1000000007
x,y=list(map(int,input().split()))
if (x+y)%3:
return 0
n=(x+y)//3
Fact=[1]
for i in range(1,n+1):
Fact.append(Fact[i-1]*i%mod)
Finv=[0]*(n+1)
Finv[-1]=pow(Fact[-1],mod-2,mod)
for i in range(n-1,-1,-1):
Finv[i]=Finv[i+1]*(i+1)%mod
def comb(n,r):
if n<r:
return 0
return Fact[n]*Finv[r]*Finv[n-r]%mod
a=(-x+2*y)//3
b=(x*2-y)//3
if a<0 or b<0:
return 0
return comb(a+b,a)
if __name__=='__main__':
print((main())) | p02862 |
import sys
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])
return result
x,y = list(map(int,input().split()))
MOD = 10**9 + 7
MAX = max(x,y)
MIN = min(x,y)
if (2*MAX - MIN) % 3 != 0 or MAX / MIN > 2:
print((0))
sys.exit()
c1 = (2*MAX - MIN) // 3
c2 = MAX - 2*c1
c1 %= MOD
c2 %= MOD
ans = cmb(c1 + c2 , c1)
print((ans%MOD))
| import math
import sys
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
x,y = list(map(int,input().split()))
min_xy = min(x,y)
max_xy = max(x,y)
MOD = 10**9+7
if max_xy / min_xy == 2.0:
print((1))
sys.exit()
if max_xy / min_xy > 2.0:
print((0))
sys.exit()
if max_xy == min_xy and max_xy % 3 != 0:
print((0))
sys.exit()
if max_xy == min_xy and max_xy % 3 == 0:
print((cmb(2 * max_xy//3, max_xy//3)))
sys.exit()
for i in range(min_xy//3+1):
if (max_xy-3*i) / (min_xy-3*i) == 2.0:
print((cmb(2*i + (min_xy-3*i),i)%MOD))
sys.exit()
print((0))
| p02862 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from math import factorial
from math import floor
P = int(1e9)+7
def c(n, m, P):
ch = 1
for i in range(m):
ch *= (n-i)
ch %= P
b = factorial(m)
b = pow(b, P-2, P)
return ch*b%P
def main():
x, y = list(map(int, readline().split()))
a = (2*y-x)/3
b = (2*x-y)/3
if (a < 0) or (b < 0):
print((0))
return
if floor(a)-a != 0:
print((0))
return
if floor(b)-b != 0:
print((0))
return
a = int(a)
b = int(b)
print((c(a+b, a, P)))
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from math import factorial
def main():
x, y = list(map(int, readline().split()))
if ((2*y-x)%3) or ((2*x-y)%3):
print((0))
return
a = (2*y-x)//3
b = (2*x-y)//3
if a < 0:
print((0))
return
if b < 0:
print((0))
return
P = int(1e9)+7
def c(n, m):
ch = 1
for i in range(m):
ch *= (n-i)
ch %= P
b = factorial(m)
b = pow(b, P-2, P)
return ch*b%P
print((c(a+b, a)))
if __name__ == '__main__':
main()
| p02862 |
mod=10**9+7
##mod,nについての制約は自分でいかに記入する
def pow_cal(x,n,mod):
if n==0:
return 1
elif n==1:
return x%mod
elif n>=2:
if n%2==0:
return (pow_cal(x,n//2,mod)**2)%mod
else:
return (x*pow_cal(x,n//2,mod)**2)%mod
def find_power(n,mod):
# 0!からn!までのびっくりを出してくれる関数(ただし、modで割った値に対してである）
powlist=[0]*(n+1)
powlist[0]=1
powlist[1]=1
for i in range(2,n+1):
powlist[i]=powlist[i-1]*i%(mod)
return powlist
def find_inv_power(n,mod):
#0!からn!までの逆元を素数modで割ったあまりリストを作る関数
c=1
uselist=[0 for i in range(n+1)]
for i in range(1,n+1):
c*=i
c%=mod
first=pow_cal(c,mod-2,mod)
uselist[n]=first
for i in range(n,0,-1):
uselist[i-1]=(uselist[i]*i)%(mod)
return uselist
A=find_power(10**6,mod)
B=find_inv_power(10**6,mod)
def combi(n,r,mod):
if n<r:
return 0
elif n>=r:
return (A[n]*B[r]*B[n-r])%(mod)
x,y=list(map(int,input().split()))
if (x+y)%3!=0:
print((0))
else:
J=(2*y-x)//3
K=(2*x-y)//3
if J>=0 and K>=0:
print((combi(J+K,J,mod)))
else:
print((0)) | def find_power(n):
# 0!からn!までのびっくりを出してくれる関数
powlist=[0]*(n+1)
powlist[0]=1
powlist[1]=1
for i in range(2,n+1):
powlist[i]=powlist[i-1]*i%(10**9+7)
return powlist
def find_inv_power(n):
#0!からn!までの逆元を10**9+7で割ったあまりリストを作る関数
powlist=find_power(n)
check=powlist[-1]
first=1
uselist=[0]*(n+1)
secondlist=[0]*30
secondlist[0]=check
secondlist[1]=check**2
for i in range(28):
secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7)
a=format(10**9+5,"b")
for j in range(30):
if a[29-j]=="1":
first=(first*secondlist[j])%(10**9+7)
uselist[n]=first
for i in range(n,0,-1):
uselist[i-1]=(uselist[i]*i)%(10**9+7)
return uselist
def combi(a,b,n,r,mod):
if n<r:
return 0
elif n>=r:
return (a[n]*b[r]*b[n-r])%(mod)
x,y=list(map(int,input().split()))
power=find_power(666670)
invpower=find_inv_power(666670)
if (2*x-y)%3==0 and (2*y-x)%3==0:
if (2*x-y)>=0 and (2*y-x)>=0:
a=(2*y-x)//3
b=(2*x-y)//3
print((combi(power,invpower,a+b,b,10**9+7)))
else:
print((0))
else:
print((0))
| p02862 |
class Factorial():
def __init__(self, mod=10**9 + 7):
self.mod = mod
self._factorial = [1]
self._size = 1
self._factorial_inv = [1]
self._size_inv = 1
def __call__(self, n):
return self.fact(n)
def fact(self, n):
''' n! % mod '''
if n >= self.mod:
return 0
self._make(n)
return self._factorial[n]
def fact_inv(self, n):
''' n!^-1 % mod '''
if n >= self.mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
self._make_inv(n)
return self._factorial_inv[n]
def comb(self, n, r):
''' nCr % mod '''
if r > n:
return 0
t = self.fact_inv(n-r)*self.fact_inv(r) % self.mod
return self(n)*t % self.mod
def comb_with_repetition(self, n, r):
''' nHr % mod '''
t = self.fact_inv(n-1)*self.fact_inv(r) % self.mod
return self(n+r-1)*t % self.mod
def perm(self, n, r):
''' nPr % mod '''
if r > n:
return 0
return self(n)*self.fact_inv(n-r) % self.mod
@staticmethod
def xgcd(a, b):
'''
Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
'''
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(self, n):
g, x, _ = self.xgcd(n, self.mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % self.mod
def _make(self, n):
if n >= self.mod:
n = self.mod
if self._size < n+1:
for i in range(self._size, n+1):
self._factorial.append(self._factorial[i-1]*i % self.mod)
self._size = n+1
def _make_inv(self, n):
if n >= self.mod:
n = self.mod
self._make(n)
if self._size_inv < n+1:
for i in range(self._size_inv, n+1):
self._factorial_inv.append(self.modinv(self._factorial[i]))
self._size_inv = n+1
x, y = sorted(map(int, input().split()))
comb = Factorial().comb
q, r = divmod(x+y, 3)
if r != 0:
print((0))
else:
print((comb(q, y-q)))
| MOD = 10**9 + 7
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, mod):
g, x, y = xgcd(a, mod)
assert g == 1, 'modular inverse does not exist'
return x % mod
factorials = [1]
def factorial(n, mod):
# n! % mod
assert n >= 0, 'Argument Error! n is "0 <= n".'
if len(factorials) < n+1:
for i in range(len(factorials), n+1):
factorials.append(factorials[-1]*i % mod)
return factorials[n]
def comb(n, r, mod):
# nCr % mod
assert n >= 0, 'Argument Error! n is "0 <= n".'
assert n >= r >= 0, 'Argument Error! r is "0 <= r <= n".'
return perm(n, r, mod) * modinv(factorial(r, mod), mod) % mod
def perm(n, r, mod):
# nPr % mod
assert n >= 0, 'Argument Error! n is "0 <= n".'
assert n >= r >= 0, 'Argument Error! r is "0 <= r <= n".'
return factorial(n, mod) * modinv(factorial(n-r, mod), mod) % mod
x, y = sorted(map(int, input().split()))
MOD = 10 ** 9 + 7
q, r = divmod(x+y, 3)
if r != 0:
print((0))
else:
try:
print((comb(q, y - q, MOD)))
except AssertionError:
print((0)) | p02862 |
class Factorial():
def __init__(self, mod=10**9 + 7):
self.mod = mod
self._factorial = [1]
self._size = 1
self._factorial_inv = [1]
self._size_inv = 1
def fact(self, n):
''' n! % mod '''
if n >= self.mod:
return 0
if self._size < n+1:
for i in range(self._size, n+1):
self._factorial.append(self._factorial[i-1]*i % self.mod)
self._size = n+1
return self._factorial[n]
def fact_inv(self, n):
''' n!^-1 % mod '''
if n >= self.mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
if self._size < n+1:
for i in range(self._size, n+1):
self._factorial.append(self._factorial[i-1]*i % self.mod)
self._size = n+1
if self._size_inv < n+1:
for i in range(self._size_inv, n+1):
self._factorial_inv.append(self.modinv(self._factorial[i]))
self._size_inv = n+1
return self._factorial_inv[n]
def comb(self, n, r):
''' nCr % mod '''
if r > n:
return 0
t = self.fact(n) * self.fact_inv(n-r) % self.mod
t = t * self.fact_inv(r) % self.mod
return t
@staticmethod
def xgcd(a, b):
'''
Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
'''
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(self, n):
g, x, _ = self.xgcd(n, self.mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % self.mod
x, y = sorted(map(int, input().split()))
q, r = divmod(x+y, 3)
if r != 0:
print((0))
else:
fact = Factorial()
print((fact.comb(q, y-q)))
| mod = 10**9 + 7
_factorial = [1]
def fact(n):
''' n! % mod '''
if n >= mod:
return 0
_size = len(_factorial)
if _size < n+1:
for i in range(_size, n+1):
_factorial.append(_factorial[i-1]*i % mod)
return _factorial[n]
_factorial_inv = [1]
def fact_inv(n):
''' n!^-1 % mod '''
if n >= mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
_size = len(_factorial)
if _size < n+1:
for i in range(_size, n+1):
_factorial.append(_factorial[i-1]*i % mod)
_size_inv = len(_factorial_inv)
if _size_inv < n+1:
for i in range(_size_inv, n+1):
_factorial_inv.append(modinv(_factorial[i]))
return _factorial_inv[n]
def comb(n, r):
''' nCr % mod '''
if r > n:
return 0
t = fact(n) * fact_inv(n-r) % mod
t = t * fact_inv(r) % mod
return t
def xgcd(a, b):
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(n):
g, x, _ = xgcd(n, mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % mod
x, y = sorted(map(int, input().split()))
q, r = divmod(x+y, 3)
if r != 0:
print((0))
else:
print((comb(q, y-q)))
| p02862 |
mod = 10**9 + 7
_factorial = [1]
def fact(n):
''' n! % mod '''
if n >= mod:
return 0
_size = len(_factorial)
if _size < n+1:
for i in range(_size, n+1):
_factorial.append(_factorial[i-1]*i % mod)
return _factorial[n]
_factorial_inv = [1]
def fact_inv(n):
''' n!^-1 % mod '''
if n >= mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
_size = len(_factorial)
if _size < n+1:
for i in range(_size, n+1):
_factorial.append(_factorial[i-1]*i % mod)
_size_inv = len(_factorial_inv)
if _size_inv < n+1:
for i in range(_size_inv, n+1):
_factorial_inv.append(modinv(_factorial[i]))
return _factorial_inv[n]
def comb(n, r):
''' nCr % mod '''
if r > n:
return 0
t = fact(n) * fact_inv(n-r) % mod
t = t * fact_inv(r) % mod
return t
def xgcd(a, b):
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(n):
g, x, _ = xgcd(n, mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % mod
x, y = sorted(map(int, input().split()))
q, r = divmod(x+y, 3)
if r != 0:
print((0))
else:
print((comb(q, y-q)))
| mod = 10**9 + 7
_factorial = [1]
def fact(n):
''' n! % mod '''
if n >= mod:
return 0
_size = len(_factorial)
if _size < n+1:
for i in range(_size, n+1):
_factorial.append(_factorial[i-1]*i % mod)
return _factorial[n]
_factorial_inv = [1]
def fact_inv(n):
''' n!^-1 % mod '''
if n >= mod:
raise ValueError('Modinv is not exist! arg={}'.format(n))
_size = len(_factorial)
if _size < n+1:
for i in range(_size, n+1):
_factorial.append(_factorial[i-1]*i % mod)
_size_inv = len(_factorial_inv)
if _size_inv < n+1:
for i in range(_size_inv, n+1):
_factorial_inv.append(modinv(_factorial[i]))
return _factorial_inv[n]
def comb(n, r):
''' nCr % mod '''
if r > n:
return 0
t = fact(n) * modinv(fact(n-r)) % mod
t = t * modinv(fact(r)) % mod
return t
def xgcd(a, b):
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
(q, a), b = divmod(b, a), a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def modinv(n):
g, x, _ = xgcd(n, mod)
if g != 1:
raise ValueError('Modinv is not exist! arg={}'.format(n))
return x % mod
x, y = sorted(map(int, input().split()))
q, r = divmod(x+y, 3)
if r != 0:
print((0))
else:
print((comb(q, y-q)))
| p02862 |
MOD = 10**9+7
X, Y = list(map(int, input().split()))
x, y = X, Y
while 0 <= y:
if x == 2*y:
break
x += 1
y -= 1
else:
print((0))
exit()
def com(n, r):
X = Y = 1
if r < 0 or n < r:
return 0
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
print((com(x//2, x-X) % MOD))
| MOD = 10**9+7
x, y = list(map(int, input().split()))
n, r1 = divmod(2*y-x, 3)
m, r2 = divmod(2*x-y, 3)
def com(n, r):
X = Y = 1
if r < 0 or n < r:
return 0
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
if r1 or r2:
print((0))
else:
print((com(n+m, n) % MOD)) | p02862 |
X, Y = list(map(int, input().split()))
if (X+Y)%3 != 0:
print((0))
exit()
N = (X+Y)//3
# C_N_X-N
MAX = 3000000
MOD = 1000000007
fac = [0]*MAX
finv = [0]*MAX
inv = [0]*MAX
fac[0] = 1
fac[1] = 1
finv[0] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, MAX):
fac[i] = fac[i-1]*i%MOD
inv[i] = MOD - inv[MOD%i]*(MOD//i)%MOD
finv[i] = finv[i-1]*inv[i]%MOD
def COM(n, k):
if n < 0 or k < 0 or n < k:
return 0
return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD
r = COM(N, X-N)
print(r)
| X, Y = list(map(int, input().split()))
if (X+Y)%3 != 0:
print((0))
exit()
N = (X+Y)//3
# C_N_X-N
MAX = 700000
MOD = 1000000007
fac = [0]*MAX
finv = [0]*MAX
inv = [0]*MAX
fac[0] = 1
fac[1] = 1
finv[0] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, MAX):
fac[i] = fac[i-1]*i%MOD
inv[i] = MOD - inv[MOD%i]*(MOD//i)%MOD
finv[i] = finv[i-1]*inv[i]%MOD
def COM(n, k):
if n < 0 or k < 0 or n < k:
return 0
return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD
r = COM(N, X-N)
print(r)
| p02862 |
def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 2*10**6 + 1
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range(2, N + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
X, Y = list(map(int, input().split()))
if X % 3 !=0 or X % 3 != 0:
print((0))
exit()
A = (2*Y - X) // 3
B = (2*X - Y) // 3
print((cmb(A+B, A, mod)))
| def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9 + 7 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range(2, N + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
X, Y = list(map(int, input().split()))
if (X + Y) % 3 != 0:
print((0))
exit()
A = (2 * Y - X) // 3
B = (2 * X - Y) // 3
print((cmb(A+B, A, mod)))
| p02862 |
X, Y = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def createFacArr(n, mod):
fac = [0] * n
finv = [0] * n
inv = [0] * n
fac[0], fac[1] = 1, 1
finv[0], finv[1] = 1, 1
inv[1] = 1
for i in range(2, n):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod%i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
return fac, finv, inv
def comb(n ,k, mod, fac, finv, inv):
'''
二項係数の計算
'''
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
def main():
if (X + Y) % 3 != 0:
return 0
# 移動回数を求める
m = (2 * X - Y) // 3
n = X - 2 * m
fac, finv, inv = createFacArr(10**6*2, MOD)
return comb(m+n, n, MOD, fac, finv, inv)
print((main()))
| X, Y = list(map(int,input().split()))
MOD = 10 ** 9 + 7
def calc_comb(n, k, mod):
'''
n が大きい場合に使う
'''
a = 1
b = 1
for i in range(1,k+1):
a *= i
a %= mod
b *= n
n -= 1
b %= mod
return b * pow(a, mod-2, mod) % mod
if (X+Y) % 3 != 0:
print((0))
else:
total_move = (X+Y) // 3
# 右に2つ動くことを選択しなければいけない回数
right_move = min(X,Y) - total_move
if right_move >= 0:
print((calc_comb(total_move, right_move, MOD)))
else:
print((0))
| p02862 |
import sys
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
return [w[0], w[1]]
def mod_inv(a, m):
x = extgcd(a, m)[0]
return (m + x % m) % m
def main():
X, Y = list(map(int, input().split()))
C = 10**9 + 7
if (X + Y) % 3 != 0:
print((0))
sys.exit()
cnt = [0, 0]
if Y / X >= 1:
(i, j) = (1, 2)
cnt[0] += 1
else:
(i, j) = (2, 1)
cnt[1] += 1
while (i, j) != (X, Y):
if Y * i > X * j:
i += 1
j += 2
cnt[0] += 1
else:
i += 2
j += 1
cnt[1] += 1
ans = 1
for i in range(1, sum(cnt) + 1):
ans *= i
ans %= C
for i in range(1, cnt[0] + 1):
ans *= mod_inv(i, C)
ans %= C
for i in range(1, cnt[1] + 1):
ans *= mod_inv(i, C)
ans %= C
print(ans)
main()
| import sys
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
return [w[0], w[1]]
def mod_inv(a, m):
x = extgcd(a, m)[0]
return (m + x % m) % m
def main():
X, Y = list(map(int, input().split()))
C = 10**9 + 7
if (X + Y) % 3 != 0:
print((0))
sys.exit()
cnt = [0, 0]
cnt[0] = (2 * X - Y) // 3
cnt[1] = (-X + 2 * Y) // 3
if cnt[0] < 0 or cnt[1] < 0:
print((0))
sys.exit()
ans = 1
for i in range(1, sum(cnt) + 1):
ans *= i
ans %= C
for i in range(1, cnt[0] + 1):
ans *= mod_inv(i, C)
ans %= C
for i in range(1, cnt[1] + 1):
ans *= mod_inv(i, C)
ans %= C
print(ans)
main()
| p02862 |
mod = 10 ** 9 + 7
fact = [1]
fact_inv = [1]
for i in range(10 ** 6):
new_fact = fact[-1] * (i + 1) % mod
fact.append(new_fact)
fact_inv.append(pow(new_fact, mod - 2, mod))
def mod_comb_k(n, k, mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n-k] % mod
def solve():
X, Y = list(map(int, input().split()))
if (2 * X - Y) % 3 == 0:
s = (2 * Y - X) // 3
t = (2 * X - Y) // 3
ans = mod_comb_k(s + t, s, mod)
print(ans)
else:
print((0))
solve() | def mod_comb(n, k, p):
if k > n - k:
k = n - k
numerator = 1
denominator = 1
for i, j in zip(list(range(n - k + 1, n + 1)), list(range(1, k + 1))):
numerator = (numerator * i) % p
denominator = (denominator * j) % p
return (numerator * pow(denominator, p - 2, p)) % p
def solve():
mod = 10 ** 9 + 7
X, Y = list(map(int, input().split()))
s = 2 * Y - X
t = 2 * X - Y
if s >= 0 and s % 3 == 0 and t >= 0 and t % 3 == 0:
s //= 3
t //= 3
print((mod_comb(s + t, s, mod)))
else:
print((0))
solve() | p02862 |
X, Y = [int(_) for _ in input().split()]
mod = 10**9 + 7
#a(1, 2) + b(2, 1) = (X, Y)
#a=(2*Y-X)//3
#b=(2*X-Y)//3
if (2 * Y - X) % 3 == (2 * X - Y) % 3 == 0:
a = (2 * Y - X) // 3
b = (2 * X - Y) // 3
if a < 0 or b < 0:
print((0))
exit()
f = [1] * (a + b + 1)
for i in range(1, a + b + 1):
f[i] = i * f[i - 1] % mod
fi = [1] * (a + b + 1)
fi[-1] = pow(f[-1], mod - 2, mod)
for i in range(a + b - 1, 1, -1):
fi[i] = (i + 1) * fi[i + 1] % mod
def comb(x, y):
return (f[x] * fi[y] * fi[x - y]) % mod
print((comb(a + b, b)))
exit()
print((0))
| X, Y = [int(_) for _ in input().split()]
mod = 10**9 + 7
#a(1, 2) + b(2, 1) = (X, Y)
a = (2 * Y - X) // 3
b = (2 * X - Y) // 3
if (2 * Y - X) % 3 == (2 * X - Y) % 3 == 0 and a * b >= 0:
f = [1] * (a + b + 1)
for i in range(1, a + b + 1):
f[i] = i * f[i - 1] % mod
fi = [1] * (a + b + 1)
fi[-1] = pow(f[-1], mod - 2, mod)
for i in range(a + b - 1, 1, -1):
fi[i] = (i + 1) * fi[i + 1] % mod
def comb(x, y):
return (f[x] * fi[y] * fi[x - y]) % mod
print((comb(a + b, b)))
exit()
print((0))
| p02862 |
X, Y = [int(_) for _ in input().split()]
mod = 10**9 + 7
#a(1, 2) + b(2, 1) = (X, Y)
a = (2 * Y - X) // 3
b = (2 * X - Y) // 3
if (2 * Y - X) % 3 == (2 * X - Y) % 3 == 0 and a * b >= 0:
f = [1] * (a + b + 1)
for i in range(1, a + b + 1):
f[i] = i * f[i - 1] % mod
fi = [1] * (a + b + 1)
fi[-1] = pow(f[-1], mod - 2, mod)
for i in range(a + b - 1, 1, -1):
fi[i] = (i + 1) * fi[i + 1] % mod
def comb(x, y):
return (f[x] * fi[y] * fi[x - y]) % mod
print((comb(a + b, b)))
exit()
print((0))
| X, Y = [int(_) for _ in input().split()]
mod = 10**9 + 7
#a(1, 2) + b(2, 1) = (X, Y)
a = (2 * Y - X) // 3
b = (2 * X - Y) // 3
if (2 * Y - X) % 3 == (2 * X - Y) % 3 == 0 and a * b >= 0:
f = [1] * (a + b + 1)
for i in range(1, a + b + 1):
f[i] = i * f[i - 1] % mod
fi = [1] * (a + b + 1)
fi[-1] = pow(f[-1], mod - 2, mod)
for i in range(a + b - 1, 1, -1):
fi[i] = (i + 1) * fi[i + 1] % mod
print(((f[a + b] * fi[a] * fi[b]) % mod))
else:
print((0))
| p02862 |
mod = 10**9 + 7
class Combination:
def __init__(self, n):
self.facts = [1 for i in range(n+1)]
self.invs = [1 for i in range(n+1)]
for i in range(1, n+1):
self.facts[i] = self.facts[i-1] * i % mod
self.invs[i] = pow(self.facts[i], mod-2, mod)
def ncr(self, n, r):
return self.facts[n] * self.invs[r] * self.invs[n-r] % mod
def nhr(self, n, r):
return self.ncr(n+r-1, n-1)
X, Y = list(map(int, input().split()))
comb = Combination(max(X, Y))
if 2*Y - X < 0 or 2*X - Y < 0 or (2*Y - X) % 3 != 0 or (2*X - Y) % 3 != 0:
print("0")
else:
M = (2*Y - X) // 3
N = (2*X - Y) // 3
print((comb.ncr(M+N,M)))
| mod = 10**9 + 7
def ncr(n, r):
r = min(r, n-r)
x, y = 1, 1
for i in range(r):
x = (x * (n-i)) % mod
y = (y * (i+1)) % mod
return x * pow(y, mod-2, mod) % mod
X, Y = list(map(int, input().split()))
if 2*Y - X < 0 or 2*X - Y < 0 or (2*Y - X) % 3 != 0 or (2*X - Y) % 3 != 0:
print("0")
else:
M = (2*Y - X) // 3
N = (2*X - Y) // 3
print((ncr(M+N,N))) | p02862 |
import math
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7
N = 10**6
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
X, Y = [int(i) for i in input().split()]
if (2*Y - X) % 3 != 0:
print((0))
elif (2*X - Y) % 3 != 0:
print((0))
else:
x = (2*X - Y) // 3
y = (2*Y - X) // 3
print((cmb(x+y, x , mod)))
| import math
def cmb(n, r, mod):
r = min(r, n-r)
a = 1
b = 1
for i in range(r):
a = (a * (n-i)) % mod
b = (b * (i+1)) % mod
return a * pow(b, mod-2, mod) % mod
X, Y = [int(i) for i in input().split()]
mod = 10**9+7
x_tmp = 2*X - Y
y_tmp = 2*Y - X
if x_tmp < 0 or y_tmp < 0:
ans = 0
elif x_tmp % 3 != 0 or y_tmp % 3 != 0:
ans = 0
else:
x = x_tmp // 3
y = y_tmp // 3
ans = cmb(x + y, y, mod)
print(ans) | p02862 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
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])
return result
def main():
x, y = list(map(int, readline().split()))
if (x+y)%3!=0:
print((0))
return
n = (x+y)//3
a, b = (2*y-x)//3, (2*x-y)//3
if a<0 or b<0:
print((0))
return
o = cmb(n, a)
o = o % (10**9+7)
print(o)
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def extgcd(a, b):
if b == 0:
return [1, 0, a]
x, y, g = extgcd(b, a % b)
return [y, x - a//b * y, g]
def mod_inverse(a, m):
x, _, _ = extgcd(a, m)
return (m + x % m) % m
def mod_comb(n, k, mod):
mul, div = 1, 1
for i in range(k):
mul *= (n-i)
div *= (i+1)
mul %= mod
div %= mod
return mul * mod_inverse(div, mod) % mod
def main():
x, y = list(map(int, readline().split()))
if (x+y)%3!=0:
print((0))
return
n = (x+y)//3
a, b = (2*y-x)//3, (2*x-y)//3
if a<0 or b<0:
print((0))
return
print((mod_comb(n, min(a, b), (10**9+7))))
if __name__ == "__main__":
main()
| p02862 |
import math
M = 10**9+7
X,Y = list(map(int,input().split()))
if (X+Y)/3 != (X+Y)//3:
print((0))
exit()
n = (X+Y)//3
r = Y-n
if r<0 or r>n:
print((0))
exit()
#互いに素なa,bについて、a*x+b*y=1の一つの解
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]]
# aの逆元(mod m)を求める。(aとmは互いに素であることが前提)
def mod_inv(a,m):
x = extgcd(a,m)[0]
return (m+x%m)%m
res = 1
for i in range(1,n+1):
res = res*i%M
for i in range(1,r+1):
res = res*mod_inv(i,M)%M
for i in range(1,n-r+1):
res = res*mod_inv(i,M)%M
print(res) | import math
M = 10**9+7
X,Y = list(map(int,input().split()))
if (X+Y)/3 != (X+Y)//3:
print((0))
exit()
n = (X+Y)//3
r = Y-n
if r<0 or r>n:
print((0))
exit()
#nCr and Mod
def nCr(n, r, mod=10**9+7):
r = min(r, n-r)
numer = denom = 1
for i in range(1, r+1):
numer = numer * (n+1-i) % mod
denom = denom * i % mod
return numer * pow(denom, mod-2, mod) % mod
print((nCr(n,r,M))) | p02862 |
def com(n,r,mod):
k=min(r,n-r)
C=1
for i in range(1,k+1):
C=(C*(n+1-i)*pow(i,mod-2,mod))%mod
return C
x, y = list(map(int,input().split()))
mod = 10 ** 9 + 7
n = (2 * y - x) // 3 if (2 * y - x) % 3 == 0 else -1
m = (2 * x - y) // 3 if (2 * x - y) % 3 == 0 else -1
if n >= 0 and m >= 0:
print((com(n + m, n, mod)))
else:
print((0)) | def com(n,r,mod):
k=min(r,n-r)
C=1
for i in range(1,k+1):
C=(C*(n+1-i)*pow(i,mod-2,mod))%mod
return C
x, y = list(map(int,input().split()))
mod = 10 ** 9 + 7
m = 2 * x - y
n = 2 * y - x
if m >= 0 and n >= 0 and m % 3 == 0 and n % 3 == 0:
print((com((n + m) // 3, n // 3, mod)))
else:print((0)) | p02862 |
X, Y = list(map(int, input().split()))
mod = 10**9+7
if (X+Y) % 3 != 0:
print((0))
else:
n = (2*Y-X)//3
m = (2*X-Y)//3
'''
n*(1,2) + m*(2,1) = (x, y)
x = n+2m
y = 2n+m
2x = 2n+4m
2x-y = 3m
m = (2x-y)/3
n = (2y-x)/3
'''
if 0 > n or 0 > m:
print((0))
else:
ans = 1
for i in range(1,n+1):
ans *= (n+m+1-i)*pow(i,mod-2,mod)
ans %= mod
print(ans)
| X, Y = list(map(int, input().split()))
m, r = divmod(2*Y-X, 3)
if r != 0:
print((0))
exit()
n = Y - 2*m
if n < 0 or m < 0:
print((0))
exit()
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
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
print((combination(n+m, n))) | p02862 |
def ncr(n, r):
return fac[n] * facinv[r] * facinv[n - r] % MOD
MOD = 10 ** 9 + 7
X, Y = list(map(int, input().split()))
N = 10 ** 6
fac = [1, 1]
facinv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fac.append(fac[i - 1] * i % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
facinv.append((facinv[-1] * inv[-1]) % MOD)
if (X + Y) % 3 or Y > 2 * X or Y < X // 2:
print((0))
exit()
d = (X + Y) // 3
print((ncr(d, X - (X + Y) // 3)))
| MOD = 10 ** 9 + 7
X, Y = list(map(int, input().split()))
if (X + Y) % 3 or Y > 2 * X or Y < X // 2:
print((0))
exit()
n = (X + Y) // 3
r = X - (X + Y) // 3
num, den = 1, 1
if n - r < r:
r = n - r
for i in range(1, r + 1):
num *= n - i + 1
num %= MOD
den *= i
den %= MOD
print(((num * pow(den, MOD - 2, MOD)) % MOD)) | p02862 |
MOD = 10 ** 9 + 7
X, Y = list(map(int, input().split()))
if (X + Y) % 3 or Y > 2 * X or Y < X // 2:
print((0))
exit()
n = (X + Y) // 3
r = X - (X + Y) // 3
num, den = 1, 1
if n - r < r:
r = n - r
for i in range(1, r + 1):
num *= n - i + 1
num %= MOD
den *= i
den %= MOD
print(((num * pow(den, MOD - 2, MOD)) % MOD)) | def ncr(n, r):
num, den = 1, 1
if n - r < r:
r = n - r
for i in range(1, r + 1):
num *= n - i + 1
num %= MOD
den *= i
den %= MOD
return num * pow(den, MOD - 2, MOD) % MOD
MOD = 10 ** 9 + 7
X, Y = list(map(int, input().split()))
Z = X + Y
if Z % 3 or Y > 2 * X or Y < X // 2:
print((0))
else:
print((ncr(Z // 3, X - Z // 3)))
| p02862 |
X, Y =list(map(int, input().split()))
mod = 1000000007
import sys
if (X + Y) % 3 != 0:
print((0))
sys.exit()
offset = (X+Y)//3
X, Y = X-offset, Y-offset
if X<0 or Y<0:
print((0))
sys.exit()
X, Y = max(X, Y), min(X, Y)
def C(n, r, mod):
num = 1
den = 1
for i in range(r):
num*=n-i
num%=mod
den*=i+1
den%=mod
return (num*pow(den, mod-2, mod))%mod
print((C(X+Y, Y, mod)))
| X, Y = list(map(int, input().split()))
if (X+Y) % 3 != 0:
print((0))
else:
# 経路
def C(n, r, mod):
num = 1
den = 1
for i in range(r):
num *= n-i
num %= mod
den *= i+1
den %= mod
return (num * pow(den, mod-2, mod)) % mod
mod = 10**9 + 7
minimun = (X+Y)/3
if X >= minimun and Y >= minimun:
X -= minimun
Y -= minimun
print((C(int(X+Y), int(X), mod)))
else:
print((0)) | p02862 |
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 10**6 + 10
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
x, y = list(map(int, input().split()))
n = (2 * x - y) / 3
m = (2 * y - x) / 3
mod = 10 ** 9 + 7
if int(n) == n and int(m) == m:
n = int(n)
m = int(m)
ans = cmb(n + m, n, mod)
ans %= mod
print(ans)
else:
print((0))
| x, y = list(map(int, input().split()))
mod = 10 ** 9 + 7
cnt1 = cnt2 = 0
for i in range(x + 1):
x_left = x - i
y_left = y - 2 * i
if x_left == y_left * 2:
cnt1 = i
cnt2 = y_left
if cnt1 == cnt2 == 0:
ans = 0
else:
ans = 1
for i in range(1, cnt1 + 1):
ans *= (cnt1 + cnt2 - i + 1)
ans %= mod
ans *= pow(i, mod - 2, mod)
ans %= mod
print(ans)
| p02862 |
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])
return result
a,s=list(map(int,input().split()))
if (2*a-s)%3==0 and max(a,s)<=2*min(a,s):
n=(a+s)//3
r=(2*a-s)//3
print(((cmb(n,r))%(10**9+7)))
else:print((0)) | x,y=list(map(int,input().split()))
if (x+y)%3:print((0))
else:
sab=(x+y)//3
a=y-sab
b=sab-a
if a<0 or b<0:print((0));exit()
mod=10**9+7
fact=[1]*(sab+1)
inv=[1]*(sab+1)
for i in range(2,sab+1):
fact[i]=i*fact[i-1]%mod
inv[-1]=pow(fact[-1],mod-2,mod)
for i in range(sab,1,-1):
inv[i-1]=inv[i]*i%mod
def comb(x,y):return fact[x]*inv[y]%mod*inv[x-y]%mod if x>=y>=0 else 0
print((comb(sab,a))) | p02862 |
def cmb(n,r,mod):
if r<0 or r>n:return 0
r=min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
mod=10**9+7
x,y=list(map(int,input().split()))
g1=[1,1]
g2=[1,1]
inverse=[0,1]
n,m=(2*y-x)//3,(2*x-y)//3
if (x+y)%3!=0 or n<0 or m<0:print((0));exit()
for i in range(2,n+m+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1]%mod))
print((cmb(n+m,n,mod))) | mod=10**9+7
x,y=list(map(int,input().split()))
X,Y=(2*y-x)//3,(2*x-y)//3
if X<0 or Y<0 or (x+y)%3!=0:print((0));exit()
def cmb(n,r,mod):
if r<0 or r>n:return 0
return g1[r]*g2[r]%mod
n=X+Y
k=max(X,Y)
g1=[1,n]
g2=[1,1]
inverse=[0,1]
for i,j in enumerate(range(n-1,((n-k+1)-1),-1)):
i=i+2
g1.append((g1[-1]*j)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1]%mod))
print((cmb(n,k,mod))) | p02862 |
X,Y=list(map(int,input().split()))
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7
N = 10**6
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
if (X+Y)%3!=0:
print((0))
else:
n=2*Y-X
m=2*X-Y
if n<0 or m<0:
print((0))
else:
n=int(n/3)
m=int(m/3)
print((cmb(n+m,m,mod))) | X,Y=list(map(int,input().split()))
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])
return result
if (X+Y)%3!=0:
print((0))
else:
n=2*Y-X
m=2*X-Y
mod=10**9+7
if n<0 or m<0:
print((0))
else:
n=int(n/3)
m=int(m/3)
print((cmb(n+m,m)%mod)) | p02862 |
x,y = list(map(int,input().split()))
mod = 10**9 + 7
if (x+y)%3 != 0:
print((0))
exit()
if (2*y-x)%3 !=0 or (2*x-y)%3 != 0 or 2*y-x <0 or 2*x-y<0:
print((0))
exit()
a = (2*y-x)//3
b = (2*x-y)//3
def inverse(a,p):
return pow(a,p-2,p)
def combination_modp(n, r, p): # nCr modpを求める
r = min(n-r, r)
result = 1
for i in range(n, n-r, -1):
result *= i
result %=p
for i in range(1, r+1):
result *= inverse(i,p)
result %= p
return result
ans = combination_modp(a+b,a,mod)
print(ans) | def combination_modp(n, r, p): # nCr modpを求める
r = min(n-r, r)
result = 1
for i in range(n, n-r, -1):
result *= i
result %=p
for i in range(1, r+1):
result *= pow(i,p-2,p)
result %= p
return result
x,y = list(map(int,input().split()))
mod = 10**9 + 7
if (x+y)%3 != 0 or 2*y-x <0 or 2*x-y<0:
print((0))
exit()
a = (2*y-x)//3
b = (2*x-y)//3
ans = combination_modp(a+b,a,mod)
print(ans) | p02862 |
x,y=list(map(int,input().split()))
a3=2*x-y
b3=2*y-x
MOD=10**9+7
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
if a3%3!=0 or b3%3!=0:
print((0))
else:
a=a3//3
b=b3//3
if a>b:
a,b=b,a
N=a+b
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % MOD )
inverse.append( ( -inverse[MOD % i] * (MOD//i) ) % MOD )
g2.append( (g2[-1] * inverse[-1]) % MOD )
ans = cmb(N,a,MOD)
print((ans%MOD)) | X,Y=list(map(int,input().split()))
# (i+1,j+2)の移動をa回
# (i+2,j+1)の移動をb回
# X=a+2b
# Y=2a+b
# となるa,bが存在するか？
# b=(2X-Y)/3が整数となればOK
b=(2*X-Y)/3
if not float.is_integer(b):
print((0))
exit(0)
b=int(b)
a=X-2*b
# aとbの回数が決まったので、a+bCmin(a,b)をやればいい
DIV=10**9+7
from functools import reduce
def nCr(n,r,DIV):
if r<n-r:
r=n-r
if r==0:
return 1
f=lambda x,y:x*y%DIV
X=reduce(f,list(range(n-r+1,n+1)))
Y=reduce(f,list(range(1,r+1)))
return X*pow(Y,DIV-2,DIV)%DIV
print((nCr(a+b,b,DIV))) | p02862 |
X, Y = list(map(int, input().split()))
mod = 10 ** 9 + 7
# modしながらコンビネーションを求める
def mod_cmb(n, r, mod):
p, q = 1, 1
for i in range(r):
p = p * (n - i) % mod
q = q * (i + 1) % mod
return p * mod_inverse(q, mod) % mod
# modしたa^bを求める
def mod_pow(a, p, mod):
if p == 0:
return 1
elif p % 2 == 1:
return a * mod_pow(a, p - 1, mod)
else:
return (mod_pow(a, p // 2, mod) % mod) ** 2 % mod
# aで割りたいときはa^(p-2)をかければよい（pは素数かつmodで使うやつ）
def mod_inverse(a, mod):
return mod_pow(a, (mod - 2), mod)
# 移動1, 2を使う回数
n, m = 0, 0
for i in range(10 ** 6):
if X - i == (Y - 2 * i) * 2 == 0 or X - i == (Y - 2 * i) * 2 != 0:
n = i
m = Y - 2 * n
break
else:
print((0))
exit()
print((mod_cmb(n + m, n, mod))) | X, Y = list(map(int, input().split()))
mod = 10 ** 9 + 7
# modしながらコンビネーションを求める
def mod_cmb(n, r, mod):
p, q = 1, 1
for i in range(r):
p = p * (n - i) % mod
q = q * (i + 1) % mod
return p * mod_inverse(q, mod) % mod
# modしたa^bを求める
def mod_pow(a, p, mod):
if p == 0:
return 1
elif p % 2 == 1:
return a * mod_pow(a, p - 1, mod)
else:
return (mod_pow(a, p // 2, mod) % mod) ** 2 % mod
# aで割りたいときはa^(p-2)をかければよい（pは素数かつmodで使うやつ）
def mod_inverse(a, mod):
return mod_pow(a, (mod - 2), mod)
if (X + Y) % 3 != 0:
print((0))
exit()
# 移動1, 2を使う回数
n = (2 * Y - X) // 3
m = (2 * X - Y) // 3
if n < 0 or m < 0:
print((0))
exit()
print((mod_cmb(n + m, n, mod))) | p02862 |
x,y = list(map(int,input().split()))
if x > y*2 or y > x*2 or (x+y)%3 != 0:
print((0))
exit()
n = (x+y)//3
r = min(x-n,2*n-x)
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7
N = 10**6
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
print((cmb(n,r,mod))) | x,y = list(map(int,input().split()))
if (x+y)%3 != 0:
print((0))
quit()
elif x < (x+y)//3 or y < (x+y)//3:
print((0))
quit()
else:
n = (x+y)//3
r = x-n
mod = 10**9+7
def cmb(n,r,mod):
r = min(r, n-r)
return (fact[n] * factinv[r] * factinv[n-r]) % mod
def makefact(n,mod):
fact = [1,1]
factinv = [1,1]
inv = [0,1]
for i in range(2,n+1):
fact.append((fact[-1]*i) % mod)
inv.append(-inv[mod%i]*(mod//i)%mod)
factinv.append((factinv[-1]*inv[-1])%mod)
return fact,factinv
fact,factinv = makefact(n,mod)
print((cmb(n,r,mod))) | p02862 |
import math
mod = 10**9 + 7
x, y = list(map(int, input().split()))
if (x+y)%3 != 0:
print((0))
exit()
if x == 0 or y == 0:
print((0))
exit()
X = max(x,y)
Y = min(x,y)
all_move = (X+Y)//3
diff = (X-Y)
y_move = (all_move - diff)//2
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
n = int(all_move)
r = int(y_move)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, n + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
print((cmb(n,r,mod)))
| import math
MOD = 10**9 + 7 # 素数
x, y = list(map(int, input().split()))
if (x+y)%3 != 0:
print((0))
exit()
if x == 0 or y == 0:
print((0))
exit()
X = max(x,y)
Y = min(x,y)
all_move = (X+Y)//3
diff = (X-Y)
Y_move = (all_move - diff)//2
def mod_cmb(n, r, mod): # nCr mod p
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, n + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
print((mod_cmb(all_move, Y_move,MOD)))
| p02862 |
def d_knight():
X, Y = [int(i) for i in input().split()]
if (abs(X) + abs(Y)) % 3 != 0 or Y > 2 * X or 2 * Y < X:
return 0
n = (abs(X) + abs(Y)) // 3
k = -1
for x in range(n, 2 * n + 1):
if Y == 3 * n - x:
k = x - n
break
class Combination(object):
"""参考: https://harigami.net/contents?id=5f169f85-5707-4137-87a5-f0068749d9bb"""
__slots__ = ['mod', 'factorial', 'inverse']
def __init__(self, max_val_arg: int = 10**6, mod: int = 10**9 + 7):
fac, inv = [1], []
fac_append, inv_append = fac.append, inv.append
for i in range(1, max_val_arg + 1):
fac_append(fac[-1] * i % mod)
inv_append(pow(fac[-1], mod - 2, mod))
for i in range(max_val_arg, 0, -1):
inv_append((inv[-1] * i) % mod)
self.mod, self.factorial, self.inverse = mod, fac, inv[::-1]
def combination(self, n, r):
if n < 0 or r < 0 or n < r:
return 0
return self.factorial[n] * self.inverse[r] * self.inverse[n - r] % self.mod
return Combination().combination(n, k)
print((d_knight())) | def d_knight():
X, Y = [int(i) for i in input().split()]
def combination(n, r, mod):
r = min(r, n - r)
numerator, denominator = 1, 1
for i in range(1, r + 1):
numerator = (numerator * (n + 1 - i)) % mod
denominator = (denominator * i) % mod
return numerator * pow(denominator, mod - 2, mod) % mod
if not (X <= 2 * Y and Y <= 2 * X):
return 0
n, m = (-X + 2 * Y) / 3, (2 * X - Y) / 3
if not (n.is_integer() and m.is_integer()):
return 0
n, m = int(n), int(m)
return combination(n + m, n, 10**9 + 7)
print((d_knight())) | p02862 |
x,y=list(map(int,input().split()))
MAX_NUM = 2*10**6 + 1
pr = 10**9+7
fac = [0 for _ in range(MAX_NUM)]
finv = [0 for _ in range(MAX_NUM)]
inv = [0 for _ in range(MAX_NUM)]
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,MAX_NUM):
fac[i] = fac[i-1] * i % pr
inv[i] = pr - inv[pr%i] * (pr // i) % pr
finv[i] = finv[i-1] * inv[i] % pr
def c(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % pr) % pr
if (x+y)%3:
print((0))
else:
n=(x+y)//3
x-=n
y-=n
print((c(x+y,x)))
| x,y=list(map(int,input().split()))
MAX_NUM = 2*10**6 + 1
MAX_NUM//=3
MAX_NUM+=1
pr = 10**9+7
fac = [0 for _ in range(MAX_NUM)]
finv = [0 for _ in range(MAX_NUM)]
inv = [0 for _ in range(MAX_NUM)]
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,MAX_NUM):
fac[i] = fac[i-1] * i % pr
inv[i] = pr - inv[pr%i] * (pr // i) % pr
finv[i] = finv[i-1] * inv[i] % pr
def c(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % pr) % pr
if (x+y)%3:
print((0))
else:
n=(x+y)//3
x-=n
y-=n
print((c(x+y,x)))
| p02862 |
from sys import stdin, setrecursionlimit
setrecursionlimit(10 ** 9)
INF = 1 << 60
def input():
return stdin.readline().strip()
X, Y = list(map(int, input().split()))
n = (X + Y) // 3
x = (2 * X - Y) // 3
y = (-X + 2 * Y) // 3
if (X + Y) % 3 or x < 0 or y < 0:
print((0))
exit()
MOD = 1000000007
COM_MAX = n
fac, finv, inv = [0] * (COM_MAX + 1), [0] * (COM_MAX + 1), [0] * (COM_MAX + 1)
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, COM_MAX + 1):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def mod_com(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
print((mod_com(n, x)))
| from sys import stdin, setrecursionlimit
setrecursionlimit(10 ** 9)
INF = 1 << 60
def input():
return stdin.readline().strip()
MOD = 1000000007
X, Y = list(map(int, input().split()))
n = (X + Y) // 3
x = (2 * X - Y) // 3
y = (-X + 2 * Y) // 3
if (X + Y) % 3 or x < 0 or y < 0:
print((0))
exit()
def mod_com(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
if k > n - k:
k = n - k
if k == 0:
return 1
ans = 1
for i in range(n - k + 1, n + 1):
ans = ans * i % MOD
inv = [0] * (k + 1)
inv[1] = 1
for i in range(2, k + 1):
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
ans = ans * inv[i] % MOD
return ans
print((mod_com(n, x)))
| p02862 |
from sys import stdin, setrecursionlimit
setrecursionlimit(10 ** 9)
INF = 1 << 60
def input():
return stdin.readline().strip()
MOD = 1000000007
X, Y = list(map(int, input().split()))
n = (X + Y) // 3
x = (2 * X - Y) // 3
y = (-X + 2 * Y) // 3
if (X + Y) % 3 or x < 0 or y < 0:
print((0))
exit()
def mod_com(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
if k > n - k:
k = n - k
if k == 0:
return 1
ans = 1
for i in range(n - k + 1, n + 1):
ans = ans * i % MOD
inv = [0] * (k + 1)
inv[1] = 1
for i in range(2, k + 1):
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
ans = ans * inv[i] % MOD
return ans
print((mod_com(n, x)))
| from sys import stdin, setrecursionlimit
setrecursionlimit(10 ** 9)
INF = 1 << 60
def input():
return stdin.readline().strip()
X, Y = list(map(int, input().split()))
n = (X + Y) // 3
x = (2 * X - Y) // 3
y = (-X + 2 * Y) // 3
if (X + Y) % 3 or x < 0 or y < 0:
print((0))
exit()
def mod_com(n, r):
MOD = 1000000007
r = min(r, n - r)
numer = denom = 1
for i in range(1, r + 1):
numer = numer * (n - r + i) % MOD
denom = denom * i % MOD
return numer * pow(denom, MOD - 2, MOD) % MOD
print((mod_com(n, x)))
| p02862 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def mod_com_once(n, r, MOD):
if n < r:
return 0
if n < 0 or r < 0:
return 0
r = min(r, n - r)
numer = denom = 1
for i in range(1, r + 1):
numer = numer * (n - r + i) % MOD
denom = denom * i % MOD
return numer * pow(denom, MOD - 2, MOD) % MOD
def main():
MOD = 1000000007
X, Y = list(map(int, readline().split()))
p = (2 * X - Y) // 3
q = (-X + 2 * Y) // 3
if (X + Y) % 3 or p < 0 or q < 0:
print((0))
return
print((mod_com_once(p + q, p, MOD)))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def mod_com_once(n, r, MOD):
if n < r:
return 0
if n < 0 or r < 0:
return 0
r = min(r, n - r)
numer = denom = 1
for i in range(n - r + 1, n + 1):
numer = numer * i % MOD
for i in range(1, r + 1):
denom = denom * i % MOD
return numer * pow(denom, MOD - 2, MOD) % MOD
def main():
MOD = 1000000007
X, Y = list(map(int, readline().split()))
p = (2 * X - Y) // 3
q = (-X + 2 * Y) // 3
if (X + Y) % 3 or p < 0 or q < 0:
print((0))
return
print((mod_com_once(p + q, p, MOD)))
return
if __name__ == '__main__':
main()
| p02862 |
mod = 10**9+7
n = 10**6
def comb(n, r):
if 2 * r > n: return comb(n, n-r)
return fac[n] * inv[r] * inv[n-r] % mod
x, y = list(map(int, input().split()))
if (x+y) % 3 != 0:
print((0))
exit()
a = -(x-2*y)//3
b = (2*x-y)//3
if a<0 or b<0:
print((0))
exit()
fac = [1] * (n+2)
inv = [1] * (n+2)
for i in range(2, n+1):
fac[i] = fac[i-1] * i % mod
inv[n] = pow(fac[n], mod - 2, mod)
for i in range(n-1, 1, -1):
inv[i] = inv[i + 1] * (i + 1) % mod
print((comb(a+b, a) % mod)) | mod = 10**9+7
def comb(n, r):
if 2 * r > n: return comb(n, n-r)
return fac[n] * inv[r] * inv[n-r] % mod
x, y = list(map(int, input().split()))
if (x+y) % 3 != 0:
print((0))
exit()
n = (x+y)//3
x -= n
y -= n
if x<0 or y<0:
print((0))
exit()
fac = [1] * (n+2)
inv = [1] * (n+2)
for i in range(2, n+1):
fac[i] = fac[i-1] * i % mod
inv[n] = pow(fac[n], mod - 2, mod)
for i in range(n-1, 1, -1):
inv[i] = inv[i + 1] * (i + 1) % mod
print((comb(x+y, x) % mod)) | p02862 |
x,y=list(map(int,input().split()))
mod=10**9+7
n_max=10**6+1
F,FI=[0]*(n_max+1),[0]*(n_max+1)
F[0],FI[0]=1,1
for i in range(n_max):
F[i+1]=(F[i]*(i+1))%mod
FI[i+1]=pow(F[i+1],mod-2,mod)
def comb(x,y):
return (F[x]*FI[x-y]*FI[y])%mod
a,b=2*y-x,2*x-y
if a<0 or b<0:
print((0))
elif a%3!=0 or b%3!=0:
print((0))
else:
a//=3
b//=3
print((comb(a+b,a)))
| x,y=list(map(int,input().split()))
mod=10**9+7
n_max=10**6+1
F=[0]*(n_max+1)
F[0]=1
for i in range(n_max):
F[i+1]=(F[i]*(i+1))%mod
def comb(x,y):
return (F[x]*pow(F[x-y],mod-2,mod)*pow(F[y],mod-2,mod))%mod
a,b=2*y-x,2*x-y
if a<0 or b<0:
print((0))
elif a%3!=0 or b%3!=0:
print((0))
else:
a//=3
b//=3
print((comb(a+b,a)))
| p02862 |
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 combination_large(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
x, y = list(map(int, input().split()))
mod = 10**9 + 7
comb = Combination(10**6,mod)
if (x+y)%3 != 0:
print((0))
exit(0)
i = (2*x-y)//3
j = (2*y-x)//3
print((comb.combination(i+j, i)))
| 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 combination_large(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
x, y = list(map(int, input().split()))
mod = 10**9 + 7
comb = Combination(10**6,mod)
if (x+y)%3 != 0:
print((0))
exit(0)
i = (2*x-y)//3
j = (2*y-x)//3
n = i+j
r = i
if not 0 <= r <= n:
print((0))
exit(0)
print((comb.combination(n, r)))
| p02862 |
def mod_inv(a, m):
return pow(a,m-2,m)
X, Y = list(map(int, input().split()))
MOD = 10 ** 9 + 7
if (X + Y) % 3:
print((0))
exit()
n = (X + Y) // 3
nx, ny = X - n, Y - n
if nx < 0 or ny < 0:
print((0))
exit()
ans = 1
for i in range(1, nx + ny + 1):
ans = ans * i % MOD
for i in range(1, nx + 1):
ans = ans * mod_inv(i, MOD) % MOD
for i in range(1, ny + 1):
ans = ans * mod_inv(i, MOD) % MOD
print(ans) | def mod_inv(a, m):
return pow(a, m-2, m)
X, Y = list(map(int, input().split()))
MOD = 10 ** 9 + 7
if (X + Y) % 3:
print((0))
exit()
n = (X + Y) // 3
nx, ny = X - n, Y - n
if nx < 0 or ny < 0:
print((0))
exit()
ans = 1
for i in range(nx + 1, nx + ny + 1):
ans = ans * i % MOD
for i in range(1, ny + 1):
ans = ans * mod_inv(i, MOD) % MOD
print(ans)
| p02862 |
MOD = 10**9 + 7
def nck(n, k):
numer, denom = 1, 1
for i in range(k):
numer = numer * (n - i) % MOD
denom = denom * (k - i) % MOD
return numer * pow(denom, MOD-2, MOD) % MOD
x, y = list(map(int, input().split()))
# (1, 2) 動く回数をm回、(2, 1) 動く回数をn回とする
n = -1
for m in range(min(x//1, y//2) + 1):
rx = x - m
ry = y - 2 * m
if rx == ry * 2:
n = ry
break
if n == -1:
print((0))
else:
print((nck(m+n, min(m, n))))
| def nck(n, k):
numer, denom = 1, 1
for i in range(k):
numer = numer * (n-i) % MOD
denom = denom * (k-i) % MOD
return numer * pow(denom, MOD-2, MOD) % MOD
x, y = list(map(int, input().split()))
MOD = 10 ** 9 + 7
i = 2 * y - x
j = 2 * x - y
if i % 3 != 0 or j % 3 != 0 or i < 0 or j < 0:
print((0))
else:
i, j = i // 3, j // 3
print((nck(i+j, min(i, j))))
| p02862 |
import math
import itertools
x,y=list(map(int, input().split()))
v=x+y
if v%3!=0:
print((0))
exit()
if (v//3-abs(x-y))%2!=0:
print((0))
exit()
v1=(v//3-abs(x-y))//2+abs(x-y)
v2=v//3-v1
if v2<0:
print((0))
exit()
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])
return result
a = cmb(v//3,v1)
a//(math.factorial(v2))
print((a%(10**9+7)))
| x,y= list(map(int, input().split()))
a=min(x,y)
b=max(x,y)
mod=pow(10,9)+7
if b-a>a or (a-(b-a))%3!=0:
print((0))
else:
r=(a-(b-a))//3
l=((a-(b-a))//3)+(b-a)
c=1
d=1
for i in range(r):
c=(c*(l+r-i))%mod
d=(d*(r-i))%mod
ans=c*pow(d,mod-2,mod)
print((ans%mod))
| p02862 |
x, y = list(map(int, input().split()))
mod = 1000000007
class Combination:
"""
O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
comb = Combination(1000000)
print(comb(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
if (x + y) % 3 != 0:
print((0))
else:
n = (x + y) // 3
if n > x or n > y:
print((0))
else:
nx = x - n
comb = Combination(n)
print((comb(n, nx)))
| x, y = list(map(int, input().split()))
mod = 10**9+7
def inv(x):
return pow(x, mod-2, mod)
def fact(x):
f = 1
for i in range(1, x + 1):
f *= i
f %= mod
return f
def comb(n, r):
return (fact(n) * inv(fact(n-r)) * inv(fact(r))) % mod
if (x + y) % 3 != 0:
print((0))
else:
n = (x + y) // 3
if n > x or n > y:
print((0))
else:
nx = x - n
print((comb(n, nx)))
| p02862 |
x, y = list(map(int, input().split()))
diff = abs(x - y)
ref = (min(x, y) - diff)//3
total = ref*2 + diff
mod = 10**9 + 7
ans = 1
if (x + y)%3 != 0 or ref < 0:
print((0))
exit()
for i in range(min(ref, total - ref)):
ans = ans*(total - i)%mod
ie = pow((i + 1), (mod - 2), mod)
ans = ans*ie%mod
print(ans) | x, y = list(map(int, input().split()))
diff = abs(x - y)
ref = (min(x, y) - diff)//3
total = ref*2 + diff
mod = 10**9 + 7
ans = 1
ie = 1
if (x + y)%3 != 0 or ref < 0:
print((0))
exit()
for i in range(min(ref, total - ref)):
ans = ans*(total - i)%mod
ie = ie*(i + 1)%mod
ie = pow(ie, mod - 2, mod)
ans = ans*ie%mod
print(ans) | p02862 |
def cmb(n, k, mod, fac, infac):
k = min(k,n-k)
return fac[n] * infac[k] * infac[n-k] % mod
def tables(mod, n):
fac = [1, 1]
infac = [1, 1]
inverse = [0, 1]
for i in range(2, n+1):
fac.append((fac[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
infac.append((infac[-1] * inverse[-1]) % mod)
return fac,infac
X,Y = list(map(int, input().split()))
if X > Y:
X, Y = Y, X
move = X + Y
if move % 3 != 0:
print((0))
else:
total = move // 3
n = X - total
if n < 0:
print((0))
else:
MOD = 10 ** 9 + 7
fac, infac = tables(MOD, total)
ans = cmb(total, n, MOD, fac, infac)
print(ans) | X,Y = list(map(int,input().split()))
M = max(X,Y)
m = min(X,Y)
mod = 10 ** 9 + 7
con = (X + Y) // 3
dif = M - m
n = (con - dif) // 2
if (X + Y) % 3 != 0 or n < 0:
print((0))
else:
def comb(n, r):
n += 1
over = 1
under = 1
for i in range(1,r + 1):
over = over * (n - i) % mod
under = under * i % mod
#powでunder ** (mod - 2) % modを実現、逆元を求めている
return over * pow(under,mod - 2,mod) % mod
ans = comb(con,n)
print(ans) | p02862 |
def knight(x, y):
mod = 10 ** 9 + 7
x, y = min(x, y), max(x, y)
if (x + y) % 3 != 0:
return 0
if y > 2 * x:
return 0
move = (x + y) // 3
right = 2 * move - y
up = move-right
ans = 1
for i in range(1, move + 1):
ans *= i
ans %= mod
for i in range(1, right + 1):
ans *= pow(i, mod - 2, mod)
ans %= mod
for i in range(1, up + 1):
ans *= pow(i, mod - 2, mod)
ans %= mod
return ans
if __name__ == "__main__":
x, y = list(map(int, input().split()))
ans = knight(x, y)
print(ans)
| def knight(x, y):
mod = 10 ** 9 + 7
x, y = min(x, y), max(x, y)
if (x + y) % 3 != 0:
return 0
if y > 2 * x:
return 0
move = (x + y) // 3
right = 2 * move - y
up = move-right
ans = 1
for i in range(up):
ans *= (move - i)
ans *= pow(i + 1, mod - 2, mod)
ans %= mod
return ans
if __name__ == "__main__":
x, y = list(map(int, input().split()))
ans = knight(x, y)
print(ans)
| p02862 |
def knight(x, y):
mod = 10 ** 9 + 7
x, y = min(x, y), max(x, y)
if (x + y) % 3 != 0:
return 0
if y > 2 * x:
return 0
move = (x + y) // 3
right = 2 * move - y
up = move-right
ans = 1
for i in range(up):
ans *= (move - i)
ans *= pow(i + 1, mod - 2, mod)
ans %= mod
return ans
if __name__ == "__main__":
x, y = list(map(int, input().split()))
ans = knight(x, y)
print(ans)
| def knight(x, y):
mod = 10 ** 9 + 7
x, y = min(x, y), max(x, y)
if (x + y) % 3 != 0:
return 0
if y > 2 * x:
return 0
move = (x + y) // 3
right = 2 * move - y
up = move-right
ans = 1
tmp = 1
for i in range(up):
ans *= (move - i)
tmp *= i + 1
ans %= mod
tmp %= mod
ans *= pow(tmp, mod - 2, mod)
return ans % mod
if __name__ == "__main__":
x, y = list(map(int, input().split()))
ans = knight(x, y)
print(ans)
| p02862 |
mod = 10**9+7
N = 10**6
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, N + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
def cmb(n, r, mod):
if (r < 0 or r > n):
return 0
return g1[n] * g2[r] * g2[n-r] % mod
X, Y = list(map(int, input().split()))
if (X + Y) % 3 != 0:
ans = 0
else:
n = (X + Y) // 3
r = min(X, Y) - n
ans = cmb(n, r, mod)
print(ans)
| mod = 10**9+7
X, Y = list(map(int, input().split()))
def comb(n, r, mod):
if r < 0 or n < r:
return 0
return fact[n]*pow(fact[r], mod-2, mod) * pow(fact[n-r], mod-2, mod) % mod
if (X + Y) % 3 != 0:
ans = 0
else:
n = (X + Y) // 3
r = min(X, Y)-n
# nCr
fact = [1, 1]
for i in range(2, n+1):
fact.append(fact[-1] * i % mod)
ans = comb(n, r, mod)
print(ans)
| p02862 |
N, a, b = list(map(int, input().split())); a -= 1; b -= 1
P = []
Q = []
for i in range(N):
x, y = list(map(int, input().split()))
P.append((x-y, x+y, i))
Q.append((x+y, x-y, i))
d = max(abs(P[a][0] - P[b][0]), abs(P[a][1] - P[b][1]))
G = [set() for i in range(N)]
def solve(P0):
P = P0[:]
P.sort()
s = t = 0
for i in range(N):
x, y, i0 = P[i]
while t < N and P[t][0] < x-d or (P[t][0] == x-d and P[t][1] <= y+d): t += 1
while s < N and (P[s][0] < x-d or (P[s][0] == x-d and P[s][1] < y-d)): s += 1
for j in range(s, t):
j0 = P[j][2]
d0 = max(abs(P0[i0][0] - P0[j0][0]), abs(P0[i0][1] - P0[j0][1]))
#assert d0 == d
G[i0].add(j0)
P.sort(key=lambda x: (-x[0], x[1], x[2]))
s = t = 0
for i in range(N):
x, y, i0 = P[i]
while t < N and x+d < P[t][0] or (P[t][0] == x+d and P[t][1] <= y+d): t += 1
while s < N and (x+d < P[s][0] or (P[s][0] == x+d and P[s][1] < y-d)): s += 1
for j in range(s, t):
j0 = P[j][2]
d0 = max(abs(P0[i0][0] - P0[j0][0]), abs(P0[i0][1] - P0[j0][1]))
#assert d0 == d
G[i0].add(j0)
solve(P)
solve(Q)
from collections import deque
que = deque([a])
used = {a}
res = 0
while que:
v = que.popleft()
to = G[v]
res += len(to)
for w in to:
if w not in used:
que.append(w)
used.add(w)
print((res // 2))
| N, a, b = list(map(int, input().split())); a -= 1; b -= 1
P = []
Q = []
for i in range(N):
x, y = list(map(int, input().split()))
P.append((x-y, x+y, i))
Q.append((x+y, x-y, i))
d = max(abs(P[a][0] - P[b][0]), abs(P[a][1] - P[b][1]))
*parent, = list(range(N))
def root(x):
if x == parent[x]:
return x
y = parent[x] = root(parent[x])
return y
def unite(x, y):
px = root(x); py = root(y)
if px < py:
parent[py] = px
else:
parent[px] = py
C = [0]*N
D = [0]*N
def solve(P0):
P = P0[:]
P.sort()
s = t = 0
for i in range(N):
x, y, i0 = P[i]
while t < N and P[t][0] < x-d or (P[t][0] == x-d and P[t][1] <= y+d): t += 1
while s < N and (P[s][0] < x-d or (P[s][0] == x-d and P[s][1] < y-d)): s += 1
for j in range(s, t):
j0 = P[j][2]
unite(i0, j0)
if abs(P0[i0][0] - P0[j0][0]) == abs(P0[i0][1] - P0[j0][1]):
D[i0] += 1
else:
C[i0] += 1
#d0 = max(abs(P0[i0][0] - P0[j0][0]), abs(P0[i0][1] - P0[j0][1]))
#assert d0 == d
P.sort(key=lambda x: (-x[0], x[1], x[2]))
s = t = 0
for i in range(N):
x, y, i0 = P[i]
while t < N and x+d < P[t][0] or (P[t][0] == x+d and P[t][1] <= y+d): t += 1
while s < N and (x+d < P[s][0] or (P[s][0] == x+d and P[s][1] < y-d)): s += 1
for j in range(s, t):
j0 = P[j][2]
unite(i0, j0)
#d0 = max(abs(P0[i0][0] - P0[j0][0]), abs(P0[i0][1] - P0[j0][1]))
#assert d0 == d
if abs(P0[i0][0] - P0[j0][0]) == abs(P0[i0][1] - P0[j0][1]):
D[i0] += 1
else:
C[i0] += 1
solve(P)
solve(Q)
ans = 0
r = root(a)
for i in range(N):
if root(i) == r:
ans += C[i] + D[i]//2
print((ans // 2))
| p03858 |
N, a, b = list(map(int, input().split())); a -= 1; b -= 1
P = []
Q = []
for i in range(N):
x, y = list(map(int, input().split()))
P.append((x-y, x+y, i))
Q.append((x+y, x-y, i))
d = max(abs(P[a][0] - P[b][0]), abs(P[a][1] - P[b][1]))
*parent, = list(range(N))
def root(x):
if x == parent[x]:
return x
y = parent[x] = root(parent[x])
return y
def unite(x, y):
px = root(x); py = root(y)
if px < py:
parent[py] = px
else:
parent[px] = py
C = [0]*N
D = [0]*N
def solve(P0):
P = P0[:]
P.sort()
s = t = 0
for i in range(N):
x, y, i0 = P[i]
while t < N and P[t][0] < x-d or (P[t][0] == x-d and P[t][1] <= y+d): t += 1
while s < N and (P[s][0] < x-d or (P[s][0] == x-d and P[s][1] < y-d)): s += 1
for j in range(s, t):
j0 = P[j][2]
unite(i0, j0)
if abs(P0[i0][0] - P0[j0][0]) == abs(P0[i0][1] - P0[j0][1]):
D[i0] += 1
else:
C[i0] += 1
solve(P)
solve(Q)
S = T = 0
r = root(a)
for i in range(N):
if root(i) == r:
S += C[i]; T += D[i]
print((S + T//2))
| N, a, b = list(map(int, input().split())); a -= 1; b -= 1
P = []
Q = []
for i in range(N):
x, y = list(map(int, input().split()))
P.append((x-y, x+y, i))
Q.append((x+y, x-y, i))
d = max(abs(P[a][0] - P[b][0]), abs(P[a][1] - P[b][1]))
*parent, = list(range(N))
def root(x):
if x == parent[x]:
return x
y = parent[x] = root(parent[x])
return y
def unite(x, y):
px = root(x); py = root(y)
if px < py:
parent[py] = px
else:
parent[px] = py
C = [0]*N
D = [0]*N
def check(P0, i0, j0):
return abs(P0[i0][0] - P0[j0][0]) == abs(P0[i0][1] - P0[j0][1])
def solve(P0):
P = P0[:]
P.sort()
s = t = 0; prev = -1
for i in range(N):
x, y, i0 = P[i]
while t < N and P[t][0] < x-d or (P[t][0] == x-d and P[t][1] <= y+d): t += 1
while s < N and (P[s][0] < x-d or (P[s][0] == x-d and P[s][1] < y-d)): s += 1
if s < t:
j0 = P[s][2]
unite(i0, j0)
if check(P0, i0, j0):
D[i0] += 1
else:
C[i0] += 1
if s < t-1:
j0 = P[t-1][2]
if check(P0, i0, j0):
D[i0] += 1
C[i0] += t-s-2
else:
C[i0] += t-s-1
for j in range(max(prev, s), t-1):
unite(P[j][2], P[j+1][2])
prev = t-1
solve(P)
solve(Q)
S = T = 0
r = root(a)
for i in range(N):
if root(i) == r:
S += C[i]; T += D[i]
print((S + T//2))
| p03858 |
n = int(eval(input()))
print((n*n*n))
| n = int(eval(input()))
print((n**3))
| p02915 |
# 2019-11-18 00:38:19(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
import re
# import heapq
# import array
# from scipy.misc import comb # (default: exact=False)
# import numpy as np
def main():
n = int(sys.stdin.readline().rstrip())
print((n ** 3))
if __name__ == "__main__":
main()
| import sys
n = int(sys.stdin.readline().rstrip())
def main():
return n ** 3
if __name__ == '__main__':
ans = main()
print(ans) | p02915 |
N = int(eval(input()))
print((N**3)) | num = int(eval(input()))
print((num ** 3)) | p02915 |
N = int(eval(input()))
print((N**3))
| def main() -> None:
print((int(eval(input())) ** 3))
if __name__ == '__main__':
main()
| p02915 |
a = int(eval(input()))
print((a**3))
| a=int(eval(input()))
print((a*a*a))
| p02915 |
"""
author : halo2halo
date : 18,Oct,2019
"""
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 7)
N = int(readline().rstrip())
print((N**3))
| """
author : halo2halo
date : 9, Jan, 2020
"""
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
A=int(read())
print((A**3))
| p02915 |
def resolve():
n = int(eval(input()))
print((n**3))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
print((int(eval(input()))**3))
resolve() | p02915 |
N = int(eval(input()))
print((pow(N, 3))) | #input
N = int(eval(input()))
#output
print((pow(N, 3))) | p02915 |
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline
from math import factorial
import heapq, bisect
import math
import itertools
import queue
from collections import deque
def main():
num = int(eval(input()))
print((num ** 3))
if __name__ == '__main__':
main()
| a = int(eval(input()))
answer = a * a * a
print(answer) | p02915 |
n=int(eval(input()))
print((n**3)) | n=int(eval(input()))
print((n*n*n)) | p02915 |
n = int(eval(input()))
print((n*n*n)) | n = int(eval(input()))
print((n**3)) | p02915 |
n = int(eval(input()))
print((n*n*n)) | n = int(eval(input()))
print((n**3)) | p02915 |
n = int(eval(input()))
print(("{}".format(n**3))) | n = int(eval(input()))
print((n**3)) | p02915 |
N=int(eval(input()))
print((N**3)) | print((int(eval(input())) ** 3)) | p02915 |
N = int(eval(input()))
print((N**3)) | N=int(eval(input()))
print((N*N*N)) | p02915 |
n=int(eval(input()))
print((n**3)) | print((int(eval(input()))**3)) | p02915 |
n = eval(input())
n = int(n)
typ = n ** 3
print(typ) | n = int(eval(input()))
print((n ** 3)) | p02915 |
import math
def lazy_update(s, e, value):
a = [(1, l+s, l+e, 1)]
while a:
k, s, e, depth = a.pop()
l_end, r_end = k << (rank-depth), (k+1) << (rank-depth)
mid = (l_end + r_end) // 2
if s == l_end and e == r_end:
lazy[k] = value
else:
if lazy[k] is not None:
lazy[k<<1] = lazy[k]
lazy[(k<<1)+1] = lazy[k]
lazy[k] = None
if s < mid:
a.append((k<<1, s, min(mid, e), depth+1))
if e > mid:
a.append(((k<<1)+1, max(mid, s), e, depth+1))
def get_value(i):
i += l
for j in range(rank, -1, -1):
n = lazy[i>>j]
if n is not None:
return n
return tree[i]
n, q = list(map(int,input().split()))
l = 1 << math.ceil(math.log2(n))
tree = [2**31-1]*(2*l)
lazy = [None]*(2*l)
rank = int(math.log2(len(tree)))
ans = []
ap = ans.append
for _ in [None]*q:
query = list(map(int, input().split()))
if query[0] == 0:
lazy_update(query[1], query[2]+1, query[3])
else:
ap(get_value(query[1]))
print(("\n".join((str(n) for n in ans)))) | import math
def lazy_update(s, e, value):
a = [(1, l+s, l+e, 1)]
ap = a.append
while a:
k, s, e, depth = a.pop()
l_end, r_end = k << (rank-depth), (k+1) << (rank-depth)
mid = (l_end + r_end) // 2
if s == l_end and e == r_end:
lazy[k] = value
else:
child = k<<1
if lazy[k] is not None:
lazy[child] = lazy[k]
lazy[child+1] = lazy[k]
lazy[k] = None
if s < mid:
ap((child, s, (mid, e)[e<mid], depth+1))
if e > mid:
ap((child+1, (mid, s)[s>mid], e, depth+1))
def get_value(i):
i += l
for j in range(rank, -1, -1):
n = lazy[i>>j]
if n is not None:
return n
return tree[i]
n, q = list(map(int,input().split()))
l = 1 << math.ceil(math.log2(n))
tree = [2**31-1]*(2*l)
lazy = [None]*(2*l)
rank = int(math.log2(len(tree)))
ans = []
ap = ans.append
for _ in [None]*q:
query = list(map(int, input().split()))
if query[0] == 0:
lazy_update(query[1], query[2]+1, query[3])
else:
ap(get_value(query[1]))
print(("\n".join((str(n) for n in ans)))) | p02348 |
import math
INT_MAX = 2147483647
MAX = 100003
n,q=(int(x) for x in input().split())
b= int(math.sqrt(n))
def update(x_f):
x = int(x_f)
for i in range(int(x*b),min(n-1,int((x+1)*b-1))+1):a[i]=l[x]
l[x]=-1
return
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for j in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com[0]
if l[int(x/b)] != -1:update(x/b)
print((a[x]))
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,min(y,int((x/b+1)*b-1))+1):a[i]=z
for i in range(int(x/b+1),int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(max(x,int(y/b**2)),y+1):a[i]=z
| import math
INT_MAX = 2147483647
MAX = 100003
n,q= l = list(map(int, input().split()))
b= int(math.sqrt(n))
def update(x_f):
x = int(x_f)
for i in range(int(x*b),min(n-1,int((x+1)*b-1))+1):a[i]=l[x]
l[x]=-1
return
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for j in range(q):
t = list(map(int, input().split()))
if t[0] :
x = t[1]
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
t0,x,y,z=t
if l[int(x/b)] != -1:update(x/b)
for i in range(x,min(y,int((x/b+1)*b-1))+1):a[i]=z
for i in range(int(x/b+1),int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(max(x,int(y/b**2)),y+1):a[i]=z
| p02348 |
import sys
sys.setrecursionlimit(20000)
def update(Set,x,y,z):
for i in range(x,y+1):
Set[i] = z
def lazy_update(Set,x,y,z):
left = int(x/4)
if((x%4)!=0):
left = left + 1
right = int(y/4)
for i in range(left,right):
Set[i] = z
return left*4,right*4
if __name__ == '__main__':
_N,query_num = list(map(int, input().split()))
A = [2**31 - 1]*_N
N = 1
while True:
if(N*4 >= _N):
break
N += 1
lazy_A = [None]*N
#print(A,lazy_A)
for i in range(query_num):
query = list(map(int,input().split()))
# update
if(query[0]==0):
if(lazy_A[int(query[1]/4)] is not None or lazy_A[int(query[2]/4)] is not None):
for i in range(int(query[1]/4),int(query[2]/4)+1):
if(lazy_A[i] is None):
continue
A[i*4:i*4+4] = [lazy_A[i]]*4
lazy_A[i] = None
#print("A update from lazy")
#print(A)
#print(lazy_A)
update(A,query[1],query[2],query[3])
#print("update A")
#print(A)
if(lazy_A[int(query[1]/4)] is None or lazy_A[int(query[2]/4)] is None):
if(query[2] - query[1] < 4):
update(A,query[1],query[2],query[3])
#print("A update")
#print(A)
else:
right, left = lazy_update(lazy_A,query[1],query[2],query[3])
#print("lazy update")
#print(lazy_A)
if(right > 0):
#print("A left update")
update(A,query[1],right-1,query[3])
#print(A)
if(left > 0):
#print("A right update")
update(A,left,query[2],query[3])
#print(A)
# find
if(query[0]==1):
if(lazy_A[int(query[1]/4)] is not None):
A[int(query[1]/4)*4:int(query[1]/4)*4+4] = [lazy_A[int(query[1]/4)]]*4
lazy_A[int(query[1]/4)] = None
#print("A update from lazy")
#print(A)
print((A[query[1]]))
| import sys
import time
sys.setrecursionlimit(20000)
def update(Set,x,y,z):
for i in range(x,y+1):
Set[i] = z
def lazy_update(Set,x,y,z):
left = int(x/4)
if((x%4)!=0):
left = left + 1
right = int(y/4)
for i in range(left,right):
Set[i] = z
return left*4,right*4
if __name__ == '__main__':
_N,query_num = list(map(int, input().split()))
A = [2**31 - 1]*_N
N = 1
while True:
if(N*4 >= _N):
break
N += 1
lazy_A = [None]*N
#start = time.time()
#print(A,lazy_A)
for i in range(query_num):
query = list(map(int,input().split()))
# update
if(query[0]==0):
if(lazy_A[int(query[1]/4)] is not None or lazy_A[int(query[2]/4)] is not None):
for i in range(int(query[1]/4),int(query[2]/4)+1):
if(lazy_A[i] is None):
continue
A[i*4:i*4+4] = [lazy_A[i]]*4
lazy_A[i] = None
#print("A update from lazy")
#print(A)
#print(lazy_A)
update(A,query[1],query[2],query[3])
#print("update A")
#print(A)
elif(lazy_A[int(query[1]/4)] is None or lazy_A[int(query[2]/4)] is None):
if(query[2] - query[1] < 4):
update(A,query[1],query[2],query[3])
#print("A update")
#print(A)
else:
right, left = lazy_update(lazy_A,query[1],query[2],query[3])
#print("lazy update")
#print(lazy_A)
if(right > 0):
#print("A left update")
update(A,query[1],right-1,query[3])
#print(A)
if(left > 0):
#print("A right update")
update(A,left,query[2],query[3])
#print(A)
# find
if(query[0]==1):
if(lazy_A[int(query[1]/4)] is not None):
A[int(query[1]/4)*4:int(query[1]/4)*4+4] = [lazy_A[int(query[1]/4)]]*4
lazy_A[int(query[1]/4)] = None
#print("A update from lazy")
#print(A)
print((A[query[1]]))
#elapsed_time = time.time() - start
#print ("elapsed_time:{0}".format(elapsed_time) + "[sec]")
| p02348 |
import sys
import math
sys.setrecursionlimit(20000)
INT_MAX = 2**31 - 1
lazy_init = (None,-1)
def lazy_tree_merge(lazy,tree,i,N):
if(lazy[i][0] is not None):
tree[i] = lazy[i]
if(i < N-1):
lazy[i*2+1] = lazy[i]
lazy[i*2+2] = lazy[i]
lazy[i] = lazy_init
def update(tree,lazy,x,y,k,l,r,i,z,N):
if (r <= x or y <= l):
lazy_tree_merge(lazy,tree,k,N)
return True
if ( x <= l and r <= y):
lazy[k] = (z,i)
lazy_tree_merge(lazy,tree,k,N)
return True
lazy_tree_merge(lazy,tree,k,N)
center = int((l+r)/2)
update(tree, lazy, x, y, k*2 + 1, l, center, i, z, N)
#update(tree, lazy, x, y, k*2 + 2, l, int((l+r)/2), i, z, N)
update(tree, lazy, x, y, k*2 + 2, center, r, i, z, N)
if(tree[k*2+1][1] < tree[k*2+2][1]):
tree[k] = tree[k*2+2]
else:
tree[k] = tree[k*2+1]
def find(tree,lazy,x,y,k,l,r,N):
if (r <= x or y <= l):
return INT_MAX
if ( x <= l and r <= y):
lazy_tree_merge(lazy,tree,k,N)
return tree[k][0]
lazy_tree_merge(lazy,tree,k,N)
v_left = find(tree, lazy_A, x, y, k*2 + 1, l, int((l+r)/2), N)
v_right = find(tree, lazy_A, x, y, k*2 + 2, int((l+r)/2), r, N)
return min(v_left, v_right)
if __name__ == '__main__':
_N,query_num = list(map(int, input().split()))
N = 1
while True:
if(N >= _N):
break
N <<= 1
if not (N == 1):
A = [(INT_MAX,-1)]*(2*N - 1)
lazy_A = [lazy_init]*(2*N - 1)
else:
A = [(INT_MAX,-1)]*(2*N)
lazy_A = [lazy_init]*(2*N)
for i in range(query_num):
query = list(map(int,input().split()))
# update
if(query[0]==0):
update(A,lazy_A,query[1],query[2]+1,0,0,N,i,query[3],N)
#print(A,lazy_A)
# find
if(query[0]==1):
z = find(A,lazy_A,query[1],query[1]+1,0,0,N,N)
print(z)
| import sys
import math
import time
sys.setrecursionlimit(20000)
INT_MAX = 2**31 - 1
def update(tree,x,y,z,N):
left = x + N #- 1
right = y + N#- 1
while True:
if(left >= right):
break
if(right % 2 == 1):
right -= 1
tree[right - 1] = z
if(left % 2 == 1):
tree[left - 1] = z
left += 1
#left += 1#math.floor((left + 1)/2)
#right -= 1#math.floor((right - 1)/2)
left >>= 1
right >>= 1
def find(tree,x,N):
x += N - 1
s = (INT_MAX, -1)
while True:
if(x < 0):
break
if(tree[x][0] is not None and (tree[x][1] > s[1])):
s = tree[x]
x = math.floor((x - 1)/2)
return s[0]
if __name__ == '__main__':
_N,query_num = list(map(int, input().split()))
N = 1
while True:
if(N >= _N):
break
N *= 2
A = [(None,-1)]*(2*N - 1)
#start = time.time()
for i in range(query_num):
query = list(map(int,input().split()))
# update
if(query[0]==0):
update(A,query[1],query[2]+1,(query[3],i),N)
#print(A)
# find
if(query[0]==1):
#z = find(A,lazy_A,query[1],query[1]+1,0,0,N,N)
z = find(A,query[1],N)
print(z)
#elapsed_time = time.time() - start
#print ("elapsed_time:{0}".format(elapsed_time) + "[sec]")
| p02348 |
n=int(input())
s=[input() for _ in range(n)]
cnt=[[0]*26 for _ in range(n)]
for i in range(n):
for j in range(len(s[i])):
cnt[i][ord(s[i][j])-ord("a")]+=1
ans=""
for j in range(26):
tmp=10**9
for i in range(n):
tmp=min(tmp,cnt[i][j])
ans+=chr(j+ord("a"))*tmp
print(ans) | n = int(input())
s = [input() for _ in range(n)]
cnt = [[0] * 26 for _ in range(n)]
for i in range(n):
for j in range(len(s[i])):
cnt[i][ord(s[i][j]) - ord("a")] += 1
ans = ""
for j in range(26):
cntmn = 10**9
for i in range(n):
cntmn = min(cntmn, cnt[i][j])
ans += chr(j + ord("a")) * cntmn
print(ans) | p03763 |
def f(ls,m,s):
global n
count = 0
if m > 0:
for i in range(len(ls)):
lls = ls[:]
a = (n-m+1)*lls.pop(i)
if s-a < 0:
break
else:
count += f(lls,m-1,s-a)
return count
else:
if s == 0:
return 1
else:
return 0
ls = [i for i in range(10)]
while True:
try:
n,s = list(map(int, input().split()))
print(f(ls,n,s))
except:
break | def mx(ls,m):
global n
sum = 0
for i in range(m):
sum += (n-i)*ls[-i-1]
return sum
def f(ls,m,s):
global n
count = 0
if m > 0:
if mx(ls,m) < s: return 0
for i in range(len(ls)):
lls = ls[:]
a = (n-m+1)*lls.pop(i)
if s-a < 0: break
else: count += f(lls,m-1,s-a)
return count
else:
return 1 if s == 0 else 0
ls = [i for i in range(10)]
while True:
try:
n,s = list(map(int, input().split()))
print(f(ls,n,s))
except:
break | p00070 |
def mx(ls,m):
global n
sum = 0
for i in range(m):
sum += (n-i)*ls[-i-1]
return sum
def mn(ls,m):
global n
sum = 0
for i in range(m):
sum += (n-i)*ls[i]
return sum
def f(ls,m,s):
global n
count = 0
if m > 0:
if mx(ls,m) < s or mn(ls,m) > s: return 0
for i in range(len(ls)):
lls = ls[:]
a = (n-m+1)*lls.pop(i)
if s-a < 0: break
else: count += f(lls,m-1,s-a)
return count
else:
return 1 if s == 0 else 0
ls = [i for i in range(10)]
while True:
try:
n,s = list(map(int, input().split()))
print(f(ls,n,s))
except:
break | def mx(ls,m):
global n
sum = 0
for i in range(m):
sum += (n-i)*ls[-i-1]
return sum
def mn(ls,m):
global n
sum = 0
for i in range(m):
sum += (n-i)*ls[i]
return sum
def f(ls,m,s):
global n
count = 0
if m > 0:
vmx,vmn = mx(ls,m),mn(ls,m)
if vmx < s or vmn > s: return 0
elif vmx == s or vmn == s: return 1
for i in range(len(ls)):
lls = ls[:]
a = (n-m+1)*lls.pop(i)
if s-a < 0: break
else: count += f(lls,m-1,s-a)
return count
else:
return 1 if s == 0 else 0
ls = [i for i in range(10)]
while True:
try:
n,s = list(map(int, input().split()))
print(f(ls,n,s))
except:
break | p00070 |
def mx(ls,m):
global n
sum = 0
for i in range(m):
sum += (n-i)*ls[-i-1]
return sum
def mn(ls,m):
global n
sum = 0
for i in range(m):
sum += (n-i)*ls[i]
return sum
def f(ls,m,s):
global n
count = 0
if m > 0:
vmx,vmn = mx(ls,m),mn(ls,m)
if vmx < s or vmn > s: return 0
elif vmx == s or vmn == s: return 1
for i in range(len(ls)):
lls = ls[:]
a = (n-m+1)*lls.pop(i)
if s-a < 0: break
else: count += f(lls,m-1,s-a)
return count
else:
return 1 if s == 0 else 0
ls = [i for i in range(10)]
while True:
try:
n,s = list(map(int, input().split()))
print(f(ls,n,s))
except:
break | def mxmn(ls,m):
global n
s1,s2 = 0, 0
for i in range(m):
s1 += (n-i)*ls[-i-1]
s2 += (n-i)*ls[i]
return s1,s2
def f(ls,m,s):
global n
count = 0
if m > 0:
mx,mn = mxmn(ls,m)
if mx < s or mn > s: return 0
elif mx == s or mn == s: return 1
for i in range(len(ls)):
lls = ls[:]
a = (n-m+1)*lls.pop(i)
if s-a < 0: break
else: count += f(lls,m-1,s-a)
return count
else:
return 1 if s == 0 else 0
ls = [i for i in range(10)]
while True:
try:
n,s = list(map(int, input().split()))
print(f(ls,n,s))
except:
break | p00070 |
import sys
dp=[[[0]*331 for i in range((1<<10)+1)] for j in range(12)]
#dp[12][1025][340]
dp[0][0][0]=1
for i in range(10):
for j in range(1<<10):
for c in range(331):
if dp[i][j][c]==0:
continue
for k in range(10):
if (j>>k&1)==0:
dp[i+1][j|(1<<k)][(i+1)*k+c]+=dp[i][j][c]
ans=[[0]*331 for unused in range(12)]
for i in range(11):
for j in range(1<<10):
for c in range(331):
ans[i][c]+=dp[i][j][c]
for line in sys.stdin.readlines():
n,s=list(map(int,line.strip().split()))
if s>330:
print(0)
else:
print(ans[n][s]) | import sys
dp=[[[0]*331 for i in range((1<<10)+1)] for j in range(12)]
#dp[12][1025][331]
dp[0][0][0]=1
for i in range(10):
for j in range(1<<10):
for c in range(331):
if dp[i][j][c]==0:
continue
for k in range(10):
if (j>>k&1)==0:
dp[i+1][j|(1<<k)][(i+1)*k+c]+=dp[i][j][c]
ans=[[0]*331 for unused in range(12)]
for i in range(11):
for j in range(1<<10):
for c in range(331):
ans[i][c]+=dp[i][j][c]
for line in sys.stdin.readlines():
n,s=list(map(int,line.strip().split()))
if s>330:
print(0)
else:
print(ans[n][s]) | p00070 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def solve(li, n, s, total, cnt):
for i in li:
value = i * n + total
if value > s:
break
if n > 1:
a = li[:]
a.remove(i)
solve(a, n - 1, s, value, cnt)
elif value == s:
cnt[0] += 1
for line in stdin:
n, s = (int(s) for s in line.split())
cnt = [0]
solve(list(range(10)), n, s, 0, cnt)
print(cnt[0]) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import (division, absolute_import, print_function,
unicode_literals)
from sys import stdin
def solve(li, n, s, total, cnt):
for i in li:
value = i * n + total
if value > s:
break
if n - 1:
subli = li[:]
subli.remove(i)
r = list(range(n - 1, 0, -1))
minimum = value + sum(i * j for i, j in zip(r, subli))
maximum = value + sum(i * j for i, j in zip(r, subli[::-1]))
if minimum <= s <= maximum:
solve(subli, n - 1, s, value, cnt)
elif value == s:
cnt[0] += 1
break
cnt = [0]
for line in stdin:
n, s = (int(s) for s in line.split())
cnt[0] = 0
solve(list(range(10)), n, s, 0, cnt)
print(cnt[0]) | p00070 |
import sys
from itertools import permutations
for line in sys.stdin:
n, s = list(map(int, line.split()))
count = 0
for combi in permutations(list(range(10)), n):
if sum(x * y for (x, y) in zip(list(range(1, 10)), combi)) == s:
count += 1
print(count) | import sys
def memoize(f):
memo = {}
def main(*args):
if args in memo:
return memo[args]
result = memo[args] = f(*args)
return result
return main
def get_num(remains):
i = 0
while remains:
if remains & 1:
yield i
i += 1
remains >>= 1
@memoize
def calc(n, s, remains):
if n == 1:
if remains & (1 << s):
return 1
else:
return 0
if s <= 0:
return 0
return sum(calc(n - 1, s - n * m, remains ^ (1 << m)) for m in get_num(remains) if s - n * m >= 0)
for line in sys.stdin:
n, s = list(map(int, line.split()))
print((calc(n, s, (1 << 10) - 1))) | p00070 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0070
"""
import sys
import time
from itertools import permutations
def solve1(pick, target):
# ????´???????????????????????????§???????????????????????????
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = []
for i in range(1, pick+1):
temp.append('{} * {}'.format(i, nums[0]))
nums = nums[1:]
exp = ' + '.join(temp)
ans = eval(exp)
if ans == target:
# print(exp)
hit += 1
return hit
def solve2(pick, target):
# ????????§??????????????£???????????§?????????????????§???????????????
# 10?????\?????????????????£???????????????????????????
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
ans = 0
for i in range(1, pick+1):
ans += (i * nums[i-1])
if ans > target:
break
if ans == target:
hit += 1
return hit
def solve3(pick, target):
#
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = [x * y for x, y in zip(nums, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])]
ans = sum(temp)
if ans == target:
hit += 1
return hit
def calc_min_max(pick, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§????????????
multiplier = list(range(1, pick+1))
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
temp = [x*y for x, y in zip(min_numbers, multiplier)]
min = sum(temp)
numbers = numbers[-pick:]
temp = [x*y for x, y in zip(numbers, multiplier)]
max = sum(temp)
return min, max
Hit = 0
def solve4(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 7.72 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
p_min, p_max = calc_min_max(pick-1, lnumbers)
if target-(n*pick) > p_max or target-(n*pick) < p_min:
continue
else:
solve4(pick-1, target-(n*pick), lnumbers)
def main(args):
global Hit
for line in sys.stdin:
pick, target = [int(x) for x in line.strip().split(' ')]
# start = time.time()
result = solve2(pick, target)
# end = time.time()
# print('solve1({}): {}'.format(end-start, result))
print(result)
# solve4(pick, target)
# print(Hit)
# Hit = 0
if __name__ == '__main__':
main(sys.argv[1:]) | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0070
"""
import sys
import time
from itertools import permutations
def solve1(pick, target):
# ????´???????????????????????????§???????????????????????????
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = []
for i in range(1, pick+1):
temp.append('{} * {}'.format(i, nums[0]))
nums = nums[1:]
exp = ' + '.join(temp)
ans = eval(exp)
if ans == target:
# print(exp)
hit += 1
return hit
def solve2(pick, target):
# ????????§??????????????£???????????§?????????????????§???????????????
# 10?????\?????????????????£??????????????????????????????40.0[s]??\???????????£??????????????§?????§????????????????????????
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
ans = 0
for i in range(1, pick+1):
ans += (i * nums[i-1])
if ans > target:
break
if ans == target:
hit += 1
return hit
def solve3(pick, target):
#
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = [x * y for x, y in zip(nums, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])]
ans = sum(temp)
if ans == target:
hit += 1
return hit
def calc_min_max(pick, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§????????????
multiplier = list(range(1, pick+1))
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
temp = [x*y for x, y in zip(min_numbers, multiplier)]
min = sum(temp)
numbers = numbers[-pick:]
temp = [x*y for x, y in zip(numbers, multiplier)]
max = sum(temp)
return min, max
Hit = 0
def solve4(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 7.72 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
p_min, p_max = calc_min_max(pick-1, lnumbers)
if target-(n*pick) > p_max or target-(n*pick) < p_min:
continue
else:
solve4(pick-1, target-(n*pick), lnumbers)
def has_possibility(pick, target, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§????????????
multiplier = list(range(1, pick+1))
max_numbers = numbers[-pick:]
temp = [x*y for x, y in zip(max_numbers, multiplier)]
max = sum(temp)
if target > max:
return False
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
temp = [x*y for x, y in zip(min_numbers, multiplier)]
min = sum(temp)
if target < min:
return False
return True
Hit = 0
def solve5(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 7.72 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
if has_possibility(pick-1, target-(n*pick), lnumbers):
solve5(pick-1, target-(n*pick), lnumbers)
else:
continue
def main(args):
global Hit
for line in sys.stdin:
global Hit
pick, target = [int(x) for x in line.strip().split(' ')]
solve5(pick, target)
print(Hit)
Hit = 0
# start = time.time()
# result = solve2(pick, target)
# end = time.time()
# print('solve1({}): {}'.format(end-start, result))
# solve5(8, 100)
# print(Hit)
# Hit = 0
# solve5(9, 150)
# print(Hit)
# Hit = 0
if __name__ == '__main__':
main(sys.argv[1:]) | p00070 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0070
"""
import sys
import time
from itertools import permutations
def solve1(pick, target):
# ????´???????????????????????????§???????????????????????????
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = []
for i in range(1, pick+1):
temp.append('{} * {}'.format(i, nums[0]))
nums = nums[1:]
exp = ' + '.join(temp)
ans = eval(exp)
if ans == target:
# print(exp)
hit += 1
return hit
def solve2(pick, target):
# ????????§??????????????£???????????§?????????????????§???????????????
# 10?????\?????????????????£??????????????????????????????40.0[s]??\???????????£??????????????§?????§????????????????????????
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
ans = 0
for i in range(1, pick+1):
ans += (i * nums[i-1])
if ans > target:
break
if ans == target:
hit += 1
return hit
def solve3(pick, target):
#
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = [x * y for x, y in zip(nums, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])]
ans = sum(temp)
if ans == target:
hit += 1
return hit
def calc_min_max(pick, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§????????????
multiplier = list(range(1, pick+1))
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
temp = [x*y for x, y in zip(min_numbers, multiplier)]
min = sum(temp)
numbers = numbers[-pick:]
temp = [x*y for x, y in zip(numbers, multiplier)]
max = sum(temp)
return min, max
Hit = 0
def solve4(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 7.72 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
p_min, p_max = calc_min_max(pick-1, lnumbers)
if target-(n*pick) > p_max or target-(n*pick) < p_min:
continue
else:
solve4(pick-1, target-(n*pick), lnumbers)
def has_possibility(pick, target, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§????????????
multiplier = list(range(1, pick+1))
max_numbers = numbers[-pick:]
temp = [x*y for x, y in zip(max_numbers, multiplier)]
max = sum(temp)
if target > max:
return False
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
temp = [x*y for x, y in zip(min_numbers, multiplier)]
min = sum(temp)
if target < min:
return False
return True
Hit = 0
def solve5(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 7.72 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
if has_possibility(pick-1, target-(n*pick), lnumbers):
solve5(pick-1, target-(n*pick), lnumbers)
else:
continue
def main(args):
global Hit
for line in sys.stdin:
global Hit
pick, target = [int(x) for x in line.strip().split(' ')]
solve5(pick, target)
print(Hit)
Hit = 0
# start = time.time()
# result = solve2(pick, target)
# end = time.time()
# print('solve1({}): {}'.format(end-start, result))
# solve5(8, 100)
# print(Hit)
# Hit = 0
# solve5(9, 150)
# print(Hit)
# Hit = 0
if __name__ == '__main__':
main(sys.argv[1:]) | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0070
"""
import sys
import time
from itertools import permutations
def solve1(pick, target):
# ????´???????????????????????????§???????????????????????????
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = []
for i in range(1, pick+1):
temp.append('{} * {}'.format(i, nums[0]))
nums = nums[1:]
exp = ' + '.join(temp)
ans = eval(exp)
if ans == target:
# print(exp)
hit += 1
return hit
def solve2(pick, target):
# ????????§??????????????£???????????§?????????????????§???????????????
# 10?????\?????????????????£??????????????????????????????40.0[s]??\???????????£??????????????§?????§????????????????????????
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
ans = 0
for i in range(1, pick+1):
ans += (i * nums[i-1])
if ans > target:
break
if ans == target:
hit += 1
return hit
def solve3(pick, target):
#
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = [x * y for x, y in zip(nums, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])]
ans = sum(temp)
if ans == target:
hit += 1
return hit
def calc_min_max(pick, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§????????????
multiplier = list(range(1, pick+1))
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
temp = [x*y for x, y in zip(min_numbers, multiplier)]
min = sum(temp)
numbers = numbers[-pick:]
temp = [x*y for x, y in zip(numbers, multiplier)]
max = sum(temp)
return min, max
Hit = 0
def solve4(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 7.72 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
p_min, p_max = calc_min_max(pick-1, lnumbers)
if target-(n*pick) > p_max or target-(n*pick) < p_min:
continue
else:
solve4(pick-1, target-(n*pick), lnumbers)
def has_possibility(pick, target, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§???????±???????
# ???????????°?????????????????????????????????????????????????????????
if pick == 1:
return numbers[0] <= target <= numbers[-1]
multiplier = list(range(1, pick+1))
max_numbers = numbers[-pick:] # ??§??????????????°??????pick????????????
max = sum(x*y for x, y in zip(max_numbers, multiplier))
if target > max:
return False
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
min = sum(x*y for x, y in zip(min_numbers, multiplier))
if target < min:
return False
return True
Hit = 0
def solve5(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 6.88 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
if has_possibility(pick-1, target-(n*pick), lnumbers):
solve5(pick-1, target-(n*pick), lnumbers)
else:
continue
def main(args):
global Hit
for line in sys.stdin:
pick, target = [int(x) for x in line.strip().split(' ')]
solve5(pick, target)
print(Hit)
Hit = 0
# start = time.time()
# result = solve2(pick, target)
# end = time.time()
# print('solve1({}): {}'.format(end-start, result))
# solve5(8, 100)
# print(Hit)
# Hit = 0
# solve5(9, 150)
# print(Hit)
# Hit = 0
if __name__ == '__main__':
main(sys.argv[1:]) | p00070 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0070
"""
import sys
import time
from itertools import permutations
def solve1(pick, target):
# ????´???????????????????????????§???????????????????????????
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = []
for i in range(1, pick+1):
temp.append('{} * {}'.format(i, nums[0]))
nums = nums[1:]
exp = ' + '.join(temp)
ans = eval(exp)
if ans == target:
# print(exp)
hit += 1
return hit
def solve2(pick, target):
# ????????§??????????????£???????????§?????????????????§???????????????
# 10?????\?????????????????£??????????????????????????????40.0[s]??\???????????£??????????????§?????§????????????????????????
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
ans = 0
for i in range(1, pick+1):
ans += (i * nums[i-1])
if ans > target:
break
if ans == target:
hit += 1
return hit
def solve3(pick, target):
#
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = [x * y for x, y in zip(nums, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])]
ans = sum(temp)
if ans == target:
hit += 1
return hit
def calc_min_max(pick, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§????????????
multiplier = list(range(1, pick+1))
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
temp = [x*y for x, y in zip(min_numbers, multiplier)]
min = sum(temp)
numbers = numbers[-pick:]
temp = [x*y for x, y in zip(numbers, multiplier)]
max = sum(temp)
return min, max
Hit = 0
def solve4(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 7.72 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
p_min, p_max = calc_min_max(pick-1, lnumbers)
if target-(n*pick) > p_max or target-(n*pick) < p_min:
continue
else:
solve4(pick-1, target-(n*pick), lnumbers)
def has_possibility(pick, target, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§???????±???????
# ???????????°?????????????????????????????????????????????????????????
if pick == 1:
return numbers[0] <= target <= numbers[-1]
multiplier = list(range(1, pick+1))
max_numbers = numbers[-pick:] # ??§??????????????°??????pick????????????
max = sum(x*y for x, y in zip(max_numbers, multiplier))
if target > max:
return False
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
min = sum(x*y for x, y in zip(min_numbers, multiplier))
if target < min:
return False
return True
Hit = 0
def solve5(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 6.88 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
if has_possibility(pick-1, target-(n*pick), lnumbers):
solve5(pick-1, target-(n*pick), lnumbers)
else:
continue
def main(args):
global Hit
for line in sys.stdin:
pick, target = [int(x) for x in line.strip().split(' ')]
solve5(pick, target)
print(Hit)
Hit = 0
# start = time.time()
# result = solve2(pick, target)
# end = time.time()
# print('solve1({}): {}'.format(end-start, result))
# solve5(8, 100)
# print(Hit)
# Hit = 0
# solve5(9, 150)
# print(Hit)
# Hit = 0
if __name__ == '__main__':
main(sys.argv[1:]) | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0070
"""
import sys
import time
from itertools import permutations
def solve1(pick, target):
# ????´???????????????????????????§???????????????????????????
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = []
for i in range(1, pick+1):
temp.append('{} * {}'.format(i, nums[0]))
nums = nums[1:]
exp = ' + '.join(temp)
ans = eval(exp)
if ans == target:
# print(exp)
hit += 1
return hit
def solve2(pick, target):
# ????????§??????????????£???????????§?????????????????§???????????????
# 10?????\?????????????????£??????????????????????????????40.0[s]??\???????????£??????????????§?????§????????????????????????
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
ans = 0
for i in range(1, pick+1):
ans += (i * nums[i-1])
if ans > target:
break
if ans == target:
hit += 1
return hit
def solve3(pick, target):
#
if target > 330:
return 0
hit = 0
for nums in permutations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], pick):
temp = [x * y for x, y in zip(nums, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])]
ans = sum(temp)
if ans == target:
hit += 1
return hit
def calc_min_max(pick, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§????????????
multiplier = list(range(1, pick+1))
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
temp = [x*y for x, y in zip(min_numbers, multiplier)]
min = sum(temp)
numbers = numbers[-pick:]
temp = [x*y for x, y in zip(numbers, multiplier)]
max = sum(temp)
return min, max
Hit = 0
def solve4(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 7.72 [s]
global Hit
if pick == 0:
if target == 0:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
p_min, p_max = calc_min_max(pick-1, lnumbers)
if target-(n*pick) > p_max or target-(n*pick) < p_min:
continue
else:
solve4(pick-1, target-(n*pick), lnumbers)
def has_possibility(pick, target, numbers):
# ?????????????????°???????????¨??????pick????????°????????????????????????????°????????????§???????±???????
# ???????????°?????????????????????????????????????????????????????????
if pick == 1:
return numbers[0] <= target <= numbers[-1]
multiplier = list(range(1, pick+1))
max_numbers = numbers[-pick:] # ??§??????????????°??????pick????????????
max = sum(x*y for x, y in zip(max_numbers, multiplier))
if target > max:
return False
min_numbers = numbers[:pick]
min_numbers.sort(reverse=True)
min = sum(x*y for x, y in zip(min_numbers, multiplier))
if target < min:
return False
return True
Hit = 0
def solve5(pick, target, numbers=[0,1,2,3,4,5,6,7,8,9]):
# 5.99 [s]
global Hit
if pick == 1:
if target in numbers:
Hit += 1
return
for n in numbers:
lnumbers = numbers[:]
lnumbers.remove(n)
if has_possibility(pick-1, target-(n*pick), lnumbers):
solve5(pick-1, target-(n*pick), lnumbers)
else:
continue
def main(args):
global Hit
for line in sys.stdin:
pick, target = [int(x) for x in line.strip().split(' ')]
solve5(pick, target)
print(Hit)
Hit = 0
# start = time.time()
# result = solve2(pick, target)
# end = time.time()
# print('solve1({}): {}'.format(end-start, result))
# solve5(8, 100)
# print(Hit)
# Hit = 0
# solve5(9, 150)
# print(Hit)
# Hit = 0
if __name__ == '__main__':
main(sys.argv[1:]) | p00070 |
import sys
def f0070(A,n,s):
if n==1: return (s in A)
c=0
A=sorted(A)
A1=A[:n][::-1]
A2=A[-n:]
N=list(range(n))
def f(A):
return sum([(i+1)*A[i] for i in N])
b1=f(A1)
b2=f(A2)
if b1<=s<=b2:
for i in range(len(A)):
b=s-A[i]*n
c+=f0070(A[:i]+A[i+1:],n-1,b)
return c
for a in sys.stdin:
n,s=list(map(int,a.split()))
print(f0070(list(range(10)),n,s)) | import sys
def f0070(A,n,s):
if n==1: return (s in A)
c=0
A=sorted(A)
A1=A[:n][::-1]
A2=A[-n:]
N=list(range(n))
def f(A):
return sum([(i+1)*A[i] for i in N])
if f(A1)<=s<=f(A2):
for i in range(len(A)):
b=s-A[i]*n
c+=f0070(A[:i]+A[i+1:],n-1,b)
return c
for a in sys.stdin:
n,s=list(map(int,a.split()))
print(f0070(list(range(10)),n,s)) | p00070 |
import sys
def f0070(A,n,s):
if n==1:
if s in A:f=1
else:f=0
return f
c=0
A=sorted(A)
A1=A[:n][::-1]
A2=A[-n:]
N=list(range(n))
def f(A):
return sum([(i+1)*A[i] for i in N])
if f(A1)<=s<=f(A2):
for i in range(len(A)):
b=s-A[i]*n
c+=f0070(A[:i]+A[i+1:],n-1,b)
return c
for a in sys.stdin:
n,s=list(map(int,a.split()))
print(f0070(list(range(10)),n,s)) | import sys
def f0070(A,n,s):
if n==1:return s in A
A=sorted(A)
A1=A[:n][::-1]
A2=A[-n:]
N=list(range(n))
b1=0
b2=0
c=0
for i in N:
b1+=(i+1)*A1[i]
b2+=(i+1)*A2[i]
if b1<=s<=b2:
for i in range(len(A)):
b=s-A[i]*n
c+=f0070(A[:i]+A[i+1:],n-1,b)
return c
for a in sys.stdin:
n,s=list(map(int,a.split()))
print(f0070(list(range(10)),n,s)) | p00070 |
import sys
def f0070(A,n,s):
if n==1:return s in A
A=sorted(A)
A1=A[:n][::-1]
A2=A[-n:]
N=list(range(n))
b1=0
b2=0
c=0
for i in N:
b1+=(i+1)*A1[i]
b2+=(i+1)*A2[i]
if b1<=s<=b2:
for i in range(len(A)):
b=s-A[i]*n
c+=f0070(A[:i]+A[i+1:],n-1,b)
return c
for a in sys.stdin:
n,s=list(map(int,a.split()))
print(f0070(list(range(10)),n,s)) | import sys
def f0070(A,n,s):
if n==1:return s in A
A=sorted(A)
A1=A[:n][::-1]
A2=A[-n:]
b1=0
b2=0
c=0
j=1
for i in range(n):
b1+=j*A1[i]
b2+=j*A2[i]
j+=1
if b1<=s<=b2:
for i in range(len(A)):
c+=f0070(A[:i]+A[i+1:],n-1,s-A[i]*n)
return c
for a in sys.stdin:
n,s=list(map(int,a.split()))
print(f0070(list(range(10)),n,s)) | p00070 |
H, W = list(map(int, input().split()))
a = [input().strip() for _ in range(H)]
a = list(map(''.join, list(zip(*a))))
ans = 0
def solve(a, c):
shift = [[0] * (H+1) for _ in range(H+1)]
for i in reversed(range(H)):
for j in reversed(range(H)):
shift[i][j] = shift[i+1][j+1] + int(a[H-1-i] == c[H-1-j])
dp = [[float('inf')] * (H+1) for _ in range(H+1)]
for i in range(H+1):
for j in range(H+1):
b = []
if i == j == 0:
b.append(0)
if i > 0:
b.append(dp[i-1][j] + shift[i-1][j])
if j > 0:
b.append(dp[i][j-1] + shift[i][j-1])
dp[i][j] = min(b)
#print a, c, shift
return dp[H][H]
for i in range(W-1):
i1 = i
i2 = i+1
ans += solve(a[i1], a[i2])
print(ans)
| H, W = list(map(int, input().split()))
a = [input().strip() for _ in range(H)]
a = list(map(''.join, list(zip(*a))))
ans = 0
def solve(a, c):
shift = [[0] * (H+1) for _ in range(H+1)]
for i in reversed(range(H)):
for j in reversed(range(H)):
shift[i][j] = shift[i+1][j+1] + int(a[H-1-i] == c[H-1-j])
dp = [[float('inf')] * (H+1) for _ in range(H+1)]
for i in range(H+1):
for j in range(H+1):
b = 2147483647
if i == j == 0:
b = 0
if i > 0:
b = min(b, dp[i-1][j] + shift[i-1][j])
if j > 0:
b = min(b, dp[i][j-1] + shift[i][j-1])
dp[i][j] = b
#print a, c, shift
return dp[H][H]
for i in range(W-1):
i1 = i
i2 = i+1
ans += solve(a[i1], a[i2])
print(ans)
| p03960 |
n,m = list(map(int,input().split()))
a = [input().rstrip() for i in range(n)]
b = list(zip(*a))
for i in range(m):
b[i] = "".join(b[i])
ans = 0
ct1 = [[0 for k in range(n-j+1)] for j in range(n+1)]
ct2 = [[0 for k in range(n-j+1)] for j in range(n+1)]
for i in range(m-1):
b1 = b[i]
b2 = b[i+1]
for j in range(n+1):
ct1[j][0] = 0
ct2[j][0] = 0
for k in range(n-j):
ct1[j][k+1] = ct1[j][k]
ct2[j][k+1] = ct2[j][k]
if b1[k+j] == b2[k]:
ct1[j][k+1] += 1
if b2[k+j] == b1[k]:
ct2[j][k+1] += 1
dp = [[10**6 for i in range(n+1)] for j in range(n+1)]
dp[0][0] = 0
for i in range(n+1):
for j in range(n+1):
if i <= j:
cost = ct2[j-i][n-j]
else:
cost = ct1[i-j][n-i]
if i < n:
dp[i+1][j] = min(dp[i+1][j],dp[i][j]+cost)
if j < n:
dp[i][j+1] = min(dp[i][j+1],dp[i][j]+cost)
ans += dp[-1][-1]
print(ans) | n,m = list(map(int,input().split()))
a = [input().rstrip() for i in range(n)]
b = list(zip(*a))
for i in range(m):
b[i] = "".join(b[i])
ans = 0
ct1 = [[0 for k in range(n-j+1)] for j in range(n+1)]
ct2 = [[0 for k in range(n-j+1)] for j in range(n+1)]
dp = [[10**5 for i in range(n+1)] for j in range(n+1)]
for i in range(m-1):
b1 = b[i]
b2 = b[i+1]
for j in range(n+1):
ct1[j][0] = 0
ct2[j][0] = 0
for k in range(n-j):
ct1[j][k+1] = ct1[j][k]
ct2[j][k+1] = ct2[j][k]
if b1[k+j] == b2[k]:
ct1[j][k+1] += 1
if b2[k+j] == b1[k]:
ct2[j][k+1] += 1
dp[0][0] = 0
for i in range(n+1):
if i < n:
dp[i+1][0] = 10**6
for j in range(n+1):
if i == 0 and j < n:
dp[i][j+1] = 10**6
if i <= j:
cost = ct2[j-i][n-j]
else:
cost = ct1[i-j][n-i]
if j < n:
dp[i][j+1] = min(dp[i][j+1],dp[i][j]+cost)
if i < n:
dp[i+1][j] = dp[i][j]+cost
ans += dp[-1][-1]
print(ans) | p03960 |
from math import sqrt
for i in range(int(eval(input()))):
a, b = list(map(int, input().split()))
if not a < b:
a, b = b, a
ans = (a-1)*2 + (a < b-1)
c = int(sqrt(a*b))
if c**2 == a*b:
c -= 1
if a < c:
if (a*b) % c == 0:
d = (a*b)//c - 1
else:
d = a*b//c
ans += (c - a) * 2 - (c==d)
print(ans)
| # seishin.py
from math import sqrt
Q = int(eval(input()))
for i in range(Q):
a, b = list(map(int, input().split()))
if not a < b:
a, b = b, a
if a == b or a+1 == b:
print((2*a-2))
continue
c = int(sqrt(a*b))
if c**2 == a*b:
c -= 1
if c*(c+1) >= a*b:
print((2*c-2))
continue
print((2*c-1)) | p03390 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
a = list(map(int,readline().split()))
s = a[0]+a[1]
if n == 2:
if a[0] < a[1] or s%2 == 1:
print((-1))
else:
print((a[0]-s//2))
exit()
c = 0
for i in a[2:]:
c ^= i
sc = (s-c)//2
if s < c or (s-c)%2 == 1 or c&sc != 0:
print((-1))
exit()
bb = a[0].bit_length()
x = ''
chk = 0
for i in range(bb-1,-1,-1):
if (c>>i&1)|(sc>>i&1) == 0:
x += '0'
elif c>>i&1 == 0 and sc>>i&1 == 1:
x += '1'
chk += 2**i
else:
x += 'p'
if chk > a[0]:
print((-1))
exit()
for i in range(bb):
if x[i] == 'p':
if a[0] >= chk+2**(bb-1-i):
chk += 2**(bb-1-i)
if chk == 0:
print((-1))
else:
print((a[0]-chk)) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline())
a = list(map(int,readline().split()))
s = a[0]+a[1]
if n == 2:
if a[0] < a[1] or s%2 == 1:
print((-1))
else:
print((a[0]-s//2))
exit()
c = 0
for i in a[2:]:
c ^= i
sc = (s-c)//2
if s < c or (s-c)%2 == 1 or c&sc:
print((-1))
exit()
bb = a[0].bit_length()
x = ''
chk = 0
for i in range(bb-1,-1,-1):
if not (c>>i&1)|(sc>>i&1):
x += '0'
elif not c>>i&1 and sc>>i&1:
x += '1'
chk += 2**i
else:
x += '?'
for i in range(bb):
if x[i] == '?':
if a[0] >= chk+2**(bb-1-i):
chk += 2**(bb-1-i)
ans = a[0]-chk
print((ans if a[0] > ans >= 0 else -1)) | p02626 |
import sys
sys.setrecursionlimit(10**7)
INF=10**18
def calc(a,b,xor):
if (a&1)^(b&1)!=(xor&1):
return INF
if xor==0:
if a<b:
return INF
else:
return (a-b)//2
x=2*calc(a//2,b//2,xor//2)
y=2*calc((a-1)//2,(b+1)//2,xor//2)+1
return min(x,y)
n=int(eval(input()))
arr=list(map(int,input().split()))
a,b=arr[0],arr[1]
xor=0
for i in range(2,n):
xor^=arr[i]
ans=calc(a,b,xor)
if ans>=a:
print((-1))
else:
print(ans) | INF=10**18
def calc(a,b,xor):
if (a,b,xor) in memo:
return memo[(a,b,xor)]
if (a&1)^(b&1)!=(xor&1):
return INF
if xor==0:
if a<b:
return INF
else:
return (a-b)//2
x=2*calc(a//2,b//2,xor//2)
y=2*calc((a-1)//2,(b+1)//2,xor//2)+1
memo[(a,b,xor)]=min(x,y)
return memo[(a,b,xor)]
n=int(eval(input()))
arr=list(map(int,input().split()))
a,b=arr[0],arr[1]
xor=0
for i in range(2,n):
xor^=arr[i]
memo={}
ans=calc(a,b,xor)
if ans>=a:
print((-1))
else:
print(ans) | p02626 |
from functools import reduce
from collections import defaultdict
N = int(eval(input()))
A = list(map(int,input().split()))
r = reduce(lambda x,y : x^y , A[2:],0)
a,b = A[:2]
def answer(ta,tb,tr):
for i in range(ta):
if (ta-i)^(tb+i) == tr:
ans = i
break
else:
ans = -1
return ans
def solve(a,b,r):
orga = a
ans = 0
l = max([len(bin(x)) for x in [a,b,r]]) - 2
cand = {(a,b,r):0}
for i in range(l):
temp = defaultdict(lambda : 10**10)
for (a,b,r),s in list(cand.items()):
x,y,z = a%2,b%2,r%2
if not x^y == z:
continue
else:
if s < temp[(a//2,b//2,r//2)]:
temp[(a//2,b//2,r//2)] = s
a -= 1
b += 1
if a < 0:
continue
s += (1<<i)
if s < temp[(a//2,b//2,r//2)]:
temp[(a//2,b//2,r//2)] = s
cand = temp
if not (0,0,0) in cand:
ans = -1
else:
ans = cand[(0,0,0)]
if ans == orga:
ans = -1
return ans
print((answer(a,b,r)))
| from functools import reduce
from collections import defaultdict
N = int(eval(input()))
A = list(map(int,input().split()))
r = reduce(lambda x,y : x^y , A[2:],0)
a,b = A[:2]
def answer(ta,tb,tr):
for i in range(ta):
if (ta-i)^(tb+i) == tr:
ans = i
break
else:
ans = -1
return ans
def solve(a,b,r):
orga = a
ans = 0
l = max([len(bin(x)) for x in [a,b,r]]) - 2
cand = {(a,b,r):0}
for i in range(l):
temp = defaultdict(lambda : 10**20)
for (a,b,r),s in list(cand.items()):
x,y,z = a%2,b%2,r%2
if not x^y == z:
continue
else:
if s < temp[(a//2,b//2,r//2)]:
temp[(a//2,b//2,r//2)] = s
a -= 1
b += 1
if a < 0:
continue
s += (1<<i)
if s < temp[(a//2,b//2,r//2)]:
temp[(a//2,b//2,r//2)] = s
cand = temp
if not (0,0,0) in cand:
ans = -1
else:
ans = cand[(0,0,0)]
if ans == orga:
ans = -1
return ans
print((solve(a,b,r)))
| p02626 |
import sys
N = int(eval(input()))
A = list(map(int,input().split()))
ALL = 0
for a in A:
ALL ^= a
ALL ^= A[0] ^ A[1]
for i in range(A[0]):
if ALL ^ (A[0] - i) ^ (A[1] + i) == 0:
print(i)
sys.exit()
print((-1)) | import sys
N = int(eval(input()))
A = list(map(int,input().split()))
ALL = 0
for a in A:
ALL ^= a
if ALL == 0:
print((0))
sys.exit()
ALL ^= A[0] ^ A[1]
K = A[0] + A[1]
L = []
for i in range(40, -1, -1):
if (1 << i) & ALL:
L.append(1)
K -= (1 << i)
else:
if K >= 2 * (1 << i):
L.append(2)
K -= 1 << (i + 1)
else:
L.append(0)
if K != 0:
print((-1))
sys.exit()
ans = 0
for i in range(41):
if L[i] == 2:
ans += 1 << (40 - i)
if ans >= A[0]:
print((-1))
sys.exit()
for i in range(41):
if L[i] == 1:
if ans + (1 << (40 - i)) < A[0]:
ans += 1 << (40 - i)
if ans == 0:
print((-1))
sys.exit()
print((A[0] - ans)) | p02626 |
def main():
import sys
def input(): return sys.stdin.readline().rstrip()
n = int(eval(input()))
a = list(map(int, input().split()))
x = 0
for i in range(2, n):
x ^= a[i]
d = a[0]+a[1]-x
if d%2 == 1 or d < 0:
print((-1))
return
d >>= 1
if d&x != 0 or d > a[0]:
print((-1))
return
k = x.bit_length()
tmp = d
# d^tmp はd&x=0からd|tmpと一緒
for i in range(40, -1, -1):
if (x >> i) & 1:
if tmp|1<<i <= a[0]:
tmp |= 1<<i
if 0 < tmp <= a[0]:
print((a[0]-tmp))
else:
print((-1))
if __name__ == '__main__':
main() | def main():
import sys
def input(): return sys.stdin.readline().rstrip()
n = int(eval(input()))
a = list(map(int, input().split()))
x = 0
for i in range(2, n):
x ^= a[i]
d = a[0]+a[1]-x
if d%2 == 1 or d < 0:
print((-1))
return
d >>= 1
if d&x != 0 or d > a[0]:
print((-1))
return
k = x.bit_length()
tmp = d
# d^tmp はd&x=0からd|tmpと一緒
for i in range(k, -1, -1):
if (x >> i) & 1:
if tmp|1<<i <= a[0]:
tmp |= 1<<i
if 0 < tmp <= a[0]:
print((a[0]-tmp))
else:
print((-1))
if __name__ == '__main__':
main() | p02626 |
def main(n,a):
s=a[0]+a[1]
z=0
for ai in a[2:]:
z^=ai
# i+j=s,i<=a[0],i^j=z となるi,jを探す
# i+j=i^j+2*(i & j)
# s = z + 2*(i & j)
# i & j = (s-z)/2 = d
# z = 2*(i & j) - s = i ^ j
# d = (s-z) / 2
# z = x^y , x&y=0
# d^x,d^yは条件を満たす。d^x+d^y=d^x^d^y + 2*((d^x)&(d^y))= z + 2*d = s
# (d^x)^(d^y)=x^y=z
# (d^x)&(d^y)=d (z & d = 0 のときのみ)
if s-z<0 or (s-z)%2==1:return -1
d=(s-z)//2
if d&z!=0:return -1
part=[]
i=0
while z//pow(2,i):
if (z//pow(2,i))%2==1:part.append(pow(2,i))
i+=1
ans=float('inf')
k=len(part)
for i in range(2**k):
x=0
y=0
for j in range(k):
if (i>>j)&1:
x+=part[j]
else:
y+=part[j]
u=d^x
v=d^y
if u+v==s and u<=a[0] and u!=0:
ans=min(ans,a[0]-u)
return ans if ans!=float('inf') else -1
n=int(eval(input()))
a=list(map(int,input().split()))
print((main(n,a))) | def main(n,a):
s=a[0]+a[1]
z=0
for ai in a[2:]:
z^=ai
# i+j=s,i<=a[0],i^j=z となるi,jを探す
# i+j=i^j+2*(i & j)
# s = z + 2*(i & j)
# i & j = (s-z)/2 = d
# z = 2*(i & j) - s = i ^ j
# d = (s-z) / 2
# z = x^y , x&y=0
# d^x,d^yは条件を満たす。d^x+d^y=d^x^d^y + 2*((d^x)&(d^y))= z + 2*d = s
# (d^x)^(d^y)=x^y=z
# (d^x)&(d^y)=d (z & d = 0 のときのみ)
if s-z<0 or (s-z)%2==1:return -1
d=(s-z)//2
if d&z!=0:return -1
if not d<=a[0]:return -1
part=[]
i=0
while z//pow(2,i):
if (z//pow(2,i))%2==1:part.append(pow(2,i))
i+=1
ans=float('inf')
k=len(part)
x=0
while part:
tmp=part.pop()
if d^(x+tmp)<=a[0]:
x+=tmp
return a[0]-(d^x) if d^x else -1
n=int(eval(input()))
a=list(map(int,input().split()))
print((main(n,a))) | p02626 |
N = int(eval(input()))
A = list(map(int, input().split()))
a, b = A[0], A[1]
X = 0
for i in range(2, N):
X ^= A[i]
S = a + b
M = 42
dp = [[[-1] * 2 for _ in range(2)] for _ in range(M + 1)]
dp[0][0][0] = 0
v = 1
for i in range(M):
cs = S & 1
cx = X & 1
ca = a & 1
for j in range(2):
for k in range(2):
if dp[i][j][k] == -1:
continue
for na in range(2):
for nb in range(2):
# 条件②: A' ^ B' = X
if na ^ nb != cx:
continue
# 条件①: A' + B' = S
ns = na + nb + j
if ns & 1 != cs:
continue
ni = i + 1
nj = 1 if ns >= 2 else 0
if na > ca:
nk = 1
elif na < ca:
nk = 0
else:
nk = k
dp[ni][nj][nk] = max(dp[ni][nj][nk], dp[i][j][k] + na * v)
S >>= 1
X >>= 1
a >>= 1
v <<= 1
ans = dp[M][0][0]
if ans <= 0:
print((-1))
else:
print((A[0] - ans))
| N = int(eval(input()))
A = list(map(int, input().split()))
# a = A_1, b = A_2, x = A_3 ^ ... ^ A_N, s = a + b とする
a, b = A[0], A[1]
x = 0
for i in range(2, N):
x ^= A[i]
s = a + b
M = 42
# dp[桁][繰り上げフラグ][これまでの桁でAより大きいフラグ] := Aとなり得る値の最大値
dp = [[[-1] * 2 for _ in range(2)] for _ in range(M + 1)]
dp[0][0][0] = 0
v = 1
for i in range(M):
cs = s & 1
cx = x & 1
ca = a & 1
for j in range(2):
for k in range(2):
if dp[i][j][k] == -1:
continue
for na in range(2):
for nb in range(2):
# 条件1: na ^ nb = x
if na ^ nb != cx:
continue
# 条件2: na + nb = S
ns = na + nb + j
if ns & 1 != cs:
continue
# 遷移先のi, j, kを求める
ni = i + 1
nj = 1 if ns >= 2 else 0
if na > ca:
nk = 1
elif na < ca:
nk = 0
else:
nk = k
# 遷移先を最大化
dp[ni][nj][nk] = max(dp[ni][nj][nk], dp[i][j][k] + na * v)
s >>= 1
x >>= 1
a >>= 1
v <<= 1
amax = dp[M][0][0]
if amax <= 0:
print((-1))
else:
print((A[0] - amax))
| p02626 |
N = int(eval(input()))
A = list(map(int, input().split()))
A3 = 0
for i in range(2, N):
A3 ^= A[i]
ans = -1
for i in range(A[0]):
if (A[0] - i) ^ (A[1] + i) == A3:
ans = i
break
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
P = 41
X = 0
for i in range(2, N):
X ^= A[i]
S = A[0] + A[1]
A1 = A[0]
D, M = divmod(S - X, 2)
ans = -1
if M % 2 == 0 and D & X == 0 and D <= A1:
Y = 0
for p in range(P, -1, -1):
if (X >> p) & 1 == 1:
new_Y = Y ^ (1 << p)
if D ^ new_Y <= A1:
Y = new_Y
ans = A1 - (D ^ Y)
if ans == A1:
ans = -1
print(ans) | p02626 |
mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
if N == 2:
if A[0] == A[1]:
print((0))
elif A[0] < A[1]:
print((-1))
else:
if (A[0] - A[1]) %2 == 0:
print(((A[0] - A[1])//2))
else:
print((-1))
exit()
g1 = A[0]
g2 = A[1]
g3 = 0
for i in range(2, N):
g3 ^= A[i]
n1 = g1.bit_length()
n2 = g2.bit_length()
n3 = g3.bit_length()
NN = max(n1, n2, n3)
ans = 0
while True:
for i in range(NN):
if (g1 >> i & 1) ^ (g2 >> i & 1) != (g3 >> i & 1):
r1 = g1 % (1 << i) + 1
r2 = (1<<i) - g2 % (1 << i)
if r1 < r2:
g1 -= r1
g2 += r1
ans += r1
break
elif r1 > r2:
g1 -= r2
g2 += r2
ans += r2
break
else:
print((-1))
exit()
if g1 ^ g2 == g3:
if ans != A[0]:
print(ans)
else:
print((-1))
exit()
if __name__ == '__main__':
main()
| mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
if N == 2:
if A[0] == A[1]:
print((0))
elif A[0] < A[1]:
print((-1))
else:
if (A[0] - A[1]) %2 == 0:
print(((A[0] - A[1])//2))
else:
print((-1))
exit()
g1 = A[0]
g2 = A[1]
g3 = 0
for i in range(2, N):
g3 ^= A[i]
n1 = g1.bit_length()
n2 = g2.bit_length()
n3 = g3.bit_length()
NN = max(n1, n2, n3)
ans = 0
cnt = 0
while True:
cnt += 1
if cnt == 10000:
print((-1))
exit()
for i in range(NN):
if (g1 >> i & 1) ^ (g2 >> i & 1) != (g3 >> i & 1):
r1 = g1 % (1 << i) + 1
r2 = (1<<i) - g2 % (1 << i)
if r1 < r2:
g1 -= r1
g2 += r1
ans += r1
break
elif r1 > r2:
g1 -= r2
g2 += r2
ans += r2
break
else:
print((-1))
exit()
if g1 ^ g2 == g3:
if ans != A[0]:
print(ans)
else:
print((-1))
exit()
if __name__ == '__main__':
main()
| p02626 |
N = int(eval(input()))
A = list(map(int, input().split()))
xor = 0
for a in A[2:]:
xor ^= a
n = A[0] + A[1] - xor
if n < 0 or n%2:
print((-1))
quit()
n //= 2
a = b = 0
digit = [1]
d = []
count = 0
while n or xor:
n0 = n & 1; xor0 = xor & 1
if n0:
if xor0:
print((-1))
quit()
else:
a += digit[-1]
b += digit[-1]
else:
if xor0:
b += digit[-1]
d.append(count)
digit.append(digit[-1] * 2)
count += 1
n >>= 1; xor >>= 1
if a > A[0]:
print((-1))
quit()
while d:
c = d.pop()
if a + digit[c] <= A[0]:
a += digit[c]; b -= digit[c]
if a:
print((A[0] - a))
else:
print((-1)) | N = int(eval(input()))
A = list(map(int, input().split()))
xor = 0
for a in A[2:]:
xor ^= a
n = A[0] + A[1] - xor
if n < 0 or n%2:
print((-1))
quit()
n //= 2
a = b = 0
digit = 1
d = []
while n or xor:
n0 = n & 1; xor0 = xor & 1
if n0:
if xor0:
print((-1))
quit()
else:
a += digit
b += digit
else:
if xor0:
b += digit
d.append(digit)
digit *= 2
n >>= 1; xor >>= 1
if a > A[0]:
print((-1))
quit()
while d:
dd = d.pop()
if a + dd <= A[0]:
a += dd; b -= dd
if a:
print((A[0] - a))
else:
print((-1)) | p02626 |
from functools import lru_cache
N, = list(map(int, input().split()))
X = list(map(int, input().split()))
t = 0
for x in X:
t = t^x
inf = float('inf')
@lru_cache(None)
def it(x, y, z):
xm, ym, zm = x%2, y%2, z%2
if xm ^ ym != zm:
return inf
if x^y == z:
return 0
Rz = 2*it(x>>1, y>>1, z>>1)
Ro = inf
if x:
Ro = 2*it((x-1)>>1, (y+1)>>1, z>>1)+1
Rz = min(Rz, Ro)
return Rz
r = it(X[0], X[1], t^X[0]^X[1])
if 0 <= r < X[0]:
print(r)
else:
print((-1))
| import sys
N, = list(map(int, input().split()))
X = list(map(int, input().split()))
S = X[0]+X[1]
T = 0
for i in range(2, N):
T ^= X[i]
if S<T or (S-T)%2:
print((-1))
sys.exit()
D = (S-T)//2
if D&T:
print((-1))
sys.exit()
M = T.bit_length()+1
if D > X[0]:
print((-1))
sys.exit()
Y = 0
for i in range(M, -1, -1):
if T & (1<<i) and ((1<<i)|Y)^D <= X[0]:
Y = (1<<i)|Y
if Y^D == 0:
print((-1))
else:
print((X[0]-(Y^D)))
| p02626 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.