input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
###############################################################################
from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
from collections import defaultdict
import math
mod = 1
def intin():
input_tuple = input().split()
if len(input_tuple) <= 1:
return int(input_tuple[0])
return tuple(map(int, input_tuple))
def intina():
return [int(i) for i in input().split()]
def intinl(count):
return [intin() for _ in range(count)]
def modadd(x, y):
global mod
return (x + y) % mod
def modmlt(x, y):
global mod
return (x * y) % mod
def lcm(x, y):
while y != 0:
z = x % y
x = y
y = z
return x
def combination(x, y):
assert(x >= y)
ret = math.factorial(x)
ret = ret // math.factorial(x - y)
ret = ret // math.factorial(y)
return ret
def get_divisors(x):
retlist = []
for i in range(1, int(x**0.5) + 3):
if x % i == 0:
retlist.append(i)
retlist.append(x // i)
return retlist
def get_factors(x):
retlist = []
for i in range(2, int(x**0.5) + 3):
while x % i == 0:
retlist.append(i)
x = x // i
retlist.append(x)
return retlist
def make_linklist(xylist):
linklist = {}
for a, b in xylist:
linklist.setdefault(a, [])
linklist.setdefault(b, [])
linklist[a].append(b)
linklist[b].append(a)
return linklist
def calc_longest_distance(linklist, v=1):
distance_list = {}
distance_count = 0
distance = 0
vlist_previous = []
vlist = [v]
nodecount = len(linklist)
while distance_count < nodecount:
vlist_next = []
for v in vlist:
distance_list[v] = distance
distance_count += 1
vlist_next.extend(linklist[v])
distance += 1
vlist_to_del = vlist_previous
vlist_previous = vlist
vlist = list(set(vlist_next) - set(vlist_to_del))
max_distance = -1
max_v = None
for v, distance in list(distance_list.items()):
if distance > max_distance:
max_distance = distance
max_v = v
return (max_distance, max_v)
def calc_tree_diameter(linklist, v=1):
_, u = calc_longest_distance(linklist, v)
distance, _ = calc_longest_distance(linklist, u)
return distance
class UnionFind:
def __init__(self, n):
self.parent = [i for i in range(n)]
def root(self, i):
if self.parent[i] == i:
return i
self.parent[i] = self.root(self.parent[i])
return self.parent[i]
def unite(self, i, j):
rooti = self.root(i)
rootj = self.root(j)
if rooti == rootj:
return
if rooti < rootj:
self.parent[rootj] = rooti
else:
self.parent[rooti] = rootj
def same(self, i, j):
return self.root(i) == self.root(j)
###############################################################################
mod = 10**9 + 7
def main():
n, m, k = intin()
c = combination(n * m - 2, k - 2) % mod
x_ans = ((n - 1) * n * (n + 1)) // 6
x_ans = modmlt(x_ans, m)
x_ans = modmlt(x_ans, m)
x_ans = modmlt(x_ans, c)
y_ans = ((m - 1) * m * (m + 1)) // 6
y_ans = modmlt(y_ans, n)
y_ans = modmlt(y_ans, n)
y_ans = modmlt(y_ans, c)
print((modadd(x_ans, y_ans)))
if __name__ == '__main__':
main()
| ###############################################################################
from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
from collections import defaultdict
import math
mod = 1
def intin():
input_tuple = input().split()
if len(input_tuple) <= 1:
return int(input_tuple[0])
return tuple(map(int, input_tuple))
def intina():
return [int(i) for i in input().split()]
def intinl(count):
return [intin() for _ in range(count)]
def modadd(x, y):
global mod
return (x + y) % mod
def modmlt(x, y):
global mod
return (x * y) % mod
def lcm(x, y):
while y != 0:
z = x % y
x = y
y = z
return x
def combination(x, y):
assert(x >= y)
ret = math.factorial(x)
ret = ret // (math.factorial(x - y) * math.factorial(y))
return ret
def get_divisors(x):
retlist = []
for i in range(1, int(x**0.5) + 3):
if x % i == 0:
retlist.append(i)
retlist.append(x // i)
return retlist
def get_factors(x):
retlist = []
for i in range(2, int(x**0.5) + 3):
while x % i == 0:
retlist.append(i)
x = x // i
retlist.append(x)
return retlist
def make_linklist(xylist):
linklist = {}
for a, b in xylist:
linklist.setdefault(a, [])
linklist.setdefault(b, [])
linklist[a].append(b)
linklist[b].append(a)
return linklist
def calc_longest_distance(linklist, v=1):
distance_list = {}
distance_count = 0
distance = 0
vlist_previous = []
vlist = [v]
nodecount = len(linklist)
while distance_count < nodecount:
vlist_next = []
for v in vlist:
distance_list[v] = distance
distance_count += 1
vlist_next.extend(linklist[v])
distance += 1
vlist_to_del = vlist_previous
vlist_previous = vlist
vlist = list(set(vlist_next) - set(vlist_to_del))
max_distance = -1
max_v = None
for v, distance in list(distance_list.items()):
if distance > max_distance:
max_distance = distance
max_v = v
return (max_distance, max_v)
def calc_tree_diameter(linklist, v=1):
_, u = calc_longest_distance(linklist, v)
distance, _ = calc_longest_distance(linklist, u)
return distance
class UnionFind:
def __init__(self, n):
self.parent = [i for i in range(n)]
def root(self, i):
if self.parent[i] == i:
return i
self.parent[i] = self.root(self.parent[i])
return self.parent[i]
def unite(self, i, j):
rooti = self.root(i)
rootj = self.root(j)
if rooti == rootj:
return
if rooti < rootj:
self.parent[rootj] = rooti
else:
self.parent[rooti] = rootj
def same(self, i, j):
return self.root(i) == self.root(j)
###############################################################################
mod = 10**9 + 7
def main():
n, m, k = intin()
c = combination(n * m - 2, k - 2) % mod
x_ans = ((n - 1) * n * (n + 1)) // 6
x_ans = modmlt(x_ans, m)
x_ans = modmlt(x_ans, m)
x_ans = modmlt(x_ans, c)
y_ans = ((m - 1) * m * (m + 1)) // 6
y_ans = modmlt(y_ans, n)
y_ans = modmlt(y_ans, n)
y_ans = modmlt(y_ans, c)
print((modadd(x_ans, y_ans)))
if __name__ == '__main__':
main()
| p03039 |
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 )
n,m,k = list(map(int,input().split()))
nm = n*m%(10**9+7)
k = k%(10**9+7)
a = (cmb(nm-2,k-2,mod)%(10**9+7))*(nm*(m*(n**2-1)+n*(m**2-1)))//6
print((a%(10**9+7))) | def main():
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 )
n,m,k = list(map(int,input().split()))
nm = n*m%(10**9+7)
a = (cmb(nm-2,k-2,mod)%(10**9+7))*(nm*(m*(n**2-1)+n*(m**2-1)))//6
print((a%(10**9+7)))
if __name__=='__main__':
main() | p03039 |
def egcd(a, b):
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return (lastx, lasty, a)
# ax ≡ 1 (mod m)なるxを返す
def modinv(a):
m=MOD
(inv, q, gcd_val) = egcd(a, m)
return inv % m
MOD=10**9+7
N,M,K=list(map(int,input().split()))
b=1
for i in range(N*M-2,N*M-K,-1):
b=(b*i)%MOD
for i in range(1,K-1):
b=(b*modinv(i))%MOD
x=0
for i in range(1,N):
x=x+i*(N-i)
x=(x*M*M)%MOD
y=0
for j in range(1,M):
y=y+j*(M-j)
y=(y*N*N)%MOD
ans=b*(x+y)%MOD
print(ans) | def modinv(a):
b=MOD
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return lastx%MOD
MOD=10**9+7
N,M,K=list(map(int,input().split()))
b=1
for i in range(1,K-1):
b=(b*(N*M-1-i)*modinv(i))%MOD
x=0
for i in range(1,N):
x=x+i*(N-i)
x=(x*M*M)%MOD
y=0
for j in range(1,M):
y=y+j*(M-j)
y=(y*N*N)%MOD
ans=b*(x+y)%MOD
print(ans) | p03039 |
def modinv(a):
b=MOD
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return lastx%MOD
MOD=10**9+7
N,M,K=list(map(int,input().split()))
b=1
for i in range(1,K-1):
b=(b*(N*M-1-i)*modinv(i))%MOD
x=0
for i in range(1,N):
x=x+i*(N-i)
x=(x*M*M)%MOD
y=0
for j in range(1,M):
y=y+j*(M-j)
y=(y*N*N)%MOD
ans=b*(x+y)%MOD
print(ans) | def comb(n, k):
x, y = 1, 1
k = min(k, n-k)
for i in range(k):
x *= n - i
x %= MOD
y *= i + 1
y %= MOD
return x*pow(y, MOD-2, MOD) % MOD
def modinv(a):
b=MOD
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return lastx%MOD
MOD=10**9+7
N,M,K=list(map(int,input().split()))
x=0
for i in range(1,N):
x=x+i*(N-i)
x=(x*M*M)%MOD
y=0
for j in range(1,M):
y=y+j*(M-j)
y=(y*N*N)%MOD
ans=comb(N*M-2,K-2)*(x+y)%MOD
print(ans) | p03039 |
def comb(n, k):
x, y = 1, 1
k = min(k, n-k)
for i in range(k):
x *= n - i
x %= MOD
y *= i + 1
y %= MOD
return x*pow(y, MOD-2, MOD) % MOD
def modinv(a):
b=MOD
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return lastx%MOD
MOD=10**9+7
N,M,K=list(map(int,input().split()))
x=0
for i in range(1,N):
x=x+i*(N-i)
x=(x*M*M)%MOD
y=0
for j in range(1,M):
y=y+j*(M-j)
y=(y*N*N)%MOD
ans=comb(N*M-2,K-2)*(x+y)%MOD
print(ans) | def comb(n, k):
x, y = 1, 1
k = min(k, n-k)
for i in range(k):
x *= n - i
x %= MOD
y *= i + 1
y %= MOD
return x*modinv(y) % MOD
def modinv(a):
b=MOD
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return lastx%MOD
MOD=10**9+7
N,M,K=list(map(int,input().split()))
x=0
for i in range(1,N):
x=x+i*(N-i)
x=(x*M*M)%MOD
y=0
for j in range(1,M):
y=y+j*(M-j)
y=(y*N*N)%MOD
ans=comb(N*M-2,K-2)*(x+y)%MOD
print(ans) | p03039 |
def cmb(a,b,c):
b = min(b,a-b)
num = 1
for i in range(b):
num = num*(a-i) % c
den = 1
for i in range(b):
den = den*(i+1) % c
return num * pow(den,c-2,c) % c
n,m,k = list(map(int,input().split()))
mod = 10**9+7
ans = 0
for i in range(1,n):
ans += i*(n-i)*m**2*cmb(n*m-2,k-2,mod)
ans %= mod
for i in range(1,m):
ans += i*(m-i)*n**2*cmb(n*m-2,k-2,mod)
ans %= mod
print(ans)
| def cmb(a,b,c):
b = min(b,a-b)
num = 1
for i in range(b):
num = num*(a-i) % c
den = 1
for i in range(b):
den = den*(i+1) % c
return num * pow(den,c-2,c) % c
n,m,k = list(map(int,input().split()))
mod = 10**9+7
ans = 0
C = cmb(n*m-2,k-2,mod)
for i in range(1,n):
ans += i*(n-i)*m**2*C
ans %= mod
for i in range(1,m):
ans += i*(m-i)*n**2*C
ans %= mod
print(ans)
| p03039 |
N,M,K=list(map(int,input().split()))
import math
def com(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
A=com(M*N-2, K-2)
MOD=10**9+7
ans=0
for d in range(1,N):
ans+=d*(N-d)*M*M*A%MOD
for d in range(1,M):
ans+=d*(M-d)*N*N*A%MOD
print((ans%MOD)) | N,M,K=list(map(int,input().split()))
def cmb(x,y):
X=1
Y=1
for i in range(1,y+1):
X= X*(x+1-i)%MOD
Y= Y*i%MOD
return (X*pow(Y,MOD-2,MOD))%MOD
MOD=10**9+7
A=cmb(M*N-2, K-2)
ans=0
for d in range(1,N):
ans+=d*(N-d)*M*M*A%MOD
for d in range(1,M):
ans+=d*(M-d)*N*N*A%MOD
print((ans%MOD)) | p03039 |
n,m,k=list(map(int,input().split()))
mod=10**9+7
f=[1]
for i in range(2*10**5+7):f+=[f[-1]*(i+1)%mod]
def comb(a,b):return f[a]*pow(f[b],mod-2,mod)*pow(f[a-b],mod-2,mod)%mod
ans=0
for i in range(1,n):
ans+=(i*(n-i)*m**2)*(comb(n*m-2,k-2))
ans%=mod
for i in range(1,m):
ans+=(i*(m-i)*n**2)*(comb(n*m-2,k-2))
ans%=mod
print(ans) | n,m,k=list(map(int,input().split()))
mod = 10**9+7
f = [1]
for i in range(n*m):
f += [f[-1]*(i+1) % mod]
def comb(a, b):
return f[a]*pow(f[b], mod-2, mod)*pow(f[a-b], mod-2, mod) % mod
ans=0
for dist in range(1,n):
c=n-dist
p=(c*m*m)%mod
ans+=p*dist
for dist in range(1,m):
c=m-dist
p=(c*n*n)%mod
ans+=p*dist
ans%=mod
print((ans*comb(n*m-2,k-2)%mod)) | p03039 |
import math
MOD = int(10**9 + 7)
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b%a, a)
return (g, x - (b//a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception("No inverse exists")
else:
return x % m
def combination(n, r):
return math.factorial(n) * modinv(math.factorial(r), MOD) * modinv(math.factorial(n-r), MOD)
# return math.factorial(n) // math.factorial(r) // math.factorial(n-r)
N, M, K = [int(x) for x in input().split()]
ans = 0
k = combination(N*M-2, K-2)
for d in range(1, N):
ans += d * k * M * M * (N - d)
for d in range(1, M):
ans += d * k * N * N * (M - d)
print((ans % MOD))
| import math
MOD = int(10**9 + 7)
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b%a, a)
return (g, x - (b//a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception("No inverse exists")
else:
return x % m
def combination(n, r):
return math.factorial(n)%MOD * modinv(math.factorial(r), MOD) * modinv(math.factorial(n-r), MOD) % MOD
# return math.factorial(n) // math.factorial(r) // math.factorial(n-r)
N, M, K = [int(x) for x in input().split()]
ans = 0
k = combination(N*M-2, K-2)
for d in range(1, N):
ans += (d * k * M * M * (N - d))%MOD
for d in range(1, M):
ans += (d * k * N * N * (M - d))%MOD
print((ans % MOD))
| p03039 |
import sys
input = sys.stdin.readline
import math
N, M, K = [int(item) for item in input().split()]
mod = 10**9 + 7
total = 0
for d in range(1, N):
score = (N - d) * M**2 * d
score %= mod
for i in range(2, K):
score *= ((N * M - i) % mod * pow(K - i, mod - 2, mod))
score %= mod
total += score
total %= mod
for d in range(1, M):
score = (M - d) * N**2 * d
score %= mod
for i in range(2, K):
score *= ((N * M - i) % mod * pow(K - i, mod - 2, mod))
score %= mod
total += score
total %= mod
print(total)
| import sys
input = sys.stdin.readline
import math
N, M, K = [int(item) for item in input().split()]
mod = 10**9 + 7
score_c = 1
for i in range(2, K):
score_c *= ((N * M - i) % mod * pow(K - i, mod - 2, mod))
score_c %= mod
total = 0
for d in range(1, N):
score = (N - d) * M**2 * d * score_c
score %= mod
total += score
total %= mod
for d in range(1, M):
score = (M - d) * N**2 * d * score_c
score %= mod
total += score
total %= mod
print(total)
| p03039 |
MOD = 10**9+7
N,M,K = list(map(int,input().split()))
U = N*M
fact = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
def comb(n,k):
x = fact[n]
x *= pow(fact[n-k],MOD-2,MOD)
x %= MOD
x *= pow(fact[k],MOD-2,MOD)
return x
res = 0
for i in range(1,N):
res += i*M*M*(N-i)%MOD
res %= MOD
for i in range(1,M):
res += i*N*N*(M-i)%MOD
res %= MOD
res *= comb(N*M-2,K-2)
res %= MOD
print(res) | mod = 10**9 + 7
n,m,k = list(map(int,input().split()))
nm = n*m
f = [1]*(nm+1)
for i in range(1,nm+1):
f[i] = (f[i-1]*i)%mod
def C(n,k):
x = f[n]
x *= pow(f[n-k],mod-2,mod)
x %= mod
x *= pow(f[k],mod-2,mod)
x %= mod
return x
def F(n):
x = n*n*(n+1)//2
y = n*(n+1)*(2*n+1)//6
return (x-y)%mod
res = (m*m%mod*F(n)%mod + n*n%mod*F(m)%mod)%mod
res *= C(n*m-2,k-2)
print((res%mod)) | p03039 |
from operator import mul
from functools import reduce
def cmb(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1,r + 1)))
return over // under
N, M, K = list(map(int, input().split()))
ans = 0
for i in range(1, M):
ans += (i * (M-i) * N**2) % (10**9 + 7)
for i in range(1, N):
ans += (i * (N-i) * M**2) % (10**9 + 7)
ans *= cmb((N*M-2)%(10**9+7) , K-2%(10**9+7))
print((int(ans % (10**9+7))))
| def framod(n, mod, a=1):
for i in range(1,n+1):
a=a * i % mod
return a
def power(n, r, mod):
if r == 0: return 1
if r%2 == 0:
return power(n*n % mod, r//2, mod) % mod
if r%2 == 1:
return n * power(n, r-1, mod) % mod
def comb(n, k, mod):
a=framod(n, mod)
b=framod(k, mod)
c=framod(n-k, mod)
return (a * power(b, mod-2, mod) * power(c, mod-2, mod)) % mod
N, M, K = list(map(int, input().split()))
ans = 0
for i in range(1, M):
ans += (i * (M-i) * N**2) % (10**9 + 7)
for i in range(1, N):
ans += (i * (N-i) * M**2) % (10**9 + 7)
ans *= comb(N*M-2 , K-2, 10**9+7)
print((int(ans % (10**9+7))))
| p03039 |
MOD = 10**9 + 7
N, M, K = list(map(int, input().split()))
invs = [1] * (K-1)
for x in range(2, K-1):
invs[x] = (-(MOD//x) * invs[MOD%x]) % MOD
C = 1
for x in range(N*M-K+1, N*M-1):
C *= x
C %= MOD
for x in range(1, K-1):
C *= invs[x]
C %= MOD
ans1 = 0
for d in range(1, N):
ans1 += (N-d) * d
ans1 %= MOD
ans1 *= M**2
ans1 %= MOD
ans2 = 0
for d in range(1, M):
ans2 += (M-d) * d
ans2 %= MOD
ans2 *= N**2
ans2 %= MOD
print(((ans1+ans2) * C % MOD))
| MOD = 10**9 + 7
N, M, K = list(map(int, input().split()))
def getComb(n, k, MOD):
if n < k:
return 0
if n-k < k:
k = n-k
comb = 1
for x in range(n-k+1, n+1):
comb = (comb * x) % MOD
d = 1
for x in range(1, k+1):
d = (d * x) % MOD
comb *= pow(d, MOD-2, MOD)
return comb % MOD
comb = getComb(N*M-2, K-2, MOD)
ans = 0
for i in range(N):
ans += i*(N-i)*M*M
ans %= MOD
for j in range(M):
ans += j*(M-j)*N*N
ans %= MOD
ans *= comb
ans %= MOD
print(ans)
| p03039 |
import math
N, M, K = (int(x) for x in input().split())
def nCm(n,m):
if m < 0 or m > n:
return 0
nf = math.factorial(n)
nm = math.factorial(m)
nm2 = math.factorial(n-m)
return (nf//nm//nm2) % 1000000007
c_sum = (M*(N-1)*N*(N+1)*M+N*(M-1)*M*(M+1)*N)//3
c_sum = c_sum//2
c_sum *= nCm(N*M-2, K-2)
c_sum = c_sum % 1000000007
print(c_sum)
| import math
N, M, K = (int(x) for x in input().split())
def comb(n,k,p):
if k < 0 or k > n:
return 0
if n == 0 or k == 0:
return 1
a=math.factorial(n) % p
b=math.factorial(k) % p
c=math.factorial(n-k) % p
return (a*mypow(b,p-2,p)*mypow(c,p-2,p)) % p
def mypow(a,b,p):
if b == 0: return 1
if b % 2 == 0:
d=mypow(a,b//2,p)
return d*d % p
if b % 2 == 1:
return (a*mypow(a,b-1,p )) % p
c_sum = (M*(N-1)*N*(N+1)*M+N*(M-1)*M*(M+1)*N)//3
c_sum = c_sum//2
c_sum *= comb(N*M-2, K-2, 1000000007)
c_sum = c_sum % 1000000007
print(c_sum)
| p03039 |
import math
N, M, K = (int(x) for x in input().split())
def nCm(n,m):
if m < 0 or m > n:
return 0
nf = math.factorial(n)
nm = math.factorial(m)
nm2 = math.factorial(n-m)
return (nf//nm//nm2) % 1000000007
c_sum = (M*(N-1)*N*(N+1)*M+N*(M-1)*M*(M+1)*N)//3
c_sum = c_sum//2
c_sum *= nCm(N*M-2, K-2)
c_sum = c_sum % 1000000007
print(c_sum)
| import math
N, M, K = (int(x) for x in input().split())
def comb(n,k,p):
if k < 0 or k > n:
return 0
if n == 0 or k == 0:
return 1
a=math.factorial(n) % p
b=math.factorial(k) % p
c=math.factorial(n-k) % p
return (a*mypow(b,p-2,p)*mypow(c,p-2,p)) % p
def mypow(a,b,p):
if b == 0: return 1
if b % 2 == 0:
d=mypow(a,b//2,p)
return d*d % p
if b % 2 == 1:
return (a*mypow(a,b-1,p )) % p
c_sum = (M*(N-1)*N*(N+1)*M+N*(M-1)*M*(M+1)*N)//3
c_sum = c_sum//2
c_sum *= comb(N*M-2, K-2, 1000000007)
c_sum = c_sum % 1000000007
print(c_sum)
| p03039 |
def combi(n, r) :
ret = 1
for i in range(n, n-r, -1) :
ret *= i
while r > 1 and ret % r == 0 :
ret //= r
r -= 1
return ret
MOD = 10 ** 9 + 7
N, M, K = list(map(int, input().split(' ')))
n, r = N * M - 2, K - 2
P = combi(n, r) % MOD
ans = 0
for n in range(N) :
for m in range(M) :
if n == 0 and m == 0 :
continue
d = n + m
cnt = (N - n) * (M - m) * (1 if n == 0 or m == 0 else 2)
ans += d * cnt * P
ans %= MOD
print(ans)
| from math import factorial
MOD = 10 ** 9 + 7
N, M, K = list(map(int, input().split(' ')))
n, r = N * M - 2, K - 2
#P = factorial(n) // factorial(n-r) // factorial(r) % MOD
P = factorial(n) * pow(factorial(n-r) % MOD, MOD - 2, MOD) * pow(factorial(r) % MOD, MOD - 2, MOD)
ans = 0
for n in range(N) :
for m in range(M) :
if n == 0 and m == 0 :
continue
d = n + m
cnt = (N - n) * (M - m) * (1 if n == 0 or m == 0 else 2)
ans += d * cnt
ans = (ans * P) % MOD
print(ans)
| p03039 |
N, M, K = list(map(int, input().split()))
MOD = 10**9+7
fact = [1 for i in range(N*M+1)]
for i in range(2, N*M+1):
fact[i] = fact[i-1] * i
def comb(n, r):
if n == 0 or r == 0:
return 1
return fact[n] // fact[n-r] // fact[r]
p = comb(N*M-2, K-2)
ans = 0
for i in range(N):
for j in range(M):
if i == 0 and j == 0:
continue
d = i+j
#print(i, j, calc_rec_num(N, M, 0, 0, i, j))
cnt = (N-i) * (M-j)
if i != 0 and j != 0:
cnt *= 2
ans += d * cnt
#if ans > DIV:
# ans %= DIV
#print(ans)
print(((ans*p)%MOD))
| from math import factorial
N, M, K = list(map(int, input().split()))
MOD = 10**9+7
def comb(n, r):
r = n-r if n-r < r else r
if r == 0:
return 1
ndfact = 1
for i in range(n, n-r, -1):
ndfact *= i
return ndfact // factorial(r)
p = comb(N*M-2, K-2)
ans = 0
for i in range(N):
for j in range(M):
if i == 0 and j == 0:
continue
d = i+j
#print(i, j, calc_rec_num(N, M, 0, 0, i, j))
cnt = (N-i) * (M-j)
if i != 0 and j != 0:
cnt *= 2
ans += d * cnt
#if ans > DIV:
# ans %= DIV
#print(ans)
print(((ans*p)%MOD))
| p03039 |
from math import factorial
N, M, K = list(map(int, input().split()))
MOD = 10**9+7
def comb(n, r):
r = n-r if n-r < r else r
if r == 0:
return 1
ndfact = 1
for i in range(n, n-r, -1):
ndfact *= i
return ndfact // factorial(r)
p = comb(N*M-2, K-2) % MOD
ans = 0
for i in range(N):
for j in range(M):
if i == 0 and j == 0:
continue
d = i+j
cnt = (N-i) * (M-j)
if i != 0 and j != 0:
cnt *= 2
ans += d * cnt
ans %= MOD
print(((ans*p)%MOD))
| from math import factorial
N, M, K = list(map(int, input().split()))
MOD = 10**9+7
fact = [1] * (N*M+1)
for i in range(2, N*M+1):
fact[i] = fact[i-1] * i % MOD
def comb(n, r):
r = n-r if n-r < r else r
return fact[n] * pow(fact[r], MOD-2, MOD) * pow(fact[n-r], MOD-2, MOD) % MOD
p = comb(N*M-2, K-2)
ans = 0
for i in range(N):
for j in range(M):
if i == 0 and j == 0:
continue
d = i+j
cnt = (N-i) * (M-j)
if i != 0 and j != 0:
cnt *= 2
ans += d * cnt % MOD
ans = ans * p % MOD
print(ans)
| p03039 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, self.pow(b, self.m-2))
def pow(self, x, y):
if y == 0:
return 1
elif y == 1:
return x % self.m
elif y % 2 == 0:
return self.pow(x, y//2)**2 % self.m
else:
return self.pow(x, y//2)**2 * x % self.m
class Combination:
def __init__(self, n, mod):
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)
self.MOD = mod
self.N = n
self.g1 = g1
self.g2 = g2
self.inverse = inverse
def __call__(self, n, r):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD
@mt
def slv(N, M, K):
m = Mod(10**9+7)
d = Combination(N*M, 10**9+7)(N*M-2, K-2)
ans = 0
for i in range(1, N+1):
for j in range(1, M+1):
if i == N and j == M:
continue
if i == N or j == M:
a = 1
else:
a = 2
ans = m.add(ans, m.mul(i*j*a, m.mul(i + j, d)))
ans = m.div(ans, 2)
return ans
def main():
N, M, K = read_int_n()
print(slv(N, M, K))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, self.pow(b, self.m-2))
def pow(self, x, y):
if y == 0:
return 1
elif y == 1:
return x % self.m
elif y % 2 == 0:
return self.pow(x, y//2)**2 % self.m
else:
return self.pow(x, y//2)**2 * x % self.m
class Combination:
def __init__(self, n, mod):
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)
self.MOD = mod
self.N = n
self.g1 = g1
self.g2 = g2
self.inverse = inverse
def __call__(self, n, r):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD
@mt
def slv(N, M, K):
m = Mod(10**9+7)
b = Combination(N*M, 10**9+7)(N*M-2, K-2)
MM = m.mul(M, M)
NN = m.mul(N, N)
ans = 0
for d in range(1, N):
ans = m.add(ans, m.mul(m.mul(m.mul(d, N-d), MM), b))
for d in range(1, M):
ans = m.add(ans, m.mul(m.mul(m.mul(d, M-d), NN), b))
return ans
def main():
N, M, K = read_int_n()
print(slv(N, M, K))
if __name__ == '__main__':
main()
| p03039 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, self.pow(b, self.m-2))
def pow(self, x, y):
if y == 0:
return 1
elif y == 1:
return x % self.m
elif y % 2 == 0:
return self.pow(x, y//2)**2 % self.m
else:
return self.pow(x, y//2)**2 * x % self.m
class Combination:
def __init__(self, n, mod):
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)
self.MOD = mod
self.N = n
self.g1 = g1
self.g2 = g2
self.inverse = inverse
def __call__(self, n, r):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD
@mt
def slv(N, M, K):
m = Mod(10**9+7)
b = Combination(N*M, 10**9+7)(N*M-2, K-2)
MM = m.mul(M, M)
NN = m.mul(N, N)
ans = 0
for d in range(1, N):
ans = m.add(ans, m.mul(m.mul(m.mul(d, N-d), MM), b))
for d in range(1, M):
ans = m.add(ans, m.mul(m.mul(m.mul(d, M-d), NN), b))
return ans
def main():
N, M, K = read_int_n()
print(slv(N, M, K))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().split()
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
class Combination:
def __init__(self, n, mod):
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)
self.MOD = mod
self.N = n
self.g1 = g1
self.g2 = g2
self.inverse = inverse
def __call__(self, n, r):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return self.g1[n] * self.g2[r] * self.g2[n-r] % self.MOD
@mt
def slv(N, M, K):
mod = 10**9+7
C = Combination(N*M, mod)
b = C(N*M-2, K-2)
ans = 0
m = M**2
for d in range(1, N):
ans += (N-d) * b * d * m
ans %= mod
m = N**2
for d in range(1, M):
ans += (M-d) * b * d * m
ans %= mod
return ans
def main():
N, M, K = read_int_n()
print(slv(N, M, K))
if __name__ == '__main__':
main()
| p03039 |
def com(n,r):
if n-r<r:
r=n-r
re=1
for i in range(n,n-r,-1):
re*=i
for i in range(1,r+1):
re//=i
return re
def f(n,m,k):
md = 10 ** 9 + 7
ans = 0
for d in range(1, m):
ans = (ans + d * (m - d) * n * n) % md
for d in range(1, n):
ans = (ans + d * (n - d) * m * m) % md
ans = (ans * com(n * m - 2, k - 2)) % md
print(ans)
n,m,k=list(map(int,input().split()))
f(n, m, k)
| def com(n,r):
re=fct[n]*pow(fct[r],md-2,md)*pow(fct[n-r],md-2,md)
re%=md
return re
n,m,k=list(map(int,input().split()))
md=10**9+7
ans=0
fct=[1]*(n*m-1)
f=1
for i in range(1,n*m-1):
f=f*i%md
fct[i]=f
for d in range(1,m):
ans=(ans+d*(m-d)*n*n)%md
for d in range(1,n):
ans=(ans+d*(n-d)*m*m)%md
ans=(ans*com(n*m-2,k-2))%md
print(ans)
| p03039 |
from math import factorial
mod=10**9+7
def cmb(n, r):
return factorial(n) // factorial(r) // factorial(n - r)%mod
n,m,k=list(map(int,input().split()))
print((((pow(m,2,mod)*cmb(n*m-2,k-2)*sum((n-i)*i%mod for i in range(1,n))%mod)+pow(n,2,mod)*cmb(n*m-2,k-2)*sum((m-i)*i%mod for i in range(1,m))%mod)%mod)) | mod=10**9+7
def mod_combination(n, k, mod):
def ext_gcd(a, b):
if b == 0:return a, 1, 0
else:d,x,y = ext_gcd(b,a%b);x-=(a//b)*y
return d,y,x
p,q=1,1
for i in range(n-k+1,n+1):
p=(p*i)%mod
for i in range(2,k+1):
q=(q*i)%mod
return int(p*(ext_gcd(q, mod)[1]%mod)%mod)
n,m,k=list(map(int,input().split()))
print((((pow(m,2,mod)*mod_combination(n*m-2,k-2,mod)*sum((n-i)*i%mod for i in range(1,n))%mod)+pow(n,2,mod)*mod_combination(n*m-2,k-2,mod)*sum((m-i)*i%mod for i in range(1,m))%mod)%mod)) | p03039 |
# https://atcoder.jp/contests/abc127/tasks/abc127_e
import itertools
from collections import Counter
from collections import defaultdict
import bisect
import math
# Calculate count of combination
def combination(n, r):
if r == 0:
return 1
a = 1
b = 1
for i in range(r):
a *= (n - i)
if a % (i + 1):
a //= (i + 1)
else:
b *= (i + 1)
return a // b
def main():
MOD = 10**9 + 7
N, M, K = list(map(int, input().split()))
pattern = combination(N * M - 2, K - 2)
# print(com)
pattern = pattern % MOD
# print(com)
ans = 0
for dx in range(1, M):
ans += dx * (M - dx) * pattern * (N * N)
ans = ans % MOD
# y
for dy in range(1, N):
ans += dy * (N - dy) * pattern * (M * M)
ans = ans % MOD
ans = ans % MOD
print(ans)
if __name__ == '__main__':
main()
| # https://atcoder.jp/contests/abc127/tasks/abc127_e
import itertools
from collections import Counter
from collections import defaultdict
import bisect
import math
# Calculate count of combination
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 combination(n, r):
if r == 0:
return 1
a = 1
b = 1
for i in range(r):
a *= (n - i)
if a % (i + 1):
a //= (i + 1)
else:
b *= (i + 1)
return a // b
def main():
MOD = 10**9 + 7
N, M, K = list(map(int, input().split()))
pattern = cmb(N * M - 2, K - 2)
# print(com)
pattern = pattern % MOD
# print(com)
ans = 0
for dx in range(1, M):
ans += dx * (M - dx) * pattern * (N * N)
ans = ans % MOD
# y
for dy in range(1, N):
ans += dy * (N - dy) * pattern * (M * M)
ans = ans % MOD
ans = ans % MOD
print(ans)
if __name__ == '__main__':
main()
| p03039 |
import sys
input = sys.stdin.readline
from operator import mul
from functools import reduce
def cmb(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1,r + 1)))
return over // under
N, M, K = list(map(int, input().split()))
mod = 10**9 + 7
x = N*N*(M*M*(M+1)//2 - M*(M+1)*(2*M+1)//6)
y = M*M*(N*N*(N+1)//2 - N*(N+1)*(2*N+1)//6)
ans = cmb(N*M-2, K-2) * (x + y) % mod
print(ans) | from math import factorial
def comb(n, k, mod):
if n < 0 or k < 0 or n < k:
return 0
if n == 0 or k == 0:
return 1
a=factorial(n) % mod
b=factorial(k) % mod
c=factorial(n-k) % mod
return (a*power_func(b, mod-2, mod)*power_func(c, mod-2, mod)) % mod
def power_func(a,b,mod):
if b == 0:
return 1
if b % 2 == 0:
d = power_func(a, b//2, mod)
return d*d % mod
if b % 2 == 1:
return (a*power_func(a, b-1, mod)) % mod
N, M, K = list(map(int, input().split()))
mod = 10**9 + 7
x = N*N*(M*M*(M+1)//2 - M*(M+1)*(2*M+1)//6)
y = M*M*(N*N*(N+1)//2 - N*(N+1)*(2*N+1)//6)
ans = comb(N*M-2, K-2, mod) * (x + y) % mod
print(ans) | p03039 |
import itertools
import sys
from functools import reduce
from operator import mul
sys.setrecursionlimit(10000)
INF = float('inf')
def comb(n, r):
"""
scipy.misc.comb または scipy.special.comb と同じ
組み合わせの数 nCr
:param int n:
:param int r:
:rtype: int
"""
assert n >= r
r = min(n - r, r)
if r == 0:
return 1
return reduce(mul, list(range(n, n - r, -1))) // reduce(mul, list(range(r, 0, -1)))
N, M, K = list(map(int, input().split()))
def pyramid(n):
return n * (n + 1) * (n + 2) // 6
# K ==2 の場合
# print(pyramid(N - 1) * M ** 2 + pyramid(M - 1) * N ** 2)
a = comb(N * M-2, K-2)
b = pyramid(N - 1) * M ** 2 + pyramid(M - 1) * N ** 2
print((a*b% (10**9+7)))
| import math
import sys
sys.setrecursionlimit(10000)
INF = float('inf')
def inv(x):
return pow(x, MOD - 2, MOD)
def comb(n, r, mod):
# https://fushime2.hatenablog.com/entry/2016/11/12/155543
return (math.factorial(n) * inv(math.factorial(n - r)) * inv(math.factorial(r))) % mod
N, M, K = list(map(int, input().split()))
def pyramid(n):
return n * (n + 1) * (n + 2) // 6
MOD = 10 ** 9 + 7
# K ==2 の場合
# print(pyramid(N - 1) * M ** 2 + pyramid(M - 1) * N ** 2)
k2 = (pyramid(N - 1) * M ** 2 + pyramid(M - 1) * N ** 2) % MOD
# k2 を何回使うか
c = comb(N * M - 2, K - 2, mod=MOD)
print((k2 * c % MOD))
| p03039 |
mod = 10**9 + 7
def comb(n, k):
x, y = 1, 1
k = min(k, n-k)
for i in range(k):
x *= n - i
y *= i + 1
return x*pow(y, mod-2, mod) % mod
N, M, K = list(map(int, input().split()))
print(((sum(i*(N-i)*M**2 for i in range(N))+sum(i*(M-i)*N**2 for i in range(M)))*comb(N*M-2, K-2) % mod)) | mod = 10**9 + 7
def comb(n, k):
x, y = 1, 1
k = min(k, n-k)
for i in range(k):
x *= n - i
x %= mod
y *= i + 1
y %= mod
return x*pow(y, mod-2, mod) % mod
N, M, K = list(map(int, input().split()))
print(((sum(i*(N-i)*M**2 for i in range(N))+sum(i*(M-i)*N**2 for i in range(M)))*comb(N*M-2, K-2) % mod)) | p03039 |
mod = 10**9 + 7
def comb(n, k):
x, y = 1, 1
k = min(k, n-k)
for i in range(k):
x *= n - i
x %= mod
y *= i + 1
y %= mod
return x*pow(y, mod-2, mod) % mod
N, M, K = list(map(int, input().split()))
print(((sum(i*(N-i)*M**2 for i in range(N))+sum(i*(M-i)*N**2 for i in range(M)))*comb(N*M-2, K-2) % mod)) | mod = 10**9 + 7
def comb(n, k):
x, y = 1, 1
k = min(k, n-k)
for i in range(k):
x *= n - i
x %= mod
y *= i + 1
y %= mod
return x*pow(y, mod-2, mod) % mod
N, M, K = list(map(int, input().split()))
print(((M*M%mod*((N**3-N)//6%mod)%mod+N*N%mod*((M**3-M)//6%mod)%mod)%mod*comb(N*M-2,K-2)%mod)) | p03039 |
def combination(n, r):
r = min(n - r, r)
result = 1
for i in range(n, n - r, -1):
result *= i
for i in range(1, r + 1):
result //= i
return result
N, M, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
NM = N * M
fa = [1] * (NM + 1)
for i in range(1, NM + 1):
fa[i] = (fa[i - 1] * i) % mod
ans = 0
for i in range(1, N):
ans += (i * M * M * (N - i)) % mod
ans %= mod
for i in range(1, M):
ans += (i * N * N *(M-i)) % mod
ans %= mod
ans *= combination(NM-2, K-2)
ans %= mod
print(ans)
| class FactMod:
def __init__(self, n, mod):
self.mod = mod
self.f = [1] * (n + 1)
for i in range(1, n + 1):
self.f[i] = self.f[i - 1] * i % mod
self.inv = [pow(self.f[-1], mod - 2, mod)]
for i in reversed(list(range(1, n + 1))):
self.inv.append(self.inv[-1] * i % mod)
self.inv.reverse()
def fact(self, n):
"""
:return: n!
"""
return self.f[n]
def comb(self, n, r):
"""
:return: nCr
"""
return self.f[n] * self.inv[n - r] * self.inv[r] % self.mod
N, M, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
NM = N * M
fa = [1] * (NM + 1)
for i in range(1, NM + 1):
fa[i] = (fa[i - 1] * i) % mod
ans = 0
for i in range(1, N):
ans += (i * M * M * (N - i)) % mod
ans %= mod
for i in range(1, M):
ans += (i * N * N *(M-i)) % mod
ans %= mod
factmod = FactMod(NM-2, mod)
ans *= factmod.comb(NM-2, K-2)
ans %= mod
print(ans)
| p03039 |
class FactMod:
def __init__(self, n, mod):
self.mod = mod
self.f = [1] * (n + 1)
for i in range(1, n + 1):
self.f[i] = self.f[i - 1] * i % mod
self.inv = [pow(self.f[-1], mod - 2, mod)]
for i in reversed(list(range(1, n + 1))):
self.inv.append(self.inv[-1] * i % mod)
self.inv.reverse()
def fact(self, n):
"""
:return: n!
"""
return self.f[n]
def comb(self, n, r):
"""
:return: nCr
"""
return self.f[n] * self.inv[n - r] * self.inv[r] % self.mod
N, M, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
NM = N * M
fa = [1] * (NM + 1)
for i in range(1, NM + 1):
fa[i] = (fa[i - 1] * i) % mod
ans = 0
for i in range(1, N):
ans += (i * M * M * (N - i)) % mod
ans %= mod
for i in range(1, M):
ans += (i * N * N *(M-i)) % mod
ans %= mod
factmod = FactMod(NM-2, mod)
ans *= factmod.comb(NM-2, K-2)
ans %= mod
print(ans)
| class FactMod:
def __init__(self, n, mod):
self.mod = mod
self.f = [1] * (n + 1)
for i in range(1, n + 1):
self.f[i] = self.f[i - 1] * i % mod
self.inv = [pow(self.f[-1], mod - 2, mod)]
for i in reversed(list(range(1, n + 1))):
self.inv.append(self.inv[-1] * i % mod)
self.inv.reverse()
def fact(self, n):
"""
:return: n!
"""
return self.f[n]
def comb(self, n, r):
"""
:return: nCr
"""
return self.f[n] * self.inv[n - r] * self.inv[r] % self.mod
N, M, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
NM = N * M
ans = 0
for i in range(1, N):
ans += (i * M * M * (N - i)) % mod
ans %= mod
for i in range(1, M):
ans += (i * N * N * (M - i)) % mod
ans %= mod
factmod = FactMod(NM - 2, mod)
ans *= factmod.comb(NM - 2, K - 2)
ans %= mod
print(ans)
| p03039 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
class modfact(object):
def __init__(self,n):
fact=[1]*(n+1); invfact=[1]*(n+1)
for i in range(1,n+1): fact[i]=i*fact[i-1]%MOD
invfact[n]=pow(fact[n],MOD-2,MOD)
for i in range(n-1,-1,-1): invfact[i]=invfact[i+1]*(i+1)%MOD
self.__fact=fact; self.__invfact=invfact
def inv(self,n):
assert(n>0)
return self.__fact[n-1]*self.__invfact[n]%MOD
def fact(self,n):
return self.__fact[n]
def invfact(self,n):
return self.__invfact[n]
def comb(self,n,k):
if(k<0 or n<k): return 0
return self.__fact[n]*self.__invfact[k]*self.__invfact[n-k]%MOD
def perm(self,n,k):
if(k<0 or n<k): return 0
return self.__fact[n]*self.__invfact[n-k]%MOD
def resolve():
n,m,k=list(map(int,input().split()))
N=n*m
ans=0
mf=modfact(N)
for d in range(1,n):
ans+=d*(m**2)*(n-d)*mf.comb(N-2,k-2)
ans%=MOD
for d in range(1,m):
ans+=d*(n**2)*(m-d)*mf.comb(N-2,k-2)
ans%=MOD
print(ans)
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
class modfact(object):
def __init__(self, n):
fact, invfact = [1] * (n + 1), [1] * (n + 1)
for i in range(1, n + 1): fact[i] = i * fact[i - 1] % MOD
invfact[n] = pow(fact[n], MOD - 2, MOD)
for i in range(n - 1, -1, -1): invfact[i] = invfact[i + 1] * (i + 1) % MOD
self._fact, self._invfact = fact, invfact
def inv(self, n):
return self._fact[n - 1] * self._invfact[n] % MOD
def fact(self, n):
return self._fact[n]
def invfact(self, n):
return self._invfact[n]
def comb(self, n, k):
if k < 0 or n < k: return 0
return self._fact[n] * self._invfact[k] % MOD * self._invfact[n - k] % MOD
def perm(self, n, k):
if k < 0 or n < k: return 0
return self._fact[n] * self._invfact[n - k] % MOD
def resolve():
m, n, k = list(map(int, input().split()))
mf = modfact(m * n - 2)
res = 0
for s in range(1, m):
res += n * n * (m - s) * s
res %= MOD
for t in range(1, n):
res += m * m * (n - t) * t
res %= MOD
res *= mf.comb(m * n - 2, k - 2)
res %= MOD
print(res)
resolve() | p03039 |
from math import factorial
N, M, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
def Comb(N, K):
a = factorial(N) % mod
b = factorial(K) % mod
c = factorial(N-K) % mod
return (a * pow(b, mod-2, mod) * pow(c, mod-2, mod)) % mod
c = Comb(N*M-2, K-2)
ans = 0
for d in range(M):
ans += d * (M - d) * (N ** 2)
ans %= mod
for d in range(N):
ans += d * (N - d) * (M ** 2)
ans %= mod
ans *= c
ans %= mod
print(ans) | from math import factorial
N, M, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
def f(N):
a = 1
for i in range(1, N+1):
a *= i
a %= mod
return a % mod
def Comb(N, K):
a = f(N)
b = f(K)
c = f(N-K)
return (a * pow(b, mod-2, mod) * pow(c, mod-2, mod)) % mod
c = Comb(N*M-2, K-2)
ans = 0
for d in range(M):
ans += d * (M - d) * (N ** 2)
ans %= mod
for d in range(N):
ans += d * (N - d) * (M ** 2)
ans %= mod
ans *= c
ans %= mod
print(ans) | p03039 |
N,M,K=list(map(int,input().split()))
P=1000000007
import math
ans=M**2*(N-1)*N*(N+1)//6
ans+=N**2*(M-1)*M*(M+1)//6
print((ans*math.factorial(N*M-2)*pow(math.factorial(K-2),P-2,P)*pow(math.factorial(N*M-K),P-2,P)%P))
| N,M,K=list(map(int,input().split()))
P=1000000007
import math
print((M*N*(M+N)*(M*N-1)//6*math.factorial(N*M-2)*pow(math.factorial(K-2),P-2,P)*pow(math.factorial(N*M-K),P-2,P)%P))
| p03039 |
import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N,M,K=MI()
#2この組み合わせを全部足して，平均ぽく考える
def sum2(x):
return ((x*(x+1))//2)%mod
#i,jますにいるときの相手．（i,j）よりも奥にあるやつの全組み合わせの総和
def calc(i,j):
temp=0
temp=sum2(M-j-1)#該当する行
temp=(temp+((sum2(M-j-1)+sum2(j))*(N-i-1)))%mod#下の行の階差部分，左右方向にあるから
temp=(temp+sum2(N-i-1)*M)%mod
return temp
S=0
for i in range(N):
for j in range(M):
S=(S+calc(i,j))%mod
rem=(N*M)-2
def cmb(n, r, mod):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return (fact[n] * factinv[r] * factinv[n-r])%mod
fact=[1,1]
factinv=[1,1]
inv=[0,1]
for i in range(2, rem + 1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
#print(rem,K-2)
S=(S*cmb(rem,K-2,mod))%mod
print(S)
main()
| import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
"""
まず，xとyを分離する=>xだけを考えるので1行とみなす．
いっぺんにいくつも考えられないので，コマを2つだけ置いた時を考える．
2この組み合わせで距離が1=>M-1通り，2=>M-2通り,...,M-1=>1通り
(以下のように考えてΣしても良いがやや面倒
(j列目にコマを固定すると，相手との距離はj,j-1,...,1,0,1,2,...,M-j))
実際にはN列あるので，選び方がN^2
同じ行・列を選んだ場合は不可能だけど，どうせ距離も0なので関係ない
ある2つの組みに注目した時，それを何回数えるかは，外野の並べ方に依存
(N*M-2)C(K-2)通り
"""
N,M,K=MI()
def cmb(n, r, mod):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return (fact[n] * factinv[r] * factinv[n-r])%mod
fact=[1,1]
factinv=[1,1]
inv=[0,1]
for i in range(2, N*M+5+ 1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
tempj=0
for j in range(M):
tempj+=(M-j)*j
tempi=0
for i in range(N):
tempi+=(N-i)*i
ans=(tempj*N*N)%mod
ans=(ans+tempi*M*M)%mod
ans=(ans*cmb(N*M-2,K-2,mod))%mod
print(ans)
main()
| p03039 |
N,M,K = list(map(int, input().split()))
mod = 10**9+7
a = 1
b = 1
for i in range(min(K-2, N*M-K)):
a *= (N*M-2-i)
b *= i+1
comb = a//b
ans = ((N*N*(N+1)//2-N*(N+1)*(2*N+1)//6)*M**2 + (M*M*(M+1)//2-M*(M+1)*(2*M+1)//6)*N**2)%mod
ans *= comb
print((ans%mod)) | N,M,K = list(map(int, input().split()))
mod = 10**9+7
a = 1
b = 1
for i in range(min(K-2, N*M-K)):
a *= (N*M-2-i)
a %= mod
b *= i+1
b %= mod
comb = a * pow(b, mod - 2, mod) % mod
ans = (((N*N*(N+1)//2-N*(N+1)*(2*N+1)//6)*M**2 + (M*M*(M+1)//2-M*(M+1)*(2*M+1)//6)*N**2)*comb)%mod
print(ans) | p03039 |
N, M, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def comb(n, r) :
if n - r < 0 or r < 0 :
return 0
r = min(n-r, r)
a, b = 1, 1
for i in range(r) :
a *= n - i
b *= i + 1
return a // b
res = 0
for i in range(1, N + 1) :
for j in range(1, M + 1) :
if i > 1 and j > 1 :
res += 2 * (N + 1 - i) * (M + 1 - j) * (i + j - 2)
else :
res += (N + 1 - i) * (M + 1 - j) * (i + j - 2)
res *= comb(N * M - 2, K - 2)
print((res % MOD)) | N, M, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def pow(x, n) :
y = 1
while n > 0 :
if n & 1 :
y = (y * x) % MOD
x = (x * x) % MOD
n >>= 1
return y
def comb(n, r) :
if n < r or n < 0 :
return 0
factorial = [0] * (n + 1)
factorial[0] = 1
for i in range(1, n + 1) :
factorial[i] = (factorial[i-1] * i) % MOD
return (factorial[n] * pow(factorial[n-r], MOD - 2) * pow(factorial[r], MOD - 2)) % MOD
res = 0
for i in range(N) :
for j in range(M) :
if i > 0 and j > 0 :
res += 2 * (N - i) * (M - j) * (i + j)
else :
res += (N - i) * (M - j) * (i + j)
res *= comb(N * M - 2, K - 2)
print((res % MOD)) | p03039 |
n, m, k = list(map(int, input().split( )))
mod = 10**9 + 7
def chs(a,b, md):
res = 1
for i in range(a-b+1,a+1):
res *= i
res %= md
rev = 1
for i in range(1,b+1):
rev *= i
rev %= md
rev2 = pow(rev,md-2,md)
res *= rev2
res %= md
return res
ans = 0
for i in range(1,n):
ans += chs(n*m-2,k-2,mod)*i*(n-i)*m**2
ans %= mod
for i in range(1,m):
ans += chs(n*m-2,k-2,mod)*i*(m-i)*n**2
ans %=mod
print(ans)
| n, m, k = list(map(int, input().split( )))
mod = 10**9 + 7
def chs(a,b, md):
res = 1
for i in range(a-b+1,a+1):
res *= i
res %= md
rev = 1
for i in range(1,b+1):
rev *= i
rev %= md
rev2 = pow(rev,md-2,md)
res *= rev2
res %= md
return res
ans = 0
c = chs(n*m-2,k-2,mod)
for i in range(1,n):
ans += i*(n-i)*m**2
ans %= mod
for i in range(1,m):
ans +=i*(m-i)*n**2
ans %=mod
ans *= c
ans %= mod
print(ans)
| p03039 |
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
A=2*10**5
mod = 10**9+7
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, A + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
N,M,K=list(map(int,input().split()))
keisuu=cmb(N*M-2,K-2,mod)
sum_=0
for i in range(N):
a=min(abs(i),abs(N-i-1))
b=max(abs(i),abs(N-i-1))
sum_+=(M**2)*((a*(a+1)//2)+(b*(b+1)//2))
for i in range(M):
a=min(abs(i),abs(M-i-1))
b=max(abs(i),abs(M-i-1))
sum_+=(N**2)*((a*(a+1)//2)+(b*(b+1)//2))
print(((keisuu * (sum_//2))%mod)) | def power_mod(a,b,mod=10**9+7):
i,temp,box=0,b,[]
while(2**i<=b):
i+=1
for j in range(i-1,-1,-1):
box=[[j,temp//2**j]]+box
temp-=2**j*(temp//2**j)
box[0].append(a)
ans=box[0][1]*a%mod
for j in range(1,i):
box[j].append(box[j-1][2]**2%mod)
if box[j][1]==1:
ans=(ans*box[j][2])%mod
return ans
def n_func(n,mod=10**9+7):
ans=1
for i in range(1,n+1):
ans=(ans*i)%mod
return ans
def nPr(n,r,mod=10**9+7):
ans=n_func(n-r,mod)
ans=power_mod(ans,mod-2,mod)
return ans*n_func(n,mod)%mod
def nCr(n,r,mod=10**9+7):
ans=n_func(n-r,mod)*n_func(r,mod)%mod
ans=power_mod(ans,mod-2,mod)
return ans*n_func(n,mod)%mod
N,M,K=list(map(int,input().split()))
keisuu=nCr(N*M-2,K-2)
mod=10**9+7
sum_=0
for i in range(N):
a=min(abs(i),abs(N-i-1))
b=max(abs(i),abs(N-i-1))
sum_+=(M**2)*((a*(a+1)//2)+(b*(b+1)//2))
for i in range(M):
a=min(abs(i),abs(M-i-1))
b=max(abs(i),abs(M-i-1))
sum_+=(N**2)*((a*(a+1)//2)+(b*(b+1)//2))
print(((keisuu * (sum_//2))%mod)) | p03039 |
#E問題
N,M,K = list(map(int,input().split()))
mod = 1000000007
#factorial(階乗)
def factorial(n):
factorial_list=[]
for i in range(n+1):
if i == 0:
factorial_list.append(1)
elif i == 1:
factorial_list.append(1)
else:
factorial_list.append(factorial_list[-1]*i)
return factorial_list[-1]
#combination(組み合わせC)
def comb(comb1,comb2):
x=min(comb1,comb2)
y=max(comb1,comb2)
bunshi=factorial(y)
bunbo=factorial(x)*factorial(y-x)
return bunshi//bunbo
C = comb(N*M-2,K-2)
X = 0
for i in range(N-1):
d = i+1
X+=(N-d)*M*M*d
X%=mod
Y = 0
for i in range(M-1):
d = i+1
Y+=(M-d)*N*N*d
Y%=mod
print((C*(X+Y)%mod)) | #E問題
N,M,K = list(map(int,input().split()))
mod = 1000000007
zen = 1
for i in range(N*M-2):
zen*=(i+1)
kk = 1
for i in range(K-2):
kk*=(i+1)
zk = 1
for i in range(N*M-K):
zk*=(i+1)
C = zen//(kk*zk)
X = 0
for i in range(N-1):
d = i+1
X+=(N-d)*M*M*d
X%=mod
Y = 0
for i in range(M-1):
d = i+1
Y+=(M-d)*N*N*d
Y%=mod
print((C*(X+Y)%mod)) | p03039 |
mod = 1000000007
import sys
input = sys.stdin.readline
N, M, K = list(map(int, input().split()))
N2 = N**2
M2 = M**2
Xpattern = [(x * (N-x)) %mod for x in range(N)]
Ypattern = [(y * (M-y)) %mod for y in range(M)]
coef = 1
num = min(K-2, N*M-K)
for i in range(N*M-2, N*M-2-num, -1):
coef *= i
for j in range(1, num+1):
coef //= j
coef %= mod
print((((sum(Xpattern)*M2+sum(Ypattern)*N2)*coef)%mod)) | mod = 1000000007
import sys
input = sys.stdin.readline
N, M, K = list(map(int, input().split()))
def cmb(n, r):
if n<0 or r<0 or r>n:
return None
r = min(r, n-r)
if r == 0:
return 1
if r == 1:
return n
numerator = [0]*r
denominator = [0]*r
for k in range(r):
numerator[k] = n-r+k+1
denominator[k] = k+1
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
res = 1
for n in numerator:
if n > 1:
res *= n
return res
N2 = N**2
M2 = M**2
Xpattern = [(x * (N-x)) % mod for x in range(N)]
Ypattern = [(y * (M-y)) % mod for y in range(M)]
coef = cmb(N*M-2, K-2)
print((((sum(Xpattern)*M2+sum(Ypattern)*N2)*coef)%mod)) | p03039 |
"""
xi,xjのペアにおいて、このペアは何通り出てくるか
sum(全通り)sum(i)sum(j){|xi-xj|+|yi-yj|}
和なので、どんな順序でもいい
sum(i)sum(j)sum(全通り){|xi-xj|}
sum(i)sum(j)sum(全通り){|yi-yj|}
あるi,jで固定して、sum(全通り){|xi-xj|}を求めるヤツ
固定したi,jが現れる回数は、
pat = NM-2_C_K-2 こいつはどこでも一緒
pat*sum(i)sum(j){|xi-xj|}を計算する
すべてのi,j(i>j)ペアにおいて、xi,xjの和は
sum(i=1,N){i*(N-i)}
"""
from math import factorial
N,M,K = list(map(int,input().split()))
mod = 10**9+7
fa = 1
num = N*M - 2
# 固定したときの通り数
cut = min(K-2, N*M-K)
# このfor文は少ないほうが良い
for i in range(num,1,-1):
if num-i == cut:
break
fa *= i
pat = fa//factorial(cut)
# print(pat)
# xi-xj
n_x = M**2*((N-1)*N*(N+1))//6
n_y = N**2*((M-1)*M*(M+1))//6
print((pat*(n_x+n_y)%mod)) |
"""
xi,xjのペアにおいて、このペアは何通り出てくるか
sum(全通り)sum(i)sum(j){|xi-xj|+|yi-yj|}
和なので、どんな順序でもいい
sum(i)sum(j)sum(全通り){|xi-xj|}
sum(i)sum(j)sum(全通り){|yi-yj|}
あるi,jで固定して、sum(全通り){|xi-xj|}を求めるヤツ
固定したi,jが現れる回数は、
pat = NM-2_C_K-2 こいつはどこでも一緒
pat*sum(i)sum(j){|xi-xj|}を計算する
すべてのi,j(i>j)ペアにおいて、xi,xjの和は
sum(i=1,N){i*(N-i)}
"""
from math import factorial
N,M,K = list(map(int,input().split()))
mod = 10**9+7
fa = 1
num = N*M - 2
# 固定したときの通り数
# フェルマーの小定理をつかって、mod(M)でのcombinationが高速で求まる
# http://keita-matsushita.hatenablog.com/entry/2016/12/05/184011
def mod_combination(n,r,mod):
if n<0 or r<0 or n<r:
return 0
if n==0 or r == 0:
return 1
a = factorial(n) % mod
b = factorial(r) % mod
c = factorial(n-r) % mod
return (a*pow(b,mod-2,mod)*pow(c,mod-2,mod)) % mod
pat = mod_combination(N*M-2,K-2,mod)
n_x = M**2*((N-1)*N*(N+1))//6
n_y = N**2*((M-1)*M*(M+1))//6
print((pat*(n_x+n_y)%mod)) | p03039 |
"""
組み合わせ(nCr)計算
https://qiita.com/derodero24/items/91b6468e66923a87f39f#%E7%95%AA%E5%A4%96%E7%B7%A8
逆元の求め方
http://drken1215.hatenablog.com/entry/2018/06/08/210000
解法@公式放送
https://www.youtube.com/watch?v=SS6kW-d-rJ0&feature=youtu.be&t=7376
"""
def cmb(n, r):
return (fact[n] * finv_t[r] * finv_t[n - r]) % MOD
MOD = 10 ** 9 + 7
N, M, K = list(map(int, input().split()))
fact = [1, 1]
inv_t = [0, 1]
finv_t = [1, 1]
for i in range(2, N * M - 2 + 1):
fact.append((fact[-1] * i) % MOD)
inv_t.append((-inv_t[MOD % i] * (MOD // i)) % MOD)
finv_t.append((finv_t[-1] * inv_t[-1]) % MOD)
pat = cmb(N * M - 2, K - 2)
ans = 0
for i in range(M):
ans += i * (M - i) * N ** 2
for i in range(N):
ans += i * (N - i) * M ** 2
ans = (ans * pat) % MOD
print(ans)
| """
https://atcoder.jp/contests/abc127/submissions/5606400
"""
def inv(x):
return pow(x, MOD - 2, MOD)
def cmb(n, r):
r = min(r, n - r)
if r == 0:
return 1
if r == 1:
return n
f = 1
for k in range(n, n - r, -1):
f = (f * k) % MOD
# n!/(n-r)!
d = 1
for k in range(2, r + 1):
d = (d * k) % MOD
# r!
return (f * inv(d)) % MOD
MOD = 10 ** 9 + 7
N, M, K = list(map(int, input().split()))
ans = 0
for i in range(M):
ans += i * (M - i) * N ** 2
for i in range(N):
ans += i * (N - i) * M ** 2
pat = cmb(N * M - 2, K - 2)
ans = (ans * pat) % MOD
print(ans)
| p03039 |
# https://atcoder.jp/contests/abc127/submissions/5606400
from functools import reduce
def mod_mul(a, b):
return (a * b) % MOD
def mod_add(a, b):
return (a + b) % MOD
def cmb(n, r):
r = min(r, n - r)
if r == 0:
return 1
if r == 1:
return n
f = reduce(mod_mul, list(range(n - r + 1, n + 1))) # n!/(n-r)!
d = reduce(mod_mul, list(range(2, r + 1))) # r!
return (f * pow(d, MOD - 2, MOD)) % MOD
MOD = 10 ** 9 + 7
N, M, K = list(map(int, input().split()))
ans_x = reduce(mod_add, (i * (M - i) for i in range(M))) * N ** 2
ans_y = reduce(mod_add, (i * (N - i) for i in range(N))) * M ** 2
ans = ans_x + ans_y
pat = cmb(N * M - 2, K - 2)
ans = (ans * pat) % MOD
print(ans)
| # https://atcoder.jp/contests/abc127/submissions/5606400
from functools import reduce
from operator import add
def mod_mul(a, b):
return (a * b) % MOD
def cmb(n, r):
r = min(r, n - r)
if r == 0:
return 1
if r == 1:
return n
f = reduce(mod_mul, list(range(n - r + 1, n + 1))) # n!/(n-r)!
d = reduce(mod_mul, list(range(2, r + 1))) # r!
return (f * pow(d, MOD - 2, MOD)) % MOD
MOD = 10 ** 9 + 7
N, M, K = list(map(int, input().split()))
ans_x = reduce(add, (i * (M - i) for i in range(M))) * N ** 2
ans_y = reduce(add, (i * (N - i) for i in range(N))) * M ** 2
ans = (ans_x + ans_y) % MOD
pat = cmb(N * M - 2, K - 2)
ans = (ans * pat) % MOD
print(ans)
| p03039 |
from collections import defaultdict
mod = 10 ** 9 + 7
memo = defaultdict(int)
def cmb(n, r):
if (n, r) in memo:
return memo[(n, r)]
if n < r or r < 0:
return 0
if r > n - r:
return cmb(n, n - r)
res = f[n] * pow(f[n - r], mod - 2, mod) * pow(f[r], mod - 2, mod) % mod
memo[(n, r)] = res
return res
n, m, k = list(map(int, input().split()))
f = [1]
for i in range(1, 2 * 10 ** 5 + 1):
f.append(f[-1] * i % mod)
ans = 0
for d in range(1, m):
ans += d * (m - d) * n ** 2
ans %= mod
for d in range(1, n):
ans += d * (n - d) * m ** 2
ans %= mod
ans *= cmb(n * m - 2, k - 2)
ans %= mod
print(ans)
| def solve():
mod = 10 ** 9 + 7
def cmb(n, r):
def build():
fs = [1]
t = 1
for x in range(1, h * w):
t = (t * x) % mod
fs.append(t)
invs = [1] * (h * w)
t = pow(t, mod - 2, mod)
invs[-1] = t
for x in range(h * w - 2, 0, -1):
t = (t * (x + 1)) % mod
invs[x] = t
return fs, invs
if r < 0 or r > n:
return 0
if r > (n - r):
return cmb(n, n - r)
if r == 0:
return 1
if r == 1:
return n
fs, invs = build()
return fs[n] * invs[n - r] * invs[r] % mod
h, w, k = list(map(int, input().split()))
c = cmb(h * w - 2, k - 2)
ret = (pow(w, 2) * sum((h - d) * d for d in range(h))
+ pow(h, 2) * sum((w - d) * d for d in range(w))) * c % mod
return ret
print((solve())) | p03039 |
def solve():
mod = 10 ** 9 + 7
def cmb(n, r):
def build():
fs = [1]
t = 1
for x in range(1, h * w):
t = (t * x) % mod
fs.append(t)
invs = [1] * (h * w)
t = pow(t, mod - 2, mod)
invs[-1] = t
for x in range(h * w - 2, 0, -1):
t = (t * (x + 1)) % mod
invs[x] = t
return fs, invs
if r < 0 or r > n:
return 0
if r > (n - r):
return cmb(n, n - r)
if r == 0:
return 1
if r == 1:
return n
fs, invs = build()
return fs[n] * invs[n - r] * invs[r] % mod
h, w, k = list(map(int, input().split()))
c = cmb(h * w - 2, k - 2)
ret = (pow(w, 2) * sum((h - d) * d for d in range(h))
+ pow(h, 2) * sum((w - d) * d for d in range(w))) * c % mod
return ret
print((solve())) | class Calc:
def __init__(self, max_value, mod):
"""combination(max_value, all)"""
fact = [-1] * (max_value + 1)
fact[0] = 1
fact[1] = 1
for x in range(2, max_value + 1):
fact[x] = x * fact[x - 1] % mod
invs = [1] * (max_value + 1)
invs[max_value] = pow(fact[max_value], mod - 2, mod)
for x in range(max_value - 1, 0, -1):
invs[x] = invs[x + 1] * (x + 1) % mod
self.fact = fact
self.invs = invs
self.mod = mod
def combination(self, n, r):
if n - r < r:
return self.combination(n, n - r)
if r < 0:
return 0
if r == 0:
return 1
if r == 1:
return n
return self.fact[n] * self.invs[r] * self.invs[n - r] % self.mod
def main():
MOD = 10 ** 9 + 7
N, M, K = list(map(int, input().split()))
calc = Calc(max_value=N * M - 2, mod=MOD)
xsum = 0
for d in range(1, N):
xsum = (xsum + d * (N - d)) % MOD
xsum = (xsum * M * M) % MOD
ysum = 0
for d in range(1, M):
ysum = (ysum + d * (M - d)) % MOD
ysum = (ysum * N * N) % MOD
ans = (xsum + ysum) * calc.combination(N * M - 2, K - 2) % MOD
print(ans)
if __name__ == '__main__':
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
| p03039 |
import math
mod = 10**9+7
N,M,K = list(map(int, input().split()))
MAX = min(N*M,mod)
facts = [1 for i in range(MAX)]
invs = [1 for i in range(MAX)]
def inv(x):
return pow(x,mod-2,mod)
for i in range(1,MAX):
facts[i] = (facts[i-1] * i)% mod
invs[i] = inv(facts[i])
def nCr(n,r):
return facts[n] * invs[r] * invs[n-r] % mod
def main():
ans = 0
complement = nCr((N*M-2)%mod,(K-2)%mod)
for i in range(N-1):
for j in range(i+1,N):
d = abs(i - j)
ans += d * M**2
for i in range(M-1):
for j in range(i+1,M):
d = abs(i - j)
ans += d * N**2
print(((ans*complement) % mod))
main()
| import math
mod = 10**9+7
N,M,K = list(map(int, input().split()))
MAX = min(N*M,mod)
facts = [1 for i in range(MAX)]
invs = [1 for i in range(MAX)]
def inv(x):
return pow(x,mod-2,mod)
for i in range(1,MAX):
facts[i] = (facts[i-1] * i)% mod
invs[i] = inv(facts[i])
def nCr(n,r):
return facts[n] * invs[r] * invs[n-r] % mod
def main():
ans = 0
complement = nCr((N*M-2)%mod,(K-2)%mod)
for i in range(1,N):
ans += i * (N-i) * M**2
for i in range(1,M):
ans += i * (M-i) * N**2
print(((ans*complement) % mod))
main()
| p03039 |
N, M, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
NM = N * M
fact = [1 for _ in range(NM+1)]
for i in range(1, NM+1):
fact[i] = fact[i-1] * i
def combination(n, m):
return fact[n] // fact[n-m] //fact[m]
pattern = combination(NM-2, K-2) % MOD
def diff_x_pattern(val):
# for d in range(1, val):
# ret += (val - d) * d
return val * (val - 1) * val // 2 - (val - 1) * (2 * val - 1) * val // 6
ans = M * M * diff_x_pattern(N)
ans += N * N * diff_x_pattern(M)
print(((ans*pattern)%MOD))
| N, M, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def combination(n, m):
m = min(m, n-m)
c = 1
for i in range(m):
c *= n - i
for i in range(2, m+1):
c //= i
return c % MOD
pattern = combination(N*M-2, K-2) % MOD
def diff_x_pattern(val):
# for d in range(1, val):
# ret += (val - d) * d
return (val * (val - 1) * val // 2 - (val - 1) * (2 * val - 1) * val // 6) % MOD
ans = (M * M * diff_x_pattern(N)) % MOD
ans += (N * N * diff_x_pattern(M)) % MOD
print(((ans*pattern)%MOD))
| p03039 |
N, M, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
fact = [1 for _ in range(N*M+1)]
for i in range(1, N*M+1):
fact[i] = fact[i-1] * i
def inv(val):
return pow(val, MOD-2, MOD)
def combination(n, m):
return fact[n] * inv(fact[n-m]*fact[m]) % MOD
pattern = combination(N*M-2, K-2)
def diff_x_pattern(val):
ret = 0
for d in range(1, val):
ret += ((val - d) * d) % MOD
return ret
ans = (M * M * diff_x_pattern(N)) % MOD
ans += (N * N * diff_x_pattern(M)) % MOD
print(((ans*pattern)%MOD))
| N, M, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def combination(n, m):
c = 1
m = min(n-m, m)
for i in range(m):
c *= (n-i) * pow(m-i, MOD-2, MOD) % MOD
return c
pattern = combination(N*M-2, K-2)
def diff_x_pattern(val):
ret = 0
for d in range(1, val):
ret += ((val - d) * d) % MOD
return ret
ans = (M * M * diff_x_pattern(N)) % MOD
ans += (N * N * diff_x_pattern(M)) % MOD
print(((ans*pattern)%MOD))
| p03039 |
N, M, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def combination(n, m):
c = 1
m = min(n-m, m)
for i in range(m):
c *= (n-i) * pow(m-i, MOD-2, MOD) % MOD
return c
pattern = combination(N*M-2, K-2)
def diff_x_pattern(val):
ret = 0
for d in range(1, val):
ret += ((val - d) * d) % MOD
return ret
ans = (M * M * diff_x_pattern(N)) % MOD
ans += (N * N * diff_x_pattern(M)) % MOD
print(((ans*pattern)%MOD))
| N, M, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def combination(n, m):
c = 1
m = min(n-m, m)
for i in range(m):
c = c * (n-i) * pow(m-i, MOD-2, MOD) % MOD
return c
pattern = combination(N*M-2, K-2)
def diff_x_pattern(val):
ret = 0
for d in range(1, val):
ret += ((val - d) * d) % MOD
return ret
ans = (M * M * diff_x_pattern(N)) % MOD
ans += (N * N * diff_x_pattern(M)) % MOD
print(((ans*pattern)%MOD))
| p03039 |
import sys
from itertools import combinations
def comb_mod(n, r, MOD=10**9+7):
if n < 0 or r < 0 or n < r:
return 0
factrial = [1] * (n+1)
for k in range(1, n+1):
factrial[k] = (factrial[k-1] * k) % MOD
fact_inv = [1] * (n+1)
fact_inv[n] = pow(factrial[n], MOD - 2, MOD)
for k in range(n-1, -1, -1):
fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD
return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD
def main():
input = sys.stdin.readline
MOD = 10**9 + 7
N, M, K = list(map(int, input().split()))
# The number of times that pieces are located on certain two tiles.
num = comb_mod(N*M-2, K-2)
ans = 0
# Column-wise distance
for a, b in combinations(list(range(M)), 2):
ans += abs(a - b) * N**2 * num
ans %= MOD
# Row-wise distance
for a, b in combinations(list(range(N)), 2):
ans += abs(a - b) * M**2 * num
ans %= MOD
return ans
if __name__ == '__main__':
print((main()))
| import sys
from itertools import combinations
def comb_mod(n, r, MOD=10**9+7):
if n < 0 or r < 0 or n < r:
return 0
factrial = [1] * (n+1)
for k in range(1, n+1):
factrial[k] = (factrial[k-1] * k) % MOD
fact_inv = [1] * (n+1)
fact_inv[n] = pow(factrial[n], MOD - 2, MOD)
for k in range(n-1, -1, -1):
fact_inv[k] = (fact_inv[k+1] * (k+1)) % MOD
return (factrial[n] * fact_inv[r] * fact_inv[n-r]) % MOD
def main():
input = sys.stdin.readline
MOD = 10**9 + 7
N, M, K = list(map(int, input().split()))
# The number of times that pieces are located on certain two tiles.
num = comb_mod(N*M-2, K-2)
ans = 0
# Column-wise distance
for i in range(M):
ans += i * (M - i) * N**2 * num
ans %= MOD
# Row-wise distance
for i in range(N):
ans += i * (N - i) * M**2 * num
ans %= MOD
return ans
if __name__ == '__main__':
print((main()))
| p03039 |
p,q,r=list(map(int,input().split()))
def comb_mod(N,K,modp):
K_fact=1
NK_fact=1
N_fact=1
for i in range(1,K+1):
K_fact*=i
for i in range(1,N-K+1):
NK_fact*=i
for i in range(1,N+1):
N_fact*=i
K_inv=pow(K_fact, -1, modp)
NK_inv=pow(NK_fact, -1, modp)
pat=(N_fact*K_inv)%modp*NK_inv%modp
return pat
pat=comb_mod(p*q-2,r-2,10**9+7)
ans=0
for i in range(0,q+1):
ans+=i*(q-i)*p*p
for k in range(0,p+1):
ans+=k*(p-k)*q*q
print((ans*pat%(10**9+7))) | p,q,r=list(map(int,input().split()))
def comb_mod(N,K,modp):
K_fact=1
NK_fact=1
N_fact=1
for i in range(1,K+1):
K_fact*=i
K_fact=K_fact%modp
for i in range(1,N-K+1):
NK_fact*=i
NK_fact=NK_fact%modp
for i in range(1,N+1):
N_fact*=i
N_fact=N_fact%modp
K_inv=pow(K_fact, -1, modp)
NK_inv=pow(NK_fact, -1, modp)
pat=(N_fact*K_inv)%modp*NK_inv%modp
return pat
pat=comb_mod(p*q-2,r-2,10**9+7)
ans=0
for i in range(0,q+1):
ans+=i*(q-i)*p*p
ans=ans%(10**9+7)
for k in range(0,p+1):
ans+=k*(p-k)*q*q%(10**9+7)
ans=ans%(10**9+7)
print((ans*pat%(10**9+7))) | p03039 |
from operator import mul
from functools import reduce
def cmb(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1,r + 1)))
return over // under
N, M, K = list(map(int, input().split()))
c = cmb(N*M-2,K-2)
ans = c * (M**2 * (N**2 * (N+1)//2 - N*(N+1)*(2*N+1)//6) + N**2 * (M**2 * (M+1)//2 - M*(M+1)*(2*M+1)//6)) % 1000000007
print(ans) | mod = 10**9 + 7
def comb(n, k):
x, y = 1, 1
k = min(k, n - k)
for i in range(k):
x *= n - i
x %= mod
y *= i + 1
y %= mod
return x * pow(y, mod - 2, mod) % mod
N, M, K = list(map(int, input().split()))
c = comb(N*M-2,K-2)
ans = c * (M**2 * (N**2 * (N+1)//2 - N*(N+1)*(2*N+1)//6) + N**2 * (M**2 * (M+1)//2 - M*(M+1)*(2*M+1)//6)) % mod
print(ans) | p03039 |
N, M, K = list(map(int, input().split()))
ppp = 10**9 + 7
def expo_div_p(a: int,n: int,p: int):
if n == 1:
d = a
elif n % 2 == 0:
d = expo_div_p(a, n//2, p)**2 % p
else:
d = a * expo_div_p(a, n//2, p)**2 % p
return d
def combi(x, y, p):
c = 1
for i in range(1,y+1):
c *= (x-i+1) * expo_div_p(i, p-2, p)
c %= p
return c
ans = 0
C = 0
C += combi(N*M-2, K-2, ppp)
for i in range(1,N):
ans += C * i * (N-i) * M**2
for j in range(1,M):
ans += C * j * (M-j) * N**2
#print(C)
print((ans % ppp))
| N, M, K = list(map(int, input().split()))
ppp = 10**9 + 7
#def expo_div_p(a: int,n: int,p: int):
# if n == 1:
# d = a
# elif n % 2 == 0:
# d = expo_div_p(a, n//2, p)**2 % p
# else:
# d = a * expo_div_p(a, n//2, p)**2 % p
# return d
#
def combi(x, y, p):
c = 1
for i in range(1,y+1):
c *= (x-i+1) * pow(i, p-2, p)
c %= p
return c
ans = 0
C = combi(N*M-2, K-2, ppp)
for i in range(1,N):
ans += C * i * (N-i) * M**2
for j in range(1,M):
ans += C * j * (M-j) * N**2
#print(C)
print((ans % ppp))
| p03039 |
from operator import mul
from functools import reduce
def comb(n,r):
r = min(n - r, r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1, r + 1)))
return over // under
N,M,K = list(map(int,input().split()))
C = comb(N*M-2, K-2)
#print(int(C))
A = int(0)
for d in range(N):
a = (N-d)*(M**2)
A += int(d*a)
B = int(0)
for d in range(M):
b = (M-d)*(N**2)
B += int(d*b)
ans = int((A+B)*C)
ans = ans%(1000000007)
print(ans)
| def comb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
N,M,K = list(map(int,input().split()))
C = comb(N*M-2, K-2)
#print(int(C))
A = int(0)
for d in range(N):
a = (N-d)*(M**2)
A += int(d*a)
B = int(0)
for d in range(M):
b = (M-d)*(N**2)
B += int(d*b)
ans = int((A+B)*C)
ans = ans%(1000000007)
print(ans)
| p03039 |
from operator import mul
from functools import reduce
def comb2(n,r):
r = min(n - r, r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1, r + 1)))
return over // under
import sys
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
mod = 10**9 + 7
inf = float('inf')
ans = int(0)
N, M, K = LI()
cou = int(0)
#maxL = N + M -2
L = int(0)
#距離i+1の組み合わせ
#for i in range(maxL):
for j in range(N):
L += (N - j - 1) * (M ** 2) * (j + 1)
for j in range(M):
L += (M - j - 1) * (N ** 2) * (j + 1)
# for j in range(i+2):
# if i>1 and i+1>j>0:
# L[i] += max((N-j)*(M-(1+i)+j),0)*(i+1)*2
# else:
# L[i] += max(((N - j) * (M - (1 + i) + j)), 0) * (i + 1)
cou = comb2(N*M-2,K-2)%mod
ans = cou *L%mod
print(ans) | from operator import mul
from functools import reduce
def comb2(n,r):
r = min(n - r, r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1, r + 1)))
return over // under
def comb3(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
import sys
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
mod = 10**9 + 7
inf = float('inf')
ans = int(0)
N, M, K = LI()
cou = int(0)
#maxL = N + M -2
L = int(0)
#距離i+1の組み合わせ
#for i in range(maxL):
for j in range(N):
L += (N - j - 1) * (M ** 2) * (j + 1)
for j in range(M):
L += (M - j - 1) * (N ** 2) * (j + 1)
# for j in range(i+2):
# if i>1 and i+1>j>0:
# L[i] += max((N-j)*(M-(1+i)+j),0)*(i+1)*2
# else:
# L[i] += max(((N - j) * (M - (1 + i) + j)), 0) * (i + 1)
cou = comb3(N*M-2,K-2)%mod
ans = cou *L%mod
print(ans) | p03039 |
from operator import mul
from functools import reduce
def comb2(n,r):
r = min(n - r, r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1, r + 1)))
return over // under
def comb3(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
import sys
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
mod = 10**9 + 7
inf = float('inf')
ans = int(0)
N, M, K = LI()
cou = int(0)
#maxL = N + M -2
L = int(0)
#距離i+1の組み合わせ
#for i in range(maxL):
for j in range(N):
L += (N - j - 1) * (M ** 2) * (j + 1)
for j in range(M):
L += (M - j - 1) * (N ** 2) * (j + 1)
# for j in range(i+2):
# if i>1 and i+1>j>0:
# L[i] += max((N-j)*(M-(1+i)+j),0)*(i+1)*2
# else:
# L[i] += max(((N - j) * (M - (1 + i) + j)), 0) * (i + 1)
cou = comb3(N*M-2,K-2)%mod
ans = cou *L%mod
print(ans) | class combination():
#素数のmod取るときのみ 速い
def __init__(self, n, mod):
self.n = n
self.fac = [1] * (n + 1)
self.inv = [1] * (n + 1)
for j in range(1, n + 1):
self.fac[j] = self.fac[j - 1] * j % mod
self.inv[n] = pow(self.fac[n], mod - 2, mod)
for j in range(n - 1, -1, -1):
self.inv[j] = self.inv[j + 1] * (j + 1) % mod
def comb(self, n, r, mod):
if r > n or n < 0 or r < 0:
return 0
return self.fac[n] * self.inv[n - r] * self.inv[r] % mod
import sys
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
mod = 10**9 + 7
inf = float('inf')
ans = int(0)
N, M, K = LI()
cou = int(0)
#maxL = N + M -2
L = int(0)
#距離i+1の組み合わせ
#for i in range(maxL):
for j in range(N):
L += (N - j - 1) * (M ** 2) * (j + 1)
L %= mod
for j in range(M):
L += (M - j - 1) * (N ** 2) * (j + 1)
L %= mod
# for j in range(i+2):
# if i>1 and i+1>j>0:
# L[i] += max((N-j)*(M-(1+i)+j),0)*(i+1)*2
# else:
# L[i] += max(((N - j) * (M - (1 + i) + j)), 0) * (i + 1)
C = combination(N*M-2,mod)
cou = C.comb(N*M-2,K-2,mod)*L%mod
print(cou) | p03039 |
N,M,K=list(map(int,input().split()))
O,S,T=10**9+7,N+M,6
for i in range(K):S=S*(N*M-i)%O;T*=i+1
print((S*K*~-K*pow(T,O-2,O)%O)) | N,M,K=list(map(int,input().split()))
O,S,T=10**9+7,N+M,6
for i in range(K):S=S*(N*M-i)%O;T=T*-~i%O
print((S*K*~-K*pow(T,O-2,O)%O)) | p03039 |
import math
n,m,k = list(map(int,input().split()))
ss = (math.factorial(m*n)//math.factorial(k))//math.factorial(m*n-k)
s = (ss*k*(k-1))//2
r = 10**9 +7
xav = ((m**3-m) *n**2)//6
yav = ((n**3-n)*m**2)//6
av = xav + yav
d = (m*n*(m*n-1))//2
print((int(((av*s)//d)%r)))
| n,m,k = list(map(int,input().split()))
x = m*n
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
ss = cmb(x,k)
s = (ss*k*(k-1))//2
r = 10**9 +7
av = (((m**3-m) *n**2)//6 + ((n**3-n)*m**2)//6)%r
d = (x*(x-1))//2
print((int(((av*s)//d)%r))) | p03039 |
# -*- coding: utf-8 -*-
mod = 10 ** 9 + 7
n, m, k = list(map(int, input().split()))
nm = n * m
fact = [1] * (nm + 1)
for i in range(1, nm + 1):
fact[i] = fact[i - 1] * i
def C(n, k):
x = fact[n]
x *= pow(fact[n-k], mod - 2, mod)
x %= mod
x *= pow(fact[k], mod - 2, mod)
x %= mod
return x
def F(x):
s1 = x * x * (x + 1) // 2
s2 = x * (x + 1) * (2 * x + 1) // 6
return (s1 - s2) % mod
res = (m ** 2 % mod * F(n) % mod + n ** 2 * F(m) % mod) % mod
res *= C(n * m - 2, k - 2)
res %= mod
print(res)
| # -*- coding: utf-8 -*-
mod = 10 ** 9 + 7
n, m, k = list(map(int, input().split()))
nm = n * m
fact = [1] * (nm + 1)
for i in range(1, nm + 1):
fact[i] = fact[i - 1] * i % mod
def C(n, k):
x = fact[n]
x *= pow(fact[n-k], mod - 2, mod)
x %= mod
x *= pow(fact[k], mod - 2, mod)
x %= mod
return x
def F(x):
s1 = x * x * (x + 1) // 2
s2 = x * (x + 1) * (2 * x + 1) // 6
return (s1 - s2) % mod
res = (m ** 2 % mod * F(n) % mod + n ** 2 * F(m) % mod) % mod
res *= C(n * m - 2, k - 2)
res %= mod
print(res)
| p03039 |
mod = 10**9 + 7
n, m, k = list(map(int, input().split()))
nm = n * m
fact = [1] * (nm-1)
inv = [1] * (nm-1)
inv_fact = [1] * (nm-1)
for i in range(2, nm-1):
fact[i] = fact[i-1] * i % mod
inv[i] = -(mod // i) * inv[mod % i] % mod
inv_fact[i] = inv_fact[i-1] * inv[i]
comb = fact[nm-2] * inv_fact[k-2] * inv_fact[nm-k] % mod
cost_x = (n-1) * n * (n+1) // 6 * m * m % mod
cost_y = (m-1) * m * (m+1) // 6 * n * n % mod
print((comb * (cost_x + cost_y) % mod)) | mod = 10**9 + 7
n, m, k = list(map(int, input().split()))
nm = n * m
fact = [1] * (nm-1)
inv = [1] * (nm-1)
inv_fact = [1] * (nm-1)
for i in range(2, nm-1):
fact[i] = fact[i-1] * i % mod
inv[i] = -(mod // i) * inv[mod % i] % mod
inv_fact[i] = inv_fact[i-1] * inv[i] % mod
comb = fact[nm-2] * inv_fact[k-2] * inv_fact[nm-k] % mod
cost_x = (n-1) * nm * (n+1) // 6 * m % mod
cost_y = (m-1) * nm * (m+1) // 6 * n % mod
print((comb * (cost_x + cost_y) % mod)) | p03039 |
import sys
input = sys.stdin.readline
N,M,K=list(map(int,input().split()))
mod=10**9+7
def Combi2(a,b):#aは大きいが、bは小さいとき
if b>a:
return 0
ANS=1
for i in range(min(b,a-b)):
ANS=ANS*(a-i)*pow(min(b,a-b)-i,mod-2,mod)
return ANS%mod
SUM_N=SUM_M=0
for i in range(N):
SUM_N+=i*(N-i)
for i in range(M):
SUM_M+=i*(M-i)
#print((SUM_N*(M**2)+SUM_M*(N**2))/Combi2(N*M,2)*Combi2(N*M,K)*K*(K-1)//2%mod)
print(((SUM_N*(M**2)+SUM_M*(N**2))*pow(Combi2(N*M,2),mod-2,mod)*Combi2(N*M,K)*K*(K-1)*pow(2,mod-2,mod)%mod))
| import sys
input = sys.stdin.readline
N,M,K=list(map(int,input().split()))
mod=10**9+7
def Combi2(a,b):#aは大きいが、bは小さいとき
if b>a:
return 0
ANS=1
for i in range(min(b,a-b)):
ANS=ANS*(a-i)*pow(min(b,a-b)-i,mod-2,mod)%mod
return ANS%mod
SUM_N=SUM_M=0
for i in range(N):
SUM_N+=i*(N-i)
for i in range(M):
SUM_M+=i*(M-i)
#print((SUM_N*(M**2)+SUM_M*(N**2))/Combi2(N*M,2)*Combi2(N*M,K)*K*(K-1)//2%mod)
print(((SUM_N*(M**2)+SUM_M*(N**2))*pow(Combi2(N*M,2),mod-2,mod)*Combi2(N*M,K)*K*(K-1)*pow(2,mod-2,mod)%mod))
| p03039 |
N,M,K = list(map(int,input().split()))
mod = 10 ** 9 + 7
MAX = N*M
fac = [0] * MAX
finv = [0] * MAX
inv = [0] * MAX
def cominit():
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 cmb(n,r):
if n < 0 or r < 0 or r > n:return 0
if r > n/2: r = n-r
return fac[n] * (finv[r] * finv[n-r] % mod) % mod
cominit()
ans= 0
NCK = cmb(N*M-2,K-2)
M2 = M**2 * NCK
N2 = N**2 * NCK
for i in range(N-1):
for j in range(i,N):
ans += M2 * (j-i)
ans %= mod
for i in range(M-1):
for j in range(i,M):
ans += N2 * (j-i)
ans %= mod
print(ans) |
N,M,K = list(map(int,input().split()))
mod = 10 ** 9 + 7
MAX = N*M
fac = [0] * MAX
finv = [0] * MAX
inv = [0] * MAX
def cominit():
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 cmb(n,r):
if n < 0 or r < 0 or r > n:return 0
if r > n/2: r = n-r
return fac[n] * (finv[r] * finv[n-r] % mod) % mod
cominit()
ans= 0
NCK = cmb(N*M-2,K-2)
M2 = M**2 * NCK
N2 = N**2 * NCK
for i in range(1,N):
ans += M2 * i * (N-i)
ans %= mod
for i in range(1,M):
ans += N2 * i * (M-i)
ans %= mod
print(ans) | p03039 |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
MOD = 10**9+7
Facts = [1]*(2*10**5+1)
for i in range(2,2*10**5+1):
Facts[i] = (Facts[i-1]*i) % MOD
def mul(a,b):
return (a*b) % MOD
def power(a,b):
if b==0 : return 1
elif b==1 : return a % MOD
elif b%2==0 : return power(a,b//2)**2 % MOD
else : return power(a,b//2)**2 * a % MOD
def div(a,b):
return mul(a,power(b,MOD-2))
def combi(n,m,k):
if k <= 2 or k >= n*m:
return 1
else:
return div(Facts[n*m-2],(Facts[k-2]*Facts[n*m-k]))
def main():
N,M,K = list(map(int, input().split()))
ans = 0
for d in range(1,N):
ans = (ans + d * (N-d)*M**2 * combi(N,M,K)) % MOD
for d in range(1,M):
ans = (ans + d * (M-d)*N**2 * combi(N,M,K)) % MOD
return ans
if __name__ == "__main__":
print((main())) | #!/usr/bin/python3
# -*- coding: utf-8 -*-
MOD = 10**9+7
Facts = [1]*(2*10**5+1)
for i in range(2,2*10**5+1):
Facts[i] = (Facts[i-1]*i) % MOD
def mul(a,b):
return (a*b) % MOD
def power(a,b):
if b==0 : return 1
elif b==1 : return a % MOD
elif b%2==0 : return power(a,b//2)**2 % MOD
else : return power(a,b//2)**2 * a % MOD
def div(a,b):
return mul(a,power(b,MOD-2))
def combi(n,m,k):
if k <= 2 or k >= n*m:
return 1
else:
return div(Facts[n*m-2],(Facts[k-2]*Facts[n*m-k]))
def main():
N,M,K = list(map(int, input().split()))
com = combi(N,M,K)
ans = 0
for d in range(1,N):
ans = (ans + d * (N-d)*M**2 * com) % MOD
for d in range(1,M):
ans = (ans + d * (M-d)*N**2 * com) % MOD
return ans
if __name__ == "__main__":
print((main())) | p03039 |
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
m,n,k = list(map(int,readline().split()))
def comb(n, r, mod):
r = min(r, n-r)
mol = 1
deno = 1
for i in range(1, r+1):
mol = mol * (n-r+i) % mod
deno = deno * i % mod
ret = mol * pow(deno, mod-2, mod) % mod
return ret
def f1(x,y,a,b):
return (a+b-x-y)*(a-x+1)*(b-y+1)//2
def f2(x,a):
return (a-x)*(a-x+1)//2
ans = 0
for x in range(1,n+1):
for y in range(1,m+1):
ans += f1(x,y,n,m)+f1(1,1,x,y)+f1(1,y,x,m)+f1(x,1,n,y)
ans -= f2(x,n) + f2(1,x) + f2(1,y) + f2(y,m)
ans %= mod
ans = (ans * comb(m*n-2,k-2,mod))%mod
ans = ans*pow(2,mod-2,mod)%mod
print(ans)
| import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
m,n,k = list(map(int,readline().split()))
def comb(n, r, mod):
r = min(r, n-r)
mol = 1
deno = 1
for i in range(1, r+1):
mol = mol * (n-r+i) % mod
deno = deno * i % mod
ret = mol * pow(deno, mod-2, mod) % mod
return ret
def f1(x,y,a,b):
return (a+b-x-y)*(a-x+1)*(b-y+1)//2
def f2(x,a):
return (a-x)*(a-x+1)//2
ans = 0
for x in range(1,n+1):
for y in range(1,m+1):
a = n-x+1
b = m-y+1
c = m*(a*(a-1)+x*(x-1))
d = n*(b*(b-1)+y*(y-1))
ans += (c+d)//2
ans %= mod
ans = (ans * comb(m*n-2,k-2,mod))%mod
ans = ans*pow(2,mod-2,mod)%mod
print(ans)
| p03039 |
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
m,n,k = list(map(int,readline().split()))
def comb(n, r, mod):
r = min(r, n-r)
mol = 1
deno = 1
for i in range(1, r+1):
mol = mol * (n-r+i) % mod
deno = deno * i % mod
ret = mol * pow(deno, mod-2, mod) % mod
return ret
def f1(x,y,a,b):
return (a+b-x-y)*(a-x+1)*(b-y+1)//2
def f2(x,a):
return (a-x)*(a-x+1)//2
ans = 0
for x in range(1,n+1):
for y in range(1,m+1):
a = n-x+1
b = m-y+1
c = m*(a*(a-1)+x*(x-1))
d = n*(b*(b-1)+y*(y-1))
ans += (c+d)//2
ans %= mod
ans = (ans * comb(m*n-2,k-2,mod))%mod
ans = ans*pow(2,mod-2,mod)%mod
print(ans)
| import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7
m,n,k = list(map(int,readline().split()))
def comb(n, r, mod):
r = min(r, n-r)
mol = 1
deno = 1
for i in range(1, r+1):
mol = mol * (n-r+i) % mod
deno = deno * i % mod
ret = mol * pow(deno, mod-2, mod) % mod
return ret
ans = m*n*(m+n)*(m*n-1)//3
ans = (ans * comb(m*n-2,k-2,mod))%mod
ans = ans*pow(2,mod-2,mod)%mod
print(ans)
| p03039 |
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 )
def main():
N, M, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
ans = 0
for i in range(1,N):
ans += i * (N - i) * M * M
ans %= mod
for j in range(1,M):
ans += j * (M - j) * N * N
ans %= mod
ans *= cmb(N*M-2,K-2,mod)
print((ans%mod))
if __name__ == "__main__":
main() | 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):
if n < r:
return 0
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
def main():
N, M, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
comb = Combination(N*M)
ans = 0
for i in range(M):
ans += i * (M - i) * N * N
ans %= MOD
for i in range(N):
ans += i * (N - i) * M * M
ans %= MOD
ans *= comb(N*M-2,K-2)
ans %= MOD
print(ans)
if __name__ == "__main__":
main() | p03039 |
class Combination:
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!を求める'''
return self.fact[k]
def inverse_factorial(self, k):
'''k!の逆元を求める'''
return self.inv_fact[k]
def combination(self, k, r):
'''kCrを求める'''
return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD
h, w, k = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(h*w, MOD)
kumi = comb.combination(h*w - 2, k - 2)
ans = 0
for i in range(h):
for j in range(i, h):
diff_h = abs(i - j)
ans += diff_h * kumi * w * w
ans %= MOD
for i in range(w):
for j in range(i, w):
diff_w = abs(i - j)
ans += diff_w * kumi * h * h
ans %= MOD
print(ans) | class Combination:
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!を求める'''
return self.fact[k]
def inverse_factorial(self, k):
'''k!の逆元を求める'''
return self.inv_fact[k]
def combination(self, k, r):
'''kCrを求める'''
return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD
h, w, k = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(h*w, MOD)
kumi = comb.combination(h*w - 2, k - 2)
ans = 0
for d in range(0, h):
ans += d * (h - d) * kumi * w * w
ans %= MOD
for d in range(0, w):
ans += d * (w - d) * kumi * h * h
ans %= MOD
print(ans) | p03039 |
n, m, k = list(map(int, input().split()))
mod = 1000000007
def pow(x, n):
ret = 1
while n > 0:
if (n & 1) == 1:
ret = (ret * x) % mod
x = (x * x) % mod
n >>= 1
return ret
fac = [1]
inv = [1]
for i in range(1, n * m + 1):
fac.append((fac[-1] * i) % mod)
inv.append(pow(fac[i], mod - 2))
def cmb(n, k):
return (fac[n] * inv[k] * inv[n - k]) % mod
def doit(n, m, k):
ret = 0
for d in range(m):
ret = (ret + d * (m - d)) % mod
return (ret * n * n * cmb(n * m - 2, k - 2)) % mod
print(((doit(n, m, k) + doit(m, n, k)) % mod)) | n, m, k = list(map(int, input().split()))
mod = 1000000007
fac = [1]
for i in range(1, n * m + 1):
fac.append((fac[-1] * i) % mod)
def pow(x, n):
ret = 1
while n > 0:
if (n & 1) == 1:
ret = (ret * x) % mod
x = (x * x) % mod
n >>= 1
return ret
def inv(i):
return pow(fac[i], mod - 2)
def cmb(n, k):
return (fac[n] * inv(k) * inv(n - k)) % mod
x = sum(d * (m - d) for d in range(m)) % mod
y = sum(d * (n - d) for d in range(n)) % mod
c = cmb(n * m - 2, k - 2)
x = (x * n * n * c) % mod
y = (y * m * m * c) % mod
print(((x + y) % mod)) | p03039 |
N,M,K=list(map(int,input().split()))
MOD=10**9+7
from fractions import Fraction
# 組合せの総数
def comb(n, k):
if n < 0 or k < 0:
pdt = 0
else:
pdt = 1
for s in range(1, k + 1):
pdt *= Fraction(n - s + 1, s)
# 戻り値をint型にするために分子を取り出す
return pdt.numerator
ans_x=0
ans_y=0
for i in range(1,N):
ans_x+=i*(N-i)
ans_x%=MOD
for i in range(1,M):
ans_y+=i*(M-i)
ans_y%=MOD
ans_x*=((M**2))
ans_y*=((N**2))
ans=comb(N*M-2,K-2)
ans*=(ans_x+ans_y)
ans%=MOD
print((int(ans))) | N,M,K=list(map(int,input().split()))
MOD=10**9+7
# 組合せの総数
def comb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
result%=MOD
return result
ans_x=0
ans_y=0
for i in range(1,N):
ans_x+=i*(N-i)
ans_x%=MOD
for i in range(1,M):
ans_y+=i*(M-i)
ans_y%=MOD
ans_x*=((M**2))
ans_y*=((N**2))
ans=comb(N*M-2,K-2)
ans*=(ans_x+ans_y)
ans%=MOD
print((int(ans))) | p03039 |
def factorial_mod(n, mod):
a = 1
for i in range(1, n + 1):
a *= i
a %= mod
return a
def comb_mod(n, k, mod):
fact_n = factorial_mod(n, mod)
fact_k = factorial_mod(k, mod)
fact_n_k = factorial_mod(n - k, mod)
return (fact_n * pow(fact_k, mod - 2, mod) * pow(fact_n_k, mod - 2, mod)) % mod
n, m, k = list(map(int, input().split()))
s = 0
mod = 10 ** 9 + 7
for x in range(m):
for i in range(x, m):
s += abs(x-i) * n **2
for y in range(n):
for j in range(y, n):
s += abs(y-j) * m ** 2
print((s * comb_mod(n * m - 2, k - 2, mod) % mod))
| def factorial_mod(n, mod):
a = 1
for i in range(1, n + 1):
a *= i
a %= mod
return a
def comb_mod(n, k, mod):
fact_n = factorial_mod(n, mod)
fact_k = factorial_mod(k, mod)
fact_n_k = factorial_mod(n - k, mod)
return (fact_n * pow(fact_k, mod - 2, mod) * pow(fact_n_k, mod - 2, mod)) % mod
n, m, k = list(map(int, input().split()))
s = 0
mod = 10 ** 9 + 7
for x in range(m):
s += (m - x - 1) * (m - x) // 2 * n **2
for y in range(n):
s += (n - y - 1) * (n - y) // 2 * m ** 2
print((s * comb_mod(n * m - 2, k - 2, mod) % mod))
| p03039 |
N, M, K = list(map(int, input().split()))
P = 10**9+7
fact = [1]
for i in range(N*M):
fact.append(fact[-1]*(i+1))
def inv(n):
return pow(n, P-2, P)
def C(a, b):
return fact[a]*inv(fact[a-b]*fact[b])%P
print(((M**2*(N**3-N)+N**2*(M**3-M))//6*C(M*N-2, K-2)%P)) | N, M, K = list(map(int, input().split()))
P = 10**9+7
fact = [1]
for i in range(N*M):
fact.append(fact[-1]*(i+1)%P)
def inv(n):
return pow(n, P-2, P)
def C(a, b):
return fact[a]*inv(fact[a-b]*fact[b])%P
print(((M**2*(N**3-N)+N**2*(M**3-M))//6*C(M*N-2, K-2)%P)) | p03039 |
import math
n,m,k = list(map(int,input().split()))
mod = 10**9+7
memo = {}
def factorial(num):
if num == 0:
return 1
if not num in memo:
memo[num] = num*factorial(num-1)
return memo[num]
temp = math.factorial(n*m-2)//(math.factorial(k-2)*math.factorial(n*m-k))
ans = 0
for d in range(1,n):
ans += d*((n-d)*(m**2))*temp
for d in range(1,m):
ans += d*((m-d)*(n**2))*temp
print((ans%mod)) | n,m,k = list(map(int,input().split()))
mod = 10**9+7
def combination(n,r,p):
if n < r or r < 0:
return 0
r = min(n-r,r)
fact = [1,1]
factinv = [1,1]
inv = [0,1]
for i in range(2,n+1):
fact.append((fact[-1]*i)%p)
inv.append((-inv[p%i]*(p//i))%p)
factinv.append((factinv[-1]*inv[-1])%p)
return fact[n]*factinv[r]*factinv[n-r]%p
temp = combination(n*m-2,k-2,mod)
ans = 0
for d in range(1,n):
ans += d*((n-d)*(m**2))*temp
for d in range(1,m):
ans += d*((m-d)*(n**2))*temp
print((ans%mod)) | p03039 |
n,m,k=list(map(int,input().split()))
ans=0
INF=10**9+7
if n<=m:
M=(m-1)*m*(2*m-1)//3
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
else:
d=j-i
ans=ans+d*m+2*d*m*(m-1)+(m-d)*m*(m-1)-M
ans=ans%INF
else:
(n,m)=(m,n)
M=(m-1)*m*(2*m-1)//3
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
else:
d=j-i
ans=ans+d*m+2*d*m*(m-1)+(m-d)*m*(m-1)-M
ans=ans%INF
import math
ans=(math.factorial(n*m-2)//(math.factorial(n*m-k)*math.factorial(k-2)))*ans
ans=ans%INF
print(ans)
| n,m,k=list(map(int,input().split()))
ans=0
INF=10**9+7
if n<=m:
M=(m-1)*m*(2*m-1)//3
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
else:
d=j-i
ans=ans+d*m+(m+d)*m*(m-1)-M
ans=ans%INF
else:
(n,m)=(m,n)
M=(m-1)*m*(2*m-1)//3
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
else:
d=j-i
ans=ans+d*m+(m+d)*m*(m-1)-M
ans=ans%INF
import math
ans=(math.factorial(n*m-2)//(math.factorial(n*m-k)*math.factorial(k-2)))*ans
ans=ans%INF
print(ans)
| p03039 |
n,m,k=list(map(int,input().split()))
ans=0
INF=10**9+7
if n<=m:
M=-(m-1)*m*(2*m-1)//3+m*m*(m-1)
Ms=m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
M=M%INF
Ms=Ms%INF
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+Ms
else:
d=j-i
ans=ans+d*m**2+M
ans=ans%INF
else:
(n,m)=(m,n)
M=-(m-1)*m*(2*m-1)//3+m*m*(m-1)
Ms=m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
M=M%INF
Ms=Ms%INF
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+Ms
else:
d=j-i
ans=ans+d*m**2+M
ans=ans%INF
a=1
b=1
x=min(n*m-2,k-2)
for i in range(x):
a=a*(n*m-2-i)
b=b*(i+1)
ans=(ans*a//b)%INF
print(ans)
| n,m,k=list(map(int,input().split()))
ans=0
INF=10**9+7
if n<=m:
M=-(m-1)*m*(2*m-1)//3+m*m*(m-1)
Ms=m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
M=M%INF
Ms=Ms%INF
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+Ms
else:
d=j-i
ans=ans+d*m**2+M
ans=ans%INF
else:
(n,m)=(m,n)
M=-(m-1)*m*(2*m-1)//3+m*m*(m-1)
Ms=m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
M=M%INF
Ms=Ms%INF
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+Ms
else:
d=j-i
ans=ans+d*m**2+M
ans=ans%INF
import math
ans=(math.factorial(n*m-2)//(math.factorial(n*m-k)*math.factorial(k-2)))*ans
ans=ans%INF
print(ans)
| p03039 |
n,m,k=list(map(int,input().split()))
ans=0
INF=10**9+7
if n<=m:
M=-(m-1)*m*(2*m-1)//3+m*m*(m-1)
Ms=m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
M=M%INF
Ms=Ms%INF
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+Ms
else:
d=j-i
ans=ans+d*m**2+M
ans=ans%INF
else:
(n,m)=(m,n)
M=-(m-1)*m*(2*m-1)//3+m*m*(m-1)
Ms=m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
M=M%INF
Ms=Ms%INF
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+Ms
else:
d=j-i
ans=ans+d*m**2+M
ans=ans%INF
a=1
b=1
c=n*m-2
x=min(c,k-2)
for i in range(x):
a=a*(c-i)
b=b*(i+1)
ans=(ans*a//b)%INF
print(ans)
| n,m,k=list(map(int,input().split()))
ans=0
INF=10**9+7
if n<=m:
M=-(m-1)*m*(2*m-1)//3+m*m*(m-1)
Ms=m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
M=M%INF
Ms=Ms%INF
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+Ms
else:
d=j-i
ans=ans+d*m**2+M
ans=ans%INF
else:
(n,m)=(m,n)
M=-(m-1)*m*(2*m-1)//3+m*m*(m-1)
Ms=m*m*(m-1)//2-(m-1)*m*(2*m-1)//6
M=M%INF
Ms=Ms%INF
for i in range(1,n+1):
for j in range(i,n+1):
if i==j:
ans=ans+Ms
else:
d=j-i
ans=ans+d*m**2+M
ans=ans%INF
def modcomb(n,k,m):
fac=[0]*(n+1)
finv=[0]*(n+1)
inv=[0]*(n+1)
fac[0]=fac[1]=1
finv[0]=finv[1]=1
inv[1]=1
for i in range(2,n+1):
fac[i]=fac[i-1]*i%m
inv[i]=m-inv[m%i]*(m//i)%m
finv[i]=finv[i-1]*inv[i]%m
return fac[n]*(finv[k]*finv[n-k]%m)%m
ans=ans*modcomb(n*m-2,k-2,INF)%INF
print(ans)
| p03039 |
n, m, k = list(map(int, input().split()))
mod = 10 ** 9 + 7
MAX = n * m
class ModInt:
def __init__(self, num):
self.num = num
def __str__(self):
return str(self.num)
def __repr__(self):
return "ModInt(num: {}, mod: {}".format(self.num, mod)
def __add__(self, other):
ret = self.num + other.num
ret %= mod
return ModInt(ret)
def __sub__(self, other):
ret = self.num - other.num
ret %= mod
return ModInt(ret)
def __mul__(self, other):
ret = self.num * other.num
ret %= mod
return ModInt(ret)
def pow(self, times):
pw = pow(self.num, times, mod)
return ModInt(pw)
def inverse(self):
return ModInt(inv[self.num])
def __truediv__(self, other):
num = self * other.inverse()
return ModInt(num)
def comb(n, k):
return fact[n] * inv[n-k] * inv[k]
fact = [None] * (MAX + 1)
fact[0] = ModInt(1)
for i in range(1, MAX + 1):
fact[i] = fact[i-1] * ModInt(i)
inv = [None] * (MAX + 1)
inv[MAX] = fact[MAX].pow(mod - 2)
for i in range(MAX, 0, -1):
inv[i-1] = inv[i] * ModInt(i)
ans = ModInt(0)
for i in range(n):
for j in range(m):
add = ModInt(n - i) * ModInt(m - j) * ModInt(i + j)
if i != 0 and j != 0:
add *= ModInt(2)
ans += add
ans *= comb(n * m - 2, k - 2)
print(ans)
| n, m, k = list(map(int, input().split()))
mod = 10 ** 9 + 7
MAX = n * m
fact = [1] * (MAX + 1)
for i in range(1, MAX + 1):
fact[i] = (fact[i-1] * i) % mod
inv = [1] * (MAX + 1)
inv[MAX] = pow(fact[MAX], mod - 2, mod)
for i in range(MAX, 0, -1):
inv[i-1] = (inv[i] * i) % mod
def comb(n, k):
return fact[n] * inv[n-k] * inv[k] % mod
ans = 0
for i in range(n):
for j in range(m):
add = (n - i) * (m - j) * (i + j) % mod
if i != 0 and j != 0:
add *= 2
add %= mod
ans += add
ans %= mod
ans *= comb(MAX - 2, k - 2)
ans %= mod
print(ans)
| p03039 |
inpl = lambda: list(map(int,input().split()))
N, M ,K = inpl()
MOD = 10**9+7
factor = 1
# MN-2 C K-2 = MN-2 C MN-K = MN-2 C L
L = min(K-2,M*N-K)
for i in range(M*N-L-1,M*N-1):
factor *= i
for i in range(1,L+1):
factor //= i
factor %= MOD
ans = ((M*(N-1)*(N+1) + N*(M-1)*(M+1))*M*N //6 * factor) % MOD
print(ans) | inpl = lambda: list(map(int,input().split()))
N, M ,K = inpl()
MOD = 10**9+7
def mod_inv(a, m=MOD):
def mod_inv_sub(a, m):
if a == 1:
return 1, 0
else:
d, r = m//a, m % a
x, y = mod_inv_sub(r, a)
return y - d*x, x
x = mod_inv_sub(a,m)[0]
if x < 0:
x += (-x//m + 1) * m
return x
factor = 1
# MN-2 C K-2 = MN-2 C MN-K = MN-2 C L
L = min(K-2,M*N-K)
for i in range(M*N-L-1,M*N-1):
factor = factor * i % MOD
for i in range(1,L+1):
factor = factor * mod_inv(i) % MOD
ans = ((M*(N-1)*(N+1) + N*(M-1)*(M+1))*M*N //6 * factor) % MOD
print(ans) | p03039 |
# coding: utf-8
import re
import math
import fractions
import random
import time
#import numpy as np
mod=int(10**9+7)
inf=int(10**20)
fac=[1]*250000
for a in range(2,250000):
fac[a]=fac[a-1]*a%mod
class union_find():
def __init__(self,n):
self.n=n
self.P=[a for a in range(N)]
self.rank=[0]*n
def find(self,x):
if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
return self.P[x]
def same(self,x,y):
return self.find(x)==self.find(y)
def link(self,x,y):
if self.rank[x]<self.rank[y]:
self.P[x]=y
elif self.rank[y]<self.rank[x]:
self.P[y]=x
else:
self.P[x]=y
self.rank[y]+=1
def unite(self,x,y):
self.link(self.find(x),self.find(y))
def size(self):
S=set()
for a in range(self.n):
S.add(self.find(a))
return len(S)
def bin_(num,size):
A=[0]*size
for a in range(size):
if (num>>(size-a-1))&1==1:
A[a]=1
else:
A[a]=0
return A
def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r)
def next_comb(num,size):
x=num&(-num)
y=num+x
z=num&(~y)
z//=x
z=z>>1
num=(y|z)
if(num>=(1<<size)):return False
else:
return num
def comb_(n,r):return fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod)
#main
def solve():
return
#入力
N,M,K=list(map(int,input().split()))
sum_=0
for a in range(N-1):
for b in range(a+1,N):
sum_+=M*M*abs(a-b)*comb_(N*M-2,K-2)%mod
for a in range(M-1):
for b in range(a+1,M):
sum_+=N*N*abs(a-b)*comb_(N*M-2,K-2)%mod
print((sum_%mod))
| # coding: utf-8
import re
import math
import fractions
import random
import time
#import numpy as np
mod=int(10**9+7)
inf=int(10**20)
fac=[1]*250000
for a in range(2,250000):
fac[a]=fac[a-1]*a%mod
class union_find():
def __init__(self,n):
self.n=n
self.P=[a for a in range(N)]
self.rank=[0]*n
def find(self,x):
if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
return self.P[x]
def same(self,x,y):
return self.find(x)==self.find(y)
def link(self,x,y):
if self.rank[x]<self.rank[y]:
self.P[x]=y
elif self.rank[y]<self.rank[x]:
self.P[y]=x
else:
self.P[x]=y
self.rank[y]+=1
def unite(self,x,y):
self.link(self.find(x),self.find(y))
def size(self):
S=set()
for a in range(self.n):
S.add(self.find(a))
return len(S)
def bin_(num,size):
A=[0]*size
for a in range(size):
if (num>>(size-a-1))&1==1:
A[a]=1
else:
A[a]=0
return A
def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r)
def next_comb(num,size):
x=num&(-num)
y=num+x
z=num&(~y)
z//=x
z=z>>1
num=(y|z)
if(num>=(1<<size)):return False
else:
return num
def comb_(n,r):return fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod)
#main
def solve():
return
#入力
N,M,K=list(map(int,input().split()))
sum_=0
for a in range(1,N):
sum_+=M*M*abs(N-a)*a*comb_(N*M-2,K-2)
sum_%=mod
for a in range(1,M):
sum_+=N*N*abs(M-a)*a*comb_(N*M-2,K-2)
sum_%=mod
print(sum_)
| p03039 |
n,m,k=list(map(int,input().split()))
mod=10**9+7
from operator import mul
from functools import reduce
def cmb(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1,r + 1)))
return over // under%mod
A=n*m
v=cmb(A-2,k-2)
t=0
y=0
for i in range(1,n):
t+=i*(n-i)*m*m%mod
for i in range(1,m):
y+=i*(m-i)*n*n%mod
ans=v*(t+y)
print((ans%mod))
| n,m,k=list(map(int,input().split()))
mod=10**9+7
A=n*m-2
from math import factorial
def Comb(N, K):
a = factorial(N) % mod
b = factorial(K) % mod
c = factorial(N-K) % mod
return (a * pow(b, mod-2, mod) * pow(c, mod-2, mod)) % mod
v=Comb(A,k-2)
t=0
y=0
for i in range(1,n):
t+=i*(n-i)*m*m%mod
for i in range(1,m):
y+=i*(m-i)*n*n%mod
ans=v*(t+y)
print((ans%mod)) | p03039 |
from itertools import combinations
import math
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
N = 10 ** 6 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
N,M,K = list(map(int,input().split()))
ans = 0
mod = 10**9 +7
by = cmb(N*M-2,K-2,mod)
#まずは、X軸の総和を求める。
for i in range(N):
for j in range(M):
cnt = M-j-1
add = (((j+1)+(M-1))*cnt//2 - j*cnt)*N%mod
ans += add*by%mod
ans %= mod
for i in range(M):
for j in range(N):
cnt = N-j-1
add = (((j+1)+(N-1))*cnt//2 - j*cnt)*M%mod
ans += add*by%mod
ans %= mod
print(ans) | """
基本の方針は「各マンハッタン距離が何回足されるか」という考え方で距離の値を積み上げて行けばよい
まず、XとYは独立に考えることにする。
X軸の距離の方から積み上げる。
X1とX2の距離が足される回数は、
A.X1の列とX2の列の座標の組み合わせの数 × B.その組み合わせが含まれるような座標の組み合わせの数
である。
A ＝ 行数**２
B ＝ CMB(N*M-2 , K-2)である
同様の計算をY軸に関しても行えばよい。
"""
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
N = 10 ** 6 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
N,M,K = list(map(int,input().split()))
ans = 0
#X軸の距離を考える
A = M*M
B = cmb(N*M-2,K-2,p)
for i in range(1,N):
ans += ((i*i)-(i-1+0)*i//2)*A*B%p
ans %= p
#Y軸の距離を考える
A = N*N
B = cmb(N*M-2,K-2,p)
for i in range(1,M):
ans += ((i*i)-(i-1+0)*i//2)*A*B%p
ans %= p
print(ans)
| p03039 |
import sys
mod = pow(10, 9) + 7
def C(n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
NNN = (10**6)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, NNN+1):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
n,m,k=list(map(int,input().split()))
#n=m=k=2
print((C(n*m,k)*C(k,2)%mod*(n+m)*inverse[3]%mod))
| N, M, K = list(map(int, input().split()))
import sys
mod = pow(10, 9) + 7
sys.setrecursionlimit(pow(10, 8))
def power(x, y):
if y == 0: return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y//2)**2 % mod
else: return power(x, (y-1)//2)**2 * x % mod
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def div(a, b):
return mul(a, power(b, mod-2))
def div2(a, b):
return mul(a, modinv(b))
def modinv(a):
b, u, v = mod, 1, 0
while b:
t = a//b
a, u = a-t*b, u-t*v
a, b, u, v = b, a, v, u
u %= mod
return u
def cmb(n, r):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
NNN = (10**6)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
def f(n, m):
x = m*m%mod
y = (n*n*(n-1)//2 - n*(n-1)*(2*n-1)//6) % mod
return x*y%mod
print((mul(f(N, M) + f(M, N), cmb(N*M-2, K-2))))
| p03039 |
#!/usr/bin/env python3
import sys
INF = float("inf")
MOD = 1000000007 # type: int
def cmb(n, r):
r = min(r, n-r)
if r == 0:
return 1
if r == 1:
return n
numer = [n - r + k + 1 for k in range(r)]
denom = [k + 1 for k in range(r)]
for p in range(2, r+1):
pivot = denom[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1, r, p):
numer[k - offset] /= pivot
denom[k] /= pivot
result = 1
for k in range(r):
if numer[k] > 1:
result *= int(numer[k])
return result
def solve(N: int, M: int, K: int):
sx = 0
for x in range(1, M+1):
sx += x*(x-1)//2
sx %= MOD
sx *= N*N
sx %= MOD
sy = 0
for y in range(1, N+1):
sy += y*(y-1)//2
sy %= MOD
sy *= M*M
sy %= MOD
s = (sx+sy) % MOD
s = (s*cmb(N*M-2, K-2)) % MOD
print(s)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
solve(N, M, K)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
INF = float("inf")
MOD = 1000000007 # type: int
def cmb(n, r):
r = min(r, n-r)
if r == 0:
return 1
if r == 1:
return n
numer = [n - r + k + 1 for k in range(r)]
denom = [k + 1 for k in range(r)]
for p in range(2, r+1):
pivot = denom[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1, r, p):
numer[k - offset] /= pivot
denom[k] /= pivot
result = 1
for k in range(r):
if numer[k] > 1:
result *= int(numer[k])
result %= MOD
return result
def solve(N: int, M: int, K: int):
sx = (M*(M+1)*(M-1)//6) % MOD
sx = (sx * N*N) % MOD
sy = (N*(N+1)*(N-1)//6) % MOD
sy = (sy * M*M) % MOD
s = (sx + sy) % MOD
s = (s*cmb(N*M-2, K-2)) % MOD
print(s)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
solve(N, M, K)
if __name__ == '__main__':
main()
| p03039 |
MAX = 10**9 + 7
def mod_inv(i, MOD):
return pow(i, MOD-2, MOD)
def combination(_N, _K):
if _K > (_N/2):
_K = _N - _K
up = 1
low = 1
for i in range (_K):
up *= (_N - i) % MAX
low *= (i + 1) % MAX
ret = up * mod_inv(low, MAX)
if ret >= MAX:
ret %= MAX
return ret
def solve():
N, M, K = [int(_) for _ in input().split()]
disSum = (M*N* ((M*(N+1)*(N-1))%MAX + (N*(M+1)*(M-1)) % MAX)) % MAX
disSum *= mod_inv(6, MAX)
if disSum >= MAX:
disSum %= MAX
ret = disSum * combination(M*N-2, K-2)
if ret >= MAX:
ret %= MAX
print(ret)
if __name__ == '__main__':
solve()
| MAX = 10**9 + 7
def mod_inv(i, mod):
return pow(i, mod-2, mod)
def combination(_N, _K):
if _K > (_N/2):
_K = _N - _K
up = 1
low = 1
for i in range (_K):
up = up * (_N - i) % MAX
low = low * (i + 1) % MAX
ret = up * mod_inv(low, MAX) % MAX
return ret
def solve():
N, M, K = [int(_) for _ in input().split()]
disSum = (M*N* ((M*(N+1)*(N-1))%MAX + (N*(M+1)*(M-1)) % MAX)) % MAX
disSum *= mod_inv(6, MAX) % MAX
ret = disSum * combination(M*N-2, K-2) % MAX
print(ret)
if __name__ == '__main__':
solve()
| p03039 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, M, K = list(map(int, readline().split()))
COM_MAX = N * M
fac, finv, inv = [0] * (COM_MAX + 1), [0] * (COM_MAX + 1), [0] * (COM_MAX + 1)
fac[0] = fac[1] = finv[0] = finv[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 com(n, r):
if n < 0 or r < 0 or n < r:
return 0
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD
def solve(n, m, k):
ans = 0
for j in range(1, k):
tmp = 0
for i in range(1, n):
tmp = (tmp + com(m * i, j) * com(m * (n - i), k - j)) % MOD
ans = (ans + tmp * j * (k - j)) % MOD
return ans
ans = (solve(N, M, K) + solve(M, N, K)) % MOD
print(ans)
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
MOD = 1000000007
def main():
N, M, K = list(map(int, readline().split()))
COM_MAX = N * M
fac, finv, inv = [0] * (COM_MAX + 1), [0] * (COM_MAX + 1), [0] * (COM_MAX + 1)
fac[0] = fac[1] = finv[0] = finv[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 com(n, r):
if n < 0 or r < 0 or n < r:
return 0
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD
def solve(n, m, k):
ans = 0
for d in range(1, n):
ans = (ans + com(n * m - 2, k - 2) * (m ** 2) * (n - d) * d) % MOD
return ans
ans = (solve(N, M, K) + solve(M, N, K)) % MOD
print(ans)
return
if __name__ == '__main__':
main()
| p03039 |
n,m,k=list(map(int,input().split()))
mod=10**9+7
import math
def f(x):
return math.factorial(x)
def c(x,y):
return f(x)//(f(x-y)*f(y))
ans=(n**2*(m-1)*m*(m+1)//6)%mod
ans=(ans+m**2*(n-1)*n*(n+1)//6)%mod
ans=(ans*c(m*n-2,k-2))%mod
print(ans) | n,m,k=list(map(int,input().split()))
import math
def f(x): return math.factorial(x)
def c(x,y): return f(x)//(f(x-y)*f(y))
print((((n**2*(m-1)*m*(m+1)//6+m**2*(n-1)*n*(n+1)//6)*c(m*n-2,k-2))%(10**9+7))) | p03039 |
import sys
sys.setrecursionlimit(100000)
while True:
n,m,h,k = list(map(int,input().split()))
if not n: break
s_lst = [int(eval(input())) for _ in range(n)]
b_lst = [tuple(map(int,input().split())) for _ in range(m)]
b_lst = sorted(b_lst,key=lambda x:-x[1])
def amida(b_lst, s_lst, used, k):
if not b_lst:
return sum(s_lst[0:k])
elif used:
for bar in b_lst:
a = bar[0]
temp = s_lst[a]
s_lst[a] = s_lst[a - 1]
s_lst[a - 1] = temp
return sum(s_lst[0:k])
else:
save_s_lst = [i for i in s_lst]
a = b_lst[0][0]
temp = s_lst[a]
s_lst[a] = s_lst[a - 1]
s_lst[a - 1] = temp
return min(amida(b_lst[1:], s_lst, 0, k), amida(b_lst[1:], save_s_lst, 1, k))
print((amida(b_lst, s_lst, 0, k)))
| while True:
n,m,h,k = list(map(int,input().split()))
if not n: break
s_lst = [int(eval(input())) for _ in range(n)]
i_lst = [i for i in range(n)]
b_lst = [tuple(map(int,input().split())) for _ in range(m)]
b_lst = sorted(b_lst,key=lambda x:x[1])
pare_lst = []
for bar in b_lst:
ind = bar[0]
temp = i_lst[ind]
i_lst[ind] = i_lst[ind - 1]
i_lst[ind - 1] = temp
pare_lst.append((i_lst[ind], i_lst[ind - 1]))
# print(i_lst)
new_s_lst = [0] * n
for i in range(n):
new_s_lst[i_lst[i]] = s_lst[i]
# print(s_lst)
ans = sum(new_s_lst[:k])
# print(ans)
# print(pare_lst)
max_dec = 0
for pare in pare_lst:
a = pare[0]
b = pare[1]
# print(a,b,s_lst[a],s_lst[b])
if a < k and b >= k and new_s_lst[a] - new_s_lst[b] > max_dec:
max_dec = new_s_lst[a] - new_s_lst[b]
if b < k and a >= k and new_s_lst[b] - new_s_lst[a] > max_dec:
max_dec = new_s_lst[b] - new_s_lst[a]
print((ans - max_dec))
| p00463 |
while True:
n, m, h, k = list(map(int, input().split()))
if not n:
break
points = [int(eval(input())) for _ in range(n)]
bars = [tuple(map(int, input().split())) for _ in range(m)]
bars_h = [set() for _ in range(h)]
for ba, bh in bars:
bars_h[bh].add(ba - 1)
swap = [points] + [None] * m
pattern = 1
for i in range(h - 1, 0, -1):
for ba in bars_h[i]:
swap[pattern] = swap[0][:]
for s in swap[:pattern]:
s[ba], s[ba + 1] = s[ba + 1], s[ba]
pattern += 1
print((min(sum(s[:k]) for s in swap))) | while True:
n, m, h, k = list(map(int, input().split()))
if not n:
break
points = [int(eval(input())) for _ in range(n)]
bars = [tuple(map(int, input().split())) for _ in range(m)]
bars_h = [set() for _ in range(h)]
for ba, bh in bars:
bars_h[bh].add(ba - 1)
swap = list(range(n))
history = set()
for i in range(h - 1, 0, -1):
for ba in bars_h[i]:
l, r = swap[ba:ba + 2]
history.add((l, r) if l < r else (r, l))
swap[ba:ba + 2] = r, l
swap_dict = {v: i for i, v in enumerate(swap)}
min_score_d = 0
for l, r in history:
li, ri = swap_dict[l], swap_dict[r]
if li > ri:
l, r, li, ri = r, l, ri, li
if li < k and k <= ri:
min_score_d = min(min_score_d, points[r] - points[l])
print((sum(points[x] for x in swap[:k]) + min_score_d)) | p00463 |
import sys
input=sys.stdin.readline
import copy
def knapsack(N,W,weight,value):
dp=[[999999999999 for i in range(W+1)] for j in range(N+1)]
dp2=[[set() for i in range(W+1)] for j in range(N+1)]
for i in range(W+1): dp[0][i]=0
for i in range(N):
for w in range(W+1):
if weight[i]<=w:
if dp[i][w-weight[i]]+value[i]>dp[i][w]:
dp[i+1][w]=dp[i][w-weight[i]]+value[i]
x=copy.copy(dp2[i][w-weight[i]])
x.add(i)
dp2[i+1][w]=x
else:
dp[i+1][w]=dp[i][w]
dp2[i+1][w]=dp2[i][w]
else:
dp[i+1][w]=dp[i][w]
dp2[i+1][w]=dp2[i][w]
return [dp[N][W],dp2[N][W]]
n,t=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
a=[];b=[]
for i in range(n):
a.append(l[i][0])
b.append(l[i][1])
z=knapsack(n,t-1,a,b)
x=z[0];y=z[1]
M=[]
for i in range(n):
if i not in y:
M.append(b[i])
if len(M)==0:
print(x)
else:
print((x+max(M))) | import sys
input=sys.stdin.readline
import copy
def knapsack(N,W,weight,value):
dp=[[999999999999 for i in range(W+1)] for j in range(N+1)]
dp2=[]
for i in range(N+1):
x=[]
for j in range(W+1):
x.append([])
dp2.append(x)
for i in range(W+1): dp[0][i]=0
for i in range(N):
for w in range(W+1):
if weight[i]<=w:
if dp[i][w-weight[i]]+value[i]>dp[i][w]:
dp[i+1][w]=dp[i][w-weight[i]]+value[i]
x=copy.copy(dp2[i][w-weight[i]])
x.append(i)
dp2[i+1][w]=x
else:
dp[i+1][w]=dp[i][w]
dp2[i+1][w]=dp2[i][w]
else:
dp[i+1][w]=dp[i][w]
dp2[i+1][w]=dp2[i][w]
return [dp[N][W],dp2[N][W]]
n,t=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
a=[];b=[]
for i in range(n):
a.append(l[i][0])
b.append(l[i][1])
z=knapsack(n,t-1,a,b)
x=z[0];y=z[1]
L=[0 for i in range(n)]
m=0
for i in range(len(y)):
L[y[i]]=1
M=[]
for i in range(n):
if L[i]==0:
M.append(b[i])
if len(M)==0:
print(x)
else:
print((x+max(M))) | p02863 |
import sys
input=sys.stdin.readline
import copy
def knapsack(N,W,weight,value):
dp=[[999999999999 for i in range(W+1)] for j in range(N+1)]
dp2=[]
for i in range(N+1):
x=[]
for j in range(W+1):
x.append([])
dp2.append(x)
for i in range(W+1): dp[0][i]=0
for i in range(N):
for w in range(W+1):
if weight[i]<=w:
if dp[i][w-weight[i]]+value[i]>dp[i][w]:
dp[i+1][w]=dp[i][w-weight[i]]+value[i]
x=copy.copy(dp2[i][w-weight[i]])
x.append(i)
dp2[i+1][w]=x
else:
dp[i+1][w]=dp[i][w]
dp2[i+1][w]=dp2[i][w]
else:
dp[i+1][w]=dp[i][w]
dp2[i+1][w]=dp2[i][w]
return [dp[N][W],dp2[N][W]]
n,t=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
a=[];b=[]
for i in range(n):
a.append(l[i][0])
b.append(l[i][1])
z=knapsack(n,t-1,a,b)
x=z[0];y=z[1]
L=[0 for i in range(n)]
m=0
for i in range(len(y)):
L[y[i]]=1
M=[]
for i in range(n):
if L[i]==0:
M.append(b[i])
if len(M)==0:
print(x)
else:
print((x+max(M))) | import sys
input=sys.stdin.readline
import copy
def knapsack(N,W,weight,value):
dp=[[999999999999 for i in range(W+1)] for j in range(N+1)]
for i in range(W+1): dp[0][i]=0
for i in range(N):
for w in range(W+1):
if weight[i]<=w:
if dp[i][w-weight[i]]+value[i]>dp[i][w]:
dp[i+1][w]=dp[i][w-weight[i]]+value[i]
else:
dp[i+1][w]=dp[i][w]
else:
dp[i+1][w]=dp[i][w]
return dp
n,t=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
l.sort()
a=[];b=[]
for i in range(n):
a.append(l[i][0])
b.append(l[i][1])
dp=knapsack(n,t-1,a,b)
ans=[]
for i in range(n):
if i!=n:
ans.append(dp[i][t-1]+b[i])
else:
ans.append(dp[n][t-i])
print((max(ans))) | p02863 |
import sys
input=sys.stdin.readline
def knapsack(N,W,weight,value):
dp=[[float('inf') for i in range(W+1)] for j in range(N+1)]
for i in range(W+1):
dp[0][i]=0
for i in range(N):
for w in range(W+1):
if weight[i]<=w:
if dp[i][w-weight[i]]+value[i]>dp[i][w]:
dp[i+1][w]=dp[i][w-weight[i]]+value[i]
else:
dp[i+1][w]=dp[i][w]
else:
dp[i+1][w]=dp[i][w]
return dp
n,t=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
l.sort()
a=[];b=[]
for i in range(n):
a.append(l[i][0])
b.append(l[i][1])
dp=knapsack(n,t-1,a,b)
ans=[]
for i in range(n):
if i!=n:
ans.append(dp[i][t-1]+b[i])
else:
ans.append(dp[n][t])
print((max(ans))) | import sys
input=sys.stdin.readline
def knapsack(N,W,weight,value):
dp=[[999999999999 for i in range(W+1)] for j in range(N+1)]
for i in range(W+1):
dp[0][i]=0
for i in range(N):
for w in range(W+1):
if weight[i]<=w:
if dp[i][w-weight[i]]+value[i]>dp[i][w]:
dp[i+1][w]=dp[i][w-weight[i]]+value[i]
else:
dp[i+1][w]=dp[i][w]
else:
dp[i+1][w]=dp[i][w]
return dp
n,t=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
l.sort()
a=[];b=[]
for i in range(n):
a.append(l[i][0])
b.append(l[i][1])
dp=knapsack(n,t-1,a,b)
ans=[]
for i in range(n):
if i!=n:
ans.append(dp[i][t-1]+b[i])
else:
ans.append(dp[n][t])
print((max(ans))) | p02863 |
import sys
input=sys.stdin.readline
import copy
def knapsack(N,W,weight,value):
dp=[[999999999999 for i in range(W+1)] for j in range(N+1)]
dp2=[[0 for i in range(W+1)] for j in range(N+1)]
for i in range(W+1): dp[0][i]=0
for i in range(N):
for w in range(W+1):
if weight[i]<=w:
if dp[i][w-weight[i]]+value[i]>dp[i][w]:
dp[i+1][w]=dp[i][w-weight[i]]+value[i]
dp2[i+1][w]=w-weight[i]
else:
dp[i+1][w]=dp[i][w]
dp2[i+1][w]=w
else:
dp[i+1][w]=dp[i][w]
dp2[i+1][w]=w
l=[]
x=W
for i in range(n-1,-1,-1):
if dp2[i+1][x]==x-weight[i]:
l.append(i)
x=dp2[i+1][x]
return dp[N][W],l
n,t=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
a=[];b=[]
for i in range(n):
a.append(l[i][0])
b.append(l[i][1])
z=knapsack(n,t-1,a,b)
L=[0]*n
for i in range(len(z[1])):
L[z[1][i]]=1
M=[]
for i in range(n):
if L[i]==0:
M.append(l[i][1])
if len(M)==0:
print((z[0]))
else:
print((z[0]+max(M))) | import sys
input=sys.stdin.readline
def knapsack(N,W,weight,value):
dp=[[999999999999 for i in range(W+1)] for j in range(N+1)]
for i in range(W+1):
dp[0][i]=0
for i in range(N):
for w in range(W+1):
if weight[i]<=w:
if dp[i][w-weight[i]]+value[i]>dp[i][w]:
dp[i+1][w]=dp[i][w-weight[i]]+value[i]
else:
dp[i+1][w]=dp[i][w]
else:
dp[i+1][w]=dp[i][w]
return dp
n,t=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
l.sort()
a=[];b=[]
for i in range(n):
a.append(l[i][0])
b.append(l[i][1])
dp=knapsack(n,t-1,a,b)
ans=[]
for i in range(n):
if i!=n:
ans.append(dp[i][t-1]+b[i])
else:
ans.append(dp[n][t])
print((max(ans))) | p02863 |
N,T=list(map(int,input().split()))
x=[None] # x[0]
for i in range(1,N+1): # x[i]のiに対応させる
x.append(tuple(map(int,input().split()))) # x[1]~x[N]
# print(x) #DB★
dp1=[[0 for j in range(T)] for i in range(N+2)] # 0~N+1 dp1[i]はx[1]からx[i]まで使用（dp1[0]は使用するx[i]なしの初期値，dp1[N+1]は余り→0で初期化していることが後で役に立つ）
for i in range(1,N+1): # dp1[0]は初期値なのでいじらない。dp1[N+1]は余りなので計算しない。dp1[N]まで計算するので，iはNまで
for j in range(T): # 0分後からT-1分後まで計算する
if x[i][0]>j:
dp1[i][j]=dp1[i-1][j]
else:
dp1[i][j]=max(dp1[i-1][j],dp1[i-1][j-x[i][0]]+x[i][1])
# print(dp1) #DB★
dp2=[[0 for j in range(T)] for i in range(N+2)] # 0~N+1 dp2[i]はx[i]からx[N]まで（x[N]からx[i]まで）使用（dp2[N+1]は使用するx[i]なしの初期値，dp2[0]は余り）
for i in range(N,0,-1): # dp2[N+1]は初期値なのでいじらない。dp2[0]は余りなので計算しない。dp2[1]まで計算するので，iは1まで
for j in range(T):
if x[i][0]>j:
dp2[i][j]=dp2[i+1][j]
else:
dp2[i][j]=max(dp2[i+1][j],dp2[i+1][j-x[i][0]]+x[i][1])
# print(dp2) #DB★
cans=[0 for i in range(N+1)] # i番目の料理を最後に食べる場合の満足度の最大値
for i in range(1,N+1):
cans[i]=max([dp1[i-1][j]+dp2[i+1][T-1-j] for j in range(T)])+x[i][1]
# print(cans) #DB★
ans=max(cans)
print(ans) | N,T=list(map(int,input().split()))
x=[(0,0)] # x[0]
for i in range(1,N+1): # x[i]のiに対応させる
x.append(tuple(map(int,input().split()))) # x[1]~x[N]
x.sort()
# print(x) #DB★
dp1=[[0 for j in range(T)] for i in range(N+2)] # 0~N+1 dp1[i]はx[1]からx[i]まで使用（dp1[0]は使用するx[i]なしの初期値，dp1[N+1]は余り→0で初期化していることが後で役に立つ）
for i in range(1,N+1): # dp1[0]は初期値なのでいじらない。dp1[N+1]は余りなので計算しない。dp1[N]まで計算するので，iはNまで
for j in range(T): # 0分後からT-1分後まで計算する
if x[i][0]>j:
dp1[i][j]=dp1[i-1][j]
else:
dp1[i][j]=max(dp1[i-1][j],dp1[i-1][j-x[i][0]]+x[i][1])
cans=[dp1[i-1][T-1]+x[i][1] for i in range(1,N+1)]
# print(cans) #DB★
ans=max(cans)
print(ans) | p02863 |
n, t = list(map(int, input().split()))
a, b, ab = [], [], []
for _ in range(n):
ab.append(tuple(map(int, input().split())))
ab.sort(key=lambda x:x[0])
for i in ab:
a.append(i[0])
b.append(i[1])
# dp[i][j] = 0~i番目の料理でj分以内に完食できる美味しさの合計の最大値
# 0 <= i <= n-1, 0 <= j <= t-1
dp = [[0 for _ in range(a[0])] + [b[0] for _ in range(t-a[0])]]
for i in range(1, n):
dp.append([])
for j in range(min([t, a[i]])):
dp[i].append(dp[i-1][j])
for j in range(a[i], t):
dp[i].append(max([dp[i-1][j], dp[i-1][j-a[i]]+b[i]]))
ans = []
for i in range(1, n):
ans.append(dp[i-1][t-1] + b[i])
print((max(ans))) | n, t = list(map(int, input().split()))
a, b, ab = [], [], []
for _ in range(n):
ab.append(tuple(map(int, input().split())))
ab.sort(key=lambda x:x[0])
for i in ab:
a.append(i[0])
b.append(i[1])
# dp[i][j] = 0~i番目の料理でj分以内に完食できる美味しさの合計の最大値
# 0 <= i <= n-1, 0 <= j <= t-1
dp = [[0 for _ in range(min([t, a[0]]))] + [b[0] for _ in range(t-a[0])]]
for i in range(1, n):
dp.append([])
for j in range(min([t, a[i]])):
dp[i].append(dp[i-1][j])
for j in range(a[i], t):
dp[i].append(max([dp[i-1][j], dp[i-1][j-a[i]]+b[i]]))
ans = []
for i in range(1, n):
ans.append(dp[i-1][t-1] + b[i])
print((max(ans))) | p02863 |
N, W = list(map(int, input().split()))
items = [list(map(int, input().split())) for i in range(N)]
# dp1[i][j] := 商品0 ~ i が対象
# dp2[i][j] := 商品i ~ N が対象(順番はそのまま)
# out-of-index 対策に余分に取っておく
dp1 = [[0] * (W + 1) for i in range(N + 2)]
dp2 = [[0] * (W + 1) for i in range(N + 2)]
# dp1を埋める
for i in range(N):
wi, vi = items[i]
for j in range(W + 1):
if j + wi <= W:
dp1[i + 1][j + wi] = max(dp1[i + 1][j + wi], dp1[i][j] + vi)
dp1[i + 1][j] = max(dp1[i][j], dp1[i + 1][j])
# dp2を埋める
for i in range(N + 1, 1, -1):
wi, vi = items[i - 2]
for j in range(W + 1):
if j + wi <= W:
dp2[i - 1][j + wi] = max(dp2[i - 1][j + wi], dp2[i][j] + vi)
dp2[i - 1][j] = max(dp2[i][j], dp2[i - 1][j])
# 2つのdpテーブルを使って、最後に使う商品を全探索
ans = 0
# ここからは商品を1-indexedとする
for i, (wi, vi) in enumerate(items, start=1):
for j in range(W):
ans = max(ans, dp1[i - 1][j] + dp2[i + 1][W - j - 1] + vi)
print(ans)
| N, W = list(map(int, input().split()))
items = sorted([list(map(int, input().split())) for i in range(N)])
# dp1[i][j] := 商品0 ~ i が対象
dp = [[0] * (W + 1) for i in range(N + 1)]
# dpテーブルを埋める
for i in range(N):
wi, vi = items[i]
for j in range(W + 1):
if j + wi <= W:
dp[i + 1][j + wi] = max(dp[i + 1][j + wi], dp[i][j] + vi)
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j])
ans = 0
for i, (wi, vi) in enumerate(items):
for j in range(W):
ans = max(ans, dp[i][j] + vi)
print(ans)
| p02863 |
N, W = list(map(int, input().split()))
items = sorted([list(map(int, input().split())) for i in range(N)])
# dp1[i][j] := 商品0 ~ i が対象
dp = [[0] * (W + 1) for i in range(N + 1)]
# dpテーブルを埋める
for i in range(N):
wi, vi = items[i]
for j in range(W + 1):
if j + wi <= W:
dp[i + 1][j + wi] = max(dp[i + 1][j + wi], dp[i][j] + vi)
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j])
ans = 0
for i, (wi, vi) in enumerate(items):
for j in range(W):
ans = max(ans, dp[i][j] + vi)
print(ans)
| N, W = list(map(int, input().split()))
items = sorted([list(map(int, input().split())) for i in range(N)])
# dp1[i][j] := 商品0 ~ i が対象
dp = [[0] * (W + 1) for i in range(N + 1)]
# dpテーブルを埋める
for i in range(N):
wi, vi = items[i]
for j in range(W + 1):
if j + wi <= W:
dp[i + 1][j + wi] = max(dp[i + 1][j + wi], dp[i][j] + vi)
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j])
ans = 0
for i, (wi, vi) in enumerate(items):
ans = max(ans, dp[i][W - 1] + vi)
print(ans)
| p02863 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
n,t = list(map(int,readline().split()))
f = []
m = 0
for i in range(n):
p,q = list(map(int,readline().split()))
m = max(m,p)
f.append((p,q))
f.sort()
dp = [[0]*(t+m) for i in range(n+1)]
for i,c in enumerate(f):
a,b = c
for j in range(t+m):
if j < a or j-a >= t:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j],dp[i][j-a]+b)
print((max(dp[n]))) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
n,t = list(map(int,readline().split()))
f = []
m = 0
for i in range(n):
p,q = list(map(int,readline().split()))
m = max(m,p)
f.append((p,q))
f.sort()
dp = [[0]*(t+m) for i in range(n+1)]
for i,c in enumerate(f):
a,b = c
for j in range(t+m):
if j-a >= t:
break
if j < a :
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j],dp[i][j-a]+b)
print((max(dp[n])))
| p02863 |
from sys import stdin
def main():
#入力
readline=stdin.readline
n,t=list(map(int,readline().split()))
li=[list(map(int,readline().split())) for _ in range(n)]
li.sort()
a=[0]*n
b=[0]*n
for i in range(n):
a[i],b[i]=li[i][0],li[i][1]
#ナップサックDP
inf=-float("inf")
dp=[[inf]*(t+1) for _ in range(n+1)]
dp[0][0]=0
for i in range(n):
for j in range(t+1):
#i番目を食べる
if j!=t:
dp[i+1][min(t,j+a[i])]=max(dp[i+1][min(t,j+a[i])],dp[i][j]+b[i])
#i番目を食べない
dp[i+1][j]=max(dp[i+1][j],dp[i][j])
print((max(dp[n])))
if __name__=="__main__":
main() | from sys import stdin
def main():
#入力
readline=stdin.readline
n,t=list(map(int,readline().split()))
li=[list(map(int,readline().split())) for _ in range(n)]
li.sort()
a=[0]*n
b=[0]*n
for i in range(n):
a[i],b[i]=li[i][0],li[i][1]
#ナップサックDP
inf=-10**9
dp=[[inf]*(t+1) for _ in range(n+1)]
dp[0][0]=0
for i in range(n):
for j in range(t+1):
#i番目を食べる
if j!=t:
dp[i+1][min(t,j+a[i])]=max(dp[i+1][min(t,j+a[i])],dp[i][j]+b[i])
#i番目を食べない
dp[i+1][j]=max(dp[i+1][j],dp[i][j])
print((max(dp[n])))
if __name__=="__main__":
main() | p02863 |
n,t=list(map(int,input().split()))
ab=[]
for i in range(n):
ab.append(list(map(int,input().split())))
ab_r=list(reversed(ab))
dp1=[[0 for j in range(t)] for i in range(n+1)]
dp2=[[0 for j in range(t)] for i in range(n+1)]
for i in range(n):
for j in range(t-1):
if ab[i][0] <= j:
dp1[i+1][j] = max(dp1[i][j],dp1[i][j-ab[i][0]]+ab[i][1])
else:
dp1[i+1][j] = dp1[i][j]
for i in range(n):
for j in range(t-1):
if ab_r[i][0] <= j:
dp2[i+1][j] = max(dp2[i][j],dp2[i][j-ab_r[i][0]]+ab_r[i][1])
else:
dp2[i+1][j] = dp2[i][j]
m=0
for i in range(1,n+1):
for j in range(t-1):
m=max(m,dp1[i-1][j]+dp2[n-i][t-1-j]+ab[i-1][1])
print(m)
| n,t=list(map(int,input().split()))
ab=[]
for i in range(n):
ab.append(list(map(int,input().split())))
ab_r=list(reversed(ab))
dp1=[[0 for j in range(t)] for i in range(n+1)]
dp2=[[0 for j in range(t)] for i in range(n+1)]
for i in range(n):
for j in range(t-1):
if ab[i][0] <= j:
dp1[i+1][j] = max(dp1[i][j],dp1[i][j-ab[i][0]]+ab[i][1])
else:
dp1[i+1][j] = dp1[i][j]
if ab_r[i][0] <= j:
dp2[i+1][j] = max(dp2[i][j],dp2[i][j-ab_r[i][0]]+ab_r[i][1])
else:
dp2[i+1][j] = dp2[i][j]
m=0
for i in range(1,n+1):
for j in range(t-1):
m=max(m,dp1[i-1][j]+dp2[n-i][t-1-j]+ab[i-1][1])
print(m)
| p02863 |
#16:25
n,t = list(map(int,input().split()))
wv = []
for _ in range(n):
wv.append(list(map(int,input().split())))
wv.sort(key=lambda x:x[0])
now = [0 for _ in range(t+1)]
for i in range(n):
w,v = wv[i]
last = now
now = []
for f in range(t):
if f >= w:
now.append(max(last[f-w]+v,last[f]))
else:
now.append(last[f])
now.append(max(last[-2]+v,last[-1]))
print((now[-1])) | n,t = list(map(int,input().split()))
dish = []
for _ in range(n):
a,b = list(map(int,input().split()))
dish.append([a,b])
dish.sort()
now = [0 for _ in range(t+1)]
for i in range(n):
a,b = dish[i]
for d in range(t)[::-1]:
if d + a < t:
now[d+a] = max(now[d+a],now[d]+b)
else:
now[-1] = max(now[-1],now[d]+b)
#print(now)
print((now[-1])) | p02863 |
import math
def main():
N, T = list(map(int, input().split()))
C = []
for _ in range(N):
A, B = list(map(int, input().split()))
C.append([B, A])
C.sort()
dp = [[0, 0] for _ in range(T)]
ans = 0
for i in range(T):
for j in range(N):
if (dp[i][1] >> j) % 2 == 0:
if i+C[j][1] > T-1:
ans = max(ans, dp[i][0] + C[j][0])
else:
if dp[i][0]+C[j][0] > dp[i+C[j][1]][0]:
dp[i+C[j][1]][0] = dp[i][0]+C[j][0]
dp[i+C[j][1]][1] = (1 << j) | dp[i][1]
for i in range(T):
ans = max(ans, dp[i][0])
return ans
if __name__ == '__main__':
print((main()))
| import math
def main():
N, T = list(map(int, input().split()))
C = []
for _ in range(N):
A, B = list(map(int, input().split()))
C.append([B, A])
# C.sort()
dp = [[0, 0] for _ in range(T)]
ans = 0
for i in range(T):
for j in range(N):
if (dp[i][1] >> j) % 2 == 0:
if i+C[j][1] > T-1:
ans = max(ans, dp[i][0] + C[j][0])
else:
if dp[i][0]+C[j][0] > dp[i+C[j][1]][0]:
dp[i+C[j][1]][0] = dp[i][0]+C[j][0]
dp[i+C[j][1]][1] = (1 << j) | dp[i][1]
# print(dp)
for i in range(T):
ans = max(ans, dp[i][0])
return ans
if __name__ == '__main__':
print((main())) | p02863 |
import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def S(): return sys.stdin.readline().rstrip()
N,T = list(map(int,S().split()))
A = [0]
B = [0]
for i in range(N):
a,b = LI()
A.append(a)
B.append(b)
dp1 = [[0]*(T+1) for i in range(N+1)]
# dp[i][j] = 1~i番目から選んでT分以内に食べるときの美味しさの和の最大値
dp2 = [[0]*(T+1) for i in range(N+2)]
# dp[i][j] = i~N番目から選んでT分以内に食べるときの美味しさの和の最大値
for i in range(1,N+1):
for j in range(T+1):
if j >= A[i]:
dp1[i][j] = max(dp1[i-1][j],dp1[i-1][j-A[i]]+B[i])
else:
dp1[i][j] = dp1[i-1][j]
for i in range(N,0,-1):
for j in range(T+1):
if j >= A[i]:
dp2[i][j] = max(dp2[i+1][j],dp2[i+1][j-A[i]]+B[i])
else:
dp2[i][j] = dp2[i+1][j]
ans = dp1[N][T]
for i in range(1,N+1): # 最後にi番目の料理を食べる
for j in range(T):
ans = max(ans,dp1[i-1][j]+dp2[i+1][T-1-j]+B[i])
print(ans) | def main():
import sys
def LI():
return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり
def S():
return sys.stdin.readline().rstrip()
N, T = list(map(int, S().split()))
A = [0]
B = [0]
for i in range(N):
a, b = LI()
A.append(a)
B.append(b)
dp1 = [[0] * (T + 1) for i in range(N + 1)]
# dp1[i][j] = 1~i番目から選んでT分以内に食べるときの美味しさの和の最大値
dp2 = [[0] * (T + 1) for i in range(N + 2)]
# dp2[i][j] = i~N番目から選んでT分以内に食べるときの美味しさの和の最大値
for i in range(1, N + 1):
for j in range(T + 1):
if j >= A[i]:
dp1[i][j] = max(dp1[i - 1][j], dp1[i - 1][j - A[i]] + B[i])
else:
dp1[i][j] = dp1[i - 1][j]
for i in range(N, 0, -1):
for j in range(T + 1):
if j >= A[i]:
dp2[i][j] = max(dp2[i + 1][j], dp2[i + 1][j - A[i]] + B[i])
else:
dp2[i][j] = dp2[i + 1][j]
ans = dp1[N][T]
for i in range(1, N + 1): # 最後にi番目の料理を食べる
for j in range(T):
ans = max(ans, dp1[i - 1][j] + dp2[i + 1][T - 1 - j] + B[i])
print(ans)
if __name__ == '__main__':
main() | p02863 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.