input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
n=int(eval(input()))
cnt=0
while True:
cnt+=1
if n<=1000*cnt:
print((1000*cnt-n))
break
resolve()
|
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
n=int(eval(input()))
print((0 if n%1000==0 else 1000-(n%1000)))
resolve()
|
p02612
|
import sys
n = int((eval(input())))
if n%1000 == 0:
print((0))
else:
while n > 1000:
n -= 1000
print((1000-n))
|
import sys
n = int((eval(input())))
if n%1000 == 0:
print((0))
else:
for i in range(10):
if n < 1000:
print((1000-n))
sys.exit()
else:
n -= 1000
|
p02612
|
(r, c) = [int(i) for i in input().split()]
ct = [0 for d in range(c)]
tmp = []
for rc in range(r):
tmp = [int(i) for i in input().split()]
total = 0
for cc in range(c):
ct[cc] += tmp[cc]
total += tmp[cc]
print(tmp[cc], end=' ')
print(total)
total = sum(ct)
print(' '.join([str(i) for i in ct]), total)
|
(r, c) = [int(i) for i in input().split()]
table = []
for rc in range(r):
table.append([int(i) for i in input().split()])
table.append([0 for _ in range(c + 1)])
for rc in range(r):
row_total = 0
for cc in range(c):
table[r][cc] += table[rc][cc]
row_total += table[rc][cc]
table[rc].append(row_total)
table[r][c] += row_total
for row in table:
print((' '.join([str(column) for column in row])))
|
p02413
|
(r, c) = [int(i) for i in input().split()]
ct = [0 for d in range(c)]
tmp = []
for rc in range(r):
tmp = [int(i) for i in input().split()]
total = 0
for cc in range(c):
ct[cc] += tmp[cc]
total += tmp[cc]
print(tmp[cc], end=' ')
print(total)
total = sum(ct)
print(' '.join([str(i) for i in ct]), total)
|
(r, c) = [int(i) for i in input().split()]
last_row = [0 for _ in range(c+1)]
for _ in range(r):
row = [int(i) for i in input().split()]
for cc in range(c):
last_row[cc] += int(row[cc])
print(row[cc], end=' ')
print(sum(row))
last_row[-1] = sum(last_row)
print(' '.join([str(a) for a in last_row]))
|
p02413
|
r, c = list(map(int, input().split(' ')))
matrix = []
total_cols = [0 for i in range(c+1)]
for i in range(r):
rows = list(map(int, input().split(' ')));
total = sum(rows)
rows.append(total)
total_cols = [ total_cols[i] + x for i, x in enumerate(rows) ]
matrix.append(rows)
matrix.append(total_cols)
for row in matrix:
print((' '.join([str(i) for i in row])))
|
def main():
r, c = [int(x) for x in input().split()]
matrix = []
totals = [0 for _ in range(c+1)]
for _ in range(r):
nums = [int(x) for x in input().split()]
total = sum(nums)
row = nums + [total]
matrix.append(row)
for i in range(c+1):
totals[i] += row[i]
matrix.append(totals)
for m in matrix:
print((" ".join([str(x) for x in m])))
if __name__ == '__main__':
main()
|
p02413
|
(r,c) = [int(i) for i in input().split()]
table = []
for rc in range(r):
table.append([int(i) for i in input().split()])
table.append([0 for _ in range(c + 1)])
for rc in range(r):
row_total = 0
for cc in range(c):
table[r][cc] += table[rc][cc]
row_total += table[rc][cc]
table[rc].append(row_total)
table[r][c] += row_total
for row in table:
print((' '.join([str(column) for column in row])))
|
(r, c) = [int(i) for i in input().split()]
last_row = [0 for _ in range(c+1)]
for _ in range(r):
row = [int(i) for i in input().split()]
for cc in range(c):
last_row[cc] += int(row[cc])
print(row[cc], end=' ')
print(sum(row))
last_row[-1] = sum(last_row)
print(' '.join([str(a) for a in last_row]))
|
p02413
|
h, w = [int(i) for i in input().split()]
date = [[int(q) for q in input().split()] for e in range(h)]
date2=[]
date3=[]
for r in range(0, h):
for t in range(0, w):
print(date[r][t], end=' ')
print(sum(date[r]))
for k in range(0,w):
for j in range(0,h):
date2.append(date[j][k])
for n in range(0,w*h,h):
print(sum(date2[n:(n+h)]),end=' ')
for m in range(h):
date3.append(sum(date[m]))
print(sum(date3))
|
r, c =[int(i) for i in input().split()]
date =[]
sum_row = [0] * (c + 1)
for ri in range(r):
date.append([int(i) for i in input().split()])
date[ri].append(sum(date[ri]))
print((" ".join([str(d) for d in date[ri]])))
for ci in range(c + 1):
sum_row[ci] += date[ri][ci]
print((" ".join([str(s) for s in sum_row])))
|
p02413
|
r, c = map(int, input().split())
a = [[0 for i in range(c+1)] for j in range(r+1)]
for i in range(r):
l = list(map(int, input().split()))
for j in range(c):
a[i][j] = l[j]
a[i][c] += a[i][j]
for i in range(c+1):
for j in range(r):
a[r][i] += a[j][i]
for i in range(r+1):
for j in range(c+1):
if j == c:
print(str(a[i][j]))
else:
print(str(a[i][j]) + " ", end="")
|
r, c = map(int, input().split())
a = [[int(i) for i in input().split()] for j in range(r)]
b = [[0 for i in range(c+1)] for j in range(r+1)]
for i in range(r):
for j in range(c):
b[i][j] = a[i][j]
b[i][c] += a[i][j]
for i in range(c+1):
for j in range(r):
b[r][i] += b[j][i]
for i in range(r+1):
for j in range(c+1):
if j == c:
print(b[i][j])
else:
print("{0} ".format(b[i][j]), end = "")
|
p02413
|
r,c=map(int,input().split())
a,b=[],[0]*c
for i in range(r):
x=list(map(int,input().split()))
print(*x, end=' ')
print(sum(x))
for j in range(c):
b[j]+=x[j]
print(*b, end=' ')
print(sum(b))
|
r,c=map(int,input().split())
a=[0]*c
for i in range(r):
x=list(map(int,input().split()))
for j in range(c):
a[j]+=x[j]
print(*x, end=' ')
print(sum(x))
print(*a, end=' ')
print(sum(a))
|
p02413
|
m,n=map(int,input().split())
a =[]
for _ in range(m):
a.append(list(map(int,input().split())))
for index in range(m):
a[index].append(sum(a[index]))
for a_column in a:
for num in a_column[:-1]:
print(num, end=' ')
print(a_column[-1])
for row_index in range(n):
sum = 0
for a_column in a:
sum += a_column[row_index]
print(sum, end=' ')
sum = 0
for a_column in a:
sum += a_column[-1]
print(sum)
|
m,n=list(map(int,input().split()))
a =[]
for _ in range(m):
a.append(list(map(int,input().split())))
for index in range(m):
a[index].append(sum(a[index]))
for a_column in a:
print((' '.join(map(str, a_column))))
a.append([0]*(n+1))
for row_index in range(n+1):
for a_column in a[:-1]:
a[-1][row_index] += a_column[row_index]
print((' '.join(map(str, a[-1]))))
|
p02413
|
N,M = list(map(int,input().split()))
table = [1,1]
while len(table) <= N:
temp = table[0]
for i in range(len(table)-1):
table[i+1] += temp
temp = table[i+1]- temp
table[i+1] %= M
table.append(1)
S = [1]
rev2 = pow(2, M-2, M)
base = pow(2, N, M)
ans = 0
S = [1]
for K in range(N+1):
res = table[K] % M
res = (res * pow(2, pow(2, N - K, M-1), M)) % M
b = 1
v = 0
T = [0]*(K+2)
for L in range(K):
T[L+1] = s = (S[L] + (L+1)*S[L+1]) % M
v += s * b
b = (b * base) % M
v += b
T[K+1] = 1
S = T
res = (res * v) % M
if K % 2:
ans -= res
else:
ans += res
ans %= M
base = (base * rev2) % M
print(ans)
|
N, M = list(map(int, input().split()))
fact = [1]*(N+1)
rfact = [1]*(N+1)
for i in range(1, N+1):
fact[i] = r = (i * fact[i-1]) % M
rfact[i] = pow(r, M-2, M)
S = [1]
rev2 = pow(2, M-2, M)
base = pow(2, N, M)
ans = 0
S = [1]
for K in range(N+1):
res = (fact[N] * rfact[K] * rfact[N-K]) % M
res = (res * pow(2, pow(2, N - K, M-1), M)) % M
b = 1
v = 0
T = [0]*(K+2)
for L in range(K):
T[L+1] = s = (S[L] + (L+1)*S[L+1]) % M
v += s * b
b = (b * base) % M
v += b
T[K+1] = 1
S = T
res = (res * v) % M
if K % 2:
ans -= res
else:
ans += res
ans %= M
base = (base * rev2) % M
print(ans)
|
p03375
|
while True:
n = int(eval(input()))
if n == 0:
break
wlst = list(map(int, input().split()))
dp = [[0] * n for _ in range(n + 1)]
def check(left1, right1, left2, right2, cnt):
if left1 > right1 and left2 > right2: return cnt
if left1 > right1:return dp[right2 - left2 + 1][left2] + cnt
if left2 > right2:return dp[right1 - left1 + 1][left1] + cnt
ret = cnt + dp[right1 - left1 + 1][left1] + dp[right2 - left2 + 1][left2]
if abs(wlst[right1] - wlst[left2]) <= 1:
ret = max(ret, check(left1, right1 - 1, left2 + 1, right2, cnt + 1))
if right1 - left1 + 1 >= 2 and dp[2][right1 - 1]:
ret = max(ret, check(left1, right1 - 2, left2, right2, cnt + 1))
if right2 - left2 + 1 >= 2 and dp[2][left2]:
ret = max(ret, check(left1, right1, left2 + 2, right2, cnt + 1))
return ret
for length in range(2, n + 1):
for left in range(n - length + 1):
for k in range(length - 1):
dp[length][left] = max(dp[length][left], check(left, left + k, left + k + 1, left + length - 1, 0))
print((dp[n][0] * 2))
|
def main():
while True:
n = int(eval(input()))
if n == 0:
break
wlst = list(map(int, input().split()))
connect = [[None] * n for _ in range(n)]
for i in range(n):
for j in range(n):
connect[i][j] = abs(wlst[i] - wlst[j]) <= 1
max_lst = [[False] * (n + 1) for _ in range(n + 1)]
for i in range(n + 1):
max_lst[0][i] = True
dp = [[0] * n for _ in range(n + 1)]
def check(length, left):
ret = dp[length - 1][left]
for k in range(length - 1, 0, -2):
if not max_lst[length - k - 1][left + k]:continue
if connect[left + k - 1][left + length - 1]:
temp = length - k + 1 + dp[k - 1][left]
if ret < temp:
ret = temp
return ret
for length in range(2, n + 1):
for left in range(n - length + 1):
dp[length][left] = check(length, left)
if dp[length][left] == length:
max_lst[length][left] = True
print((dp[n][0]))
main()
|
p01096
|
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f(n):
a = LI()
m = {}
def _f(a):
l = len(a)
if l < 2:
return 0
k = tuple(a)
if k in m:
return m[k]
r = 0
for i in range(len(a)-1):
if abs(a[i]-a[i+1]) >= 2:
continue
t = _f(a[:i] + a[i+2:]) + 2
if r < t:
r = t
m[k] = r
return r
return _f(a)
while True:
n = I()
if n == 0:
break
rr.append(f(n))
return '\n'.join(map(str, rr))
print(main())
|
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f(n):
a = LI()
l = len(a)
s = set()
r = 0
for i in range(l-1):
if abs(a[i] - a[i+1]) < 2:
s.add((i,i+1))
for i in range(4, l+1):
for j in range(l-i+1):
k = j + i - 1
if (j+1, k-1) in s and abs(a[j] - a[k]) < 2:
s.add((j,k))
continue
for m in range(j+2,k,2):
if (j,m-1) in s and (m,k) in s:
s.add((j,k))
break
m = {}
m[l] = 0
def _f(i):
if i in m:
return m[i]
r = 0
for j in range(i,l+1):
t = _f(j+1)
if (i,j) in s:
t += j - i + 1
if r < t:
r = t
m[i] = r
return r
return _f(0)
while True:
n = I()
if n == 0:
break
rr.append(f(n))
return '\n'.join(map(str, rr))
print(main())
|
p01096
|
def cmb(n,r,mod):
if r<0 or r>n:
return 0
r=min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
l=[]
l2=[]
for i in range(n):
l.append([a[i],i])
l.sort()
for i in range(n):
l2.append([l[i][1],i])
l2.sort()
mod=10**9+7
g1=[1,1]
g2=[1,1]
inverse=[0,1]
for i in range(2,n+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
ans=0
for i in range(n):
ans+=a[i]*cmb(l2[i][1],k-1,mod)
ans%=mod
for i in range(n):
ans-=a[i]*cmb(n-l2[i][1]-1,k-1,mod)
ans+=mod
ans%=mod
print(ans)
|
def cmb(n,r,mod):
if r<0 or r>n:
return 0
r=min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
mod=10**9+7
g1=[1,1]
g2=[1,1]
inverse=[0,1]
for i in range(2,n+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
ans=0
for i in range(n):
ans+=a[i]*cmb(i,k-1,mod)
ans%=mod
for i in range(n):
ans-=a[i]*cmb(n-i-1,k-1,mod)
ans+=mod
ans%=mod
print(ans)
|
p02804
|
#!/usr/bin/env python3
import sys
MOD = 1000000007 # type: int
from itertools import accumulate
def mod_factorial(n):
value = 1
for i in range(n,0,-1):
value*=i
value%=MOD
return value
def solve(N: int, K: int, A: "List[int]"):
A.sort()
n = N-1
r = K-1
# nCkTable[i] = iCr
nCkTable = [0]*(n+1)
start = 1
for _ in range(r):
start *= n
start %= MOD
n -= 1
bunbo = mod_factorial(r)
bunbo_gyakugen = pow(bunbo,MOD-2,MOD)
n = N-1
for i in range(n, r-1, -1):
nCkTable[i] = start*bunbo_gyakugen%MOD
start*=pow(i,MOD-2,MOD)
start*=i-r
answer = 0
for i in range(N):
answer += A[i]*(nCkTable[i]-nCkTable[N-1-i])
answer%=MOD
print((answer%MOD))
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
K = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, K, A)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
MOD = 1000000007 # type: int
from itertools import accumulate
def mod_factorial(n):
value = 1
for i in range(n,0,-1):
value*=i
value%=MOD
return value
def solve(N: int, K: int, A: "List[int]"):
A.sort()
n = N-1
r = K-1
# nCkTable[i] = iCr
nCkTable = [0]*(n+1)
start = 1
for _ in range(r):
start *= n
start %= MOD
n -= 1
bunbo = mod_factorial(r)
bunbo_gyakugen = pow(bunbo,MOD-2,MOD)
n = N-1
for i in range(n, r-1, -1):
nCkTable[i] = start*bunbo_gyakugen%MOD
start*=pow(i,MOD-2,MOD)
start*=i-r
start%=MOD
answer = 0
for i in range(N):
answer += A[i]*(nCkTable[i]-nCkTable[N-1-i])
answer%=MOD
print((answer%MOD))
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
K = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, K, A)
if __name__ == '__main__':
main()
|
p02804
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A)
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
p = 1000000007
ans = 0
for i in range(N- K +1):
ans += ((A[N-1-i] - A[i])*comb(N-1-i, K-1, p))
ans = ans % p
print(ans)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A = sorted(A)
p = 1000000007
frac = [1]
for i in range(N):
frac.append(frac[i]*(i+1)%p)
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=frac[n]
b=frac[k]
c=frac[n-k]
return (a * power(b, mod-2, mod) * power(c, mod-2, mod)) % mod
ans = 0
for i in range(N- K +1):
ans += ((A[N-1-i] - A[i])*comb(N-1-i, K-1, p))
ans = ans % p
print(ans)
|
p02804
|
def nCr(n,r):
if n < 0 or r < 0 or n < r: return 0
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
# 分子のn*(n-1)*...がr個分続くやつ
numerator = [n-r+k+1 for k in range(r)]
# 分母：r!=r*(r-1)*...*3*2の要素
denominator = [k+1 for k in range(r)]
# 分母の要素で割れる部分を割っていく部分
for p in range(2, r+1):
# 分母は1,2,3,...rのようになっており、1は意味がないのでスキップした形か
pivot = denominator[p-1]
if pivot > 1:
# 分子のX番目と分母のX-offset番目が共通の約数を持つということだと思う。piv分ずれているのだから、pivの倍数というところか
offset = (n-r) % p
for k in range(p-1, r, p):
# 約分できる要素について割る
numerator[k - offset] /= pivot
denominator[k] /= pivot
ret = 1
for k in range(r):
if numerator[k] > 1: ret *= int(numerator[k])
return ret
N,K = list(map(int, input().split()))
MOD = 10**9+7
A = list(map(int, input().split()))
A.sort()
if N == 1 or K == 1:
print((0))
exit()
# A_iがminに選ばれる回数と、maxに選ばれる回数それぞれをわけて考えて足していく
ans = 0
for i in range(N):
# minになれるのは、iの右からK-1個選べる場合
if N - (i+1) >= K-1:
ans -= A[i] * nCr(N - (i+1), K-1) % MOD
# maxになれるのは、iの左からK-1個選べる場合
if i >= K-1:
ans += A[i] * nCr(i, K-1) % MOD
ans %= MOD
print(ans)
|
N,K = list(map(int, input().split()))
MOD = 10**9+7
A = list(map(int, input().split()))
A.sort()
if N == 1 or K == 1:
print((0))
exit()
def nCr(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
# nCr = n! / (r! * (n-r)!)
return fact[n] * factinv[r] * factinv[n-r] % p
p = MOD
#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):
# (a * b * c) % MOD = (a * b % MOD) * c % MOD みたいなやつを利用して、大きな値にならないように一ステップごとにMODをとる
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
# A_iがminに選ばれる回数と、maxに選ばれる回数それぞれをわけて考えて足していく
ans = 0
for i in range(N):
# minになれるのは、iの右からK-1個選べる場合
if N - (i+1) >= K-1:
ans -= A[i] * nCr(N - (i+1), K-1, MOD)
# maxになれるのは、iの左からK-1個選べる場合
if i >= K-1:
ans += A[i] * nCr(i, K-1, MOD)
ans %= MOD
print(ans)
|
p02804
|
n,k=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
mod=10**9+7
ans=0
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
for i in range(n-k+1):
ans-=a[i]*cmb(n-i-1,k-1)%mod
ans%=mod
a=a[::-1]
for i in range(n-k+1):
ans+=a[i]*cmb(n-i-1,k-1)%mod
ans%=mod
print((ans%mod))
|
n,k=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
mod=10**9+7
ans=0
MOD=10**9+7
factorial = [1]
inverse = [1]
for i in range(1, n+2):
factorial.append(factorial[-1] * i % MOD)
inverse.append(pow(factorial[-1], MOD - 2, MOD))
# 組み合わせ計算
def nCr(n, r):
if n < r or r < 0:
return 0
elif r == 0:
return 1
return factorial[n] * inverse[r] * inverse[n - r] % MOD
for i in range(n-k+1):
ans-=a[i]*nCr(n-i-1,k-1)%mod
ans%=mod
a=a[::-1]
for i in range(n-k+1):
ans+=a[i]*nCr(n-i-1,k-1)%mod
ans%=mod
print((ans%mod))
|
p02804
|
# modulo:mod
# inverse x^(-1)
def inv(x):
global mod
return pow(x,mod-2,mod)
# factorial x!
def fact(x):
global mod
res=1
for i in range(2,x+1):
res=res*i%mod
return res
# combination nCr
def combi(n,r):
if r<0 or r>n:
return 0
else:
return fact(n)*inv(fact(r))*inv(fact(n-r))%mod
mod=10**9+7
N,K=list(map(int,input().split()))
A=[-10**10] # 1-ind
A.extend(list(map(int,input().split())))
A.sort()
# print(A)
ans=0
# min
for i in range(1,N-K+2):
temp=combi(N-i,K-1)%mod
'''
print(i,A[i])
print(N-i,K-1)
print('min',temp)
'''
ans=(ans-temp*A[i])%mod
# max
for j in range(K,N+1):
temp=combi(j-1,K-1)
'''
print(j)
print(j-1,K-1)
print('max',temp*A[j])
'''
ans=(ans+temp*A[j])%mod
print(ans)
|
# modulo:mod
# inverse x^(-1)
def inv(x):
global mod
return pow(x,mod-2,mod)
# factorial x!
def fact(x):
global mod
res=1
for i in range(2,x+1):
res=res*i%mod
return res
# combination nCr
def combi(n,r):
if r<0 or r>n:
return 0
else:
return fact(n)*inv(fact(r))*inv(fact(n-r))%mod
mod=10**9+7
N,K=list(map(int,input().split()))
A=[-10**10] # 1-ind
A.extend(list(map(int,input().split())))
A.sort()
# print(A)
ans=0
# min
p=1
for i in range(N-K+1,0,-1):
# print(i,A[i],p)
temp=A[i]*p%mod
ans=(ans-temp)%mod
# print((N-i+1)*inv(N-K-i+2))
p=p*(N-i+1)*inv(N-K-i+2)%mod
# max
p=1
for j in range(K,N+1):
# print(j,A[j],p)
temp=A[j]*p%mod
ans=(ans+temp)%mod
p=p*j*inv(j-K+1)%mod
print(ans)
|
p02804
|
import sys
input = sys.stdin.readline
def inv(x):
return pow(x, MOD-2, MOD)
def C(n, r):
if r>n:
return 0
#return fact[n]//fact[r]//fact[n-r]
#return fact[n]*inv(fact[r])*inv(fact[n-r])
return fact[n]*inv_table[r]*inv_table[n-r]
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
MOD = 10**9+7
if K==1:
print((0))
exit()
fact = [1]
for i in range(1, N+1):
fact.append(fact[-1]*i%MOD)
#fact.append(fact[-1]*i)
inv_table = [-1]*(N+1)
for i in range(N+1):
inv_table[i] = inv(fact[i])
ans = 0
c_acc = [0]
for i in range(N+1):
c_acc.append((c_acc[-1]+C(i, K-2))%MOD)
for i in range(N):
left = c_acc[i]-c_acc[0]
right = c_acc[N-i-1]-c_acc[0]
#print(left, right)
ans += A[i]*(left-right)
ans %= MOD
print(ans)
|
def inv(x):
return pow(x, MOD-2, MOD)
def C(n, r):
if r>n:
return 0
return fact[n]*inv_table[r]*inv_table[n-r]
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
ans = 0
MOD = 10**9+7
fact = [1]
for i in range(1, N+1):
fact.append(fact[-1]*i%MOD)
inv_table = [-1]*(N+1)
for i in range(N+1):
inv_table[i] = inv(fact[i])
for i in range(N):
ans += A[i]*(C(i, K-1)-C(N-i-1, K-1))
ans %= MOD
print(ans)
|
p02804
|
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K = mapint()
from collections import Counter
As = list(mapint())
count = Counter(As)
mod = 10**9+7
maxi = 0
cum = 0
pos = {}
neg = {}
pos[0] = 1
neg[0] = 1
As = sorted(list(set(As)))
for i in range(1, 10**5+5):
pos[i] = pos[i-1]*i%mod
neg[i] = pow(pos[i], mod-2, mod)
for a in As:
cum += count[a]
if cum<K:
continue
for i in range(1, min(K, count[a])+1):
if cum-count[a]-K+i<0: continue
maxi += a*pos[count[a]]*neg[i]*neg[count[a]-i]*pos[cum-count[a]]*neg[K-i]*neg[cum-count[a]-K+i]
maxi %= mod
mini = 0
cum = 0
for a in As[::-1]:
cum += count[a]
if cum<K:
continue
for i in range(1, min(K, count[a])+1):
if cum-count[a]-K+i<0: continue
mini += a*pos[count[a]]*neg[i]*neg[count[a]-i]*pos[cum-count[a]]*neg[K-i]*neg[cum-count[a]-K+i]
mini %= mod
print(((maxi-mini)%mod))
|
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, K = mapint()
As = list(mapint())
mod = 10**9+7
As.sort()
pos = {}
neg = {}
pos[0] = 1
neg[0] = 1
for i in range(1, 10**5+3):
pos[i] = (pos[i-1]*i)%mod
neg[i] = pow(pos[i], mod-2, mod)
mini = 0
maxi = 0
for i, a in enumerate(As):
if i<=N-K:
mini += a*pos[(N-i-1)]*neg[K-1]*neg[N-i-K]
mini %= mod
if i>=K-1:
maxi += a*pos[i]*neg[K-1]*neg[i-K+1]
maxi %= mod
print(((maxi-mini)%mod))
|
p02804
|
n,k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
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
ans=0
mod = 10**9+7
a=a[::-1]
for i in range(n-k+1):
ans += (a[i] * comb(n-i-1, k-1, mod))%mod
a=a[::-1]
for i in range(n-k+1):
ans -= (a[i] * comb(n-i-1, k-1, mod))%mod
print((ans%mod))
|
n,k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
ans=0
mod = 10**9+7
factorial = [1]
inverse = [1]
for i in range(1, n+2):
factorial.append(factorial[-1] * i % mod)
inverse.append(pow(factorial[-1], mod - 2, mod))
def comb(n, r, mod):
if n < r or r < 0:
return 0
elif r == 0:
return 1
return factorial[n] * inverse[r] * inverse[n - r] % mod
a=a[::-1]
for i in range(n-k+1):
ans += (a[i] * comb(n-i-1, k-1, mod))%mod
a=a[::-1]
for i in range(n-k+1):
ans -= (a[i] * comb(n-i-1, k-1, mod))%mod
print((ans%mod))
|
p02804
|
from collections import deque
N, K = list(map(int, input().split()))
A = [int(x) for x in input().split()]
A = sorted(A)
B = deque()
C = deque()
mod = (10**9)+7
for h in range(N):
B.append(A[h])
C.append(A[h])
def cmb(n, r): # 【Python】組み合わせ(nCr) 計算の高速化より引用
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
N_cmb = 10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for ZZZ in range(2, N_cmb + 1):
g1.append((g1[-1] * ZZZ) % mod)
inverse.append((-inverse[mod % ZZZ] * (mod//ZZZ)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
ans = 0
for i in range(N):
if N - i >= K:
kari = cmb(N - i - 1, K-1) % mod
# print(kari)
ans += (kari * B.pop()) % mod
ans -= (kari * C.popleft()) % mod
ans = ans % mod
print(ans)
|
from collections import deque
N, K = list(map(int, input().split()))
A = [int(x) for x in input().split()]
A = sorted(A)
B = deque()
C = deque()
mod = (10**9)+7
for h in range(N):
B.append(A[h])
C.append(A[h])
def cmb(n, r): # 【Python】組み合わせ(nCr) 計算の高速化より引用
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return fac[n] * finv[r] * finv[n-r] % mod
N_cmb = 10**5 # 入力の制約によって変えるところ、nCrの計算で欲しいnの最大値
fac = [1, 1] # 階乗テーブル
finv = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for ZZZ in range(2, N_cmb + 1):
fac.append((fac[-1] * ZZZ) % mod)
inverse.append(mod-inverse[mod % ZZZ]*(mod//ZZZ) % mod)
finv.append((finv[-1] * inverse[-1]) % mod)
ans = 0
for i in range(N):
if N - i >= K:
kari = cmb(N - i - 1, K-1) % mod
# print(kari)
ans += (kari * B.pop()) % mod
ans -= (kari * C.popleft()) % mod
ans = ans % mod
print(ans)
|
p02804
|
N, K=(int(i) for i in input().split())
A=[int(i) for i in input().split()]
A= sorted(A)
from math import factorial
inf=10**9+7
ans=0
for i in range(K, N+1):
#(N-1)C(K-1)
ans+=(A[i-1]*factorial(i-1) // factorial(K-1) // factorial(i-1-K+1))%inf
for i in range(1, N-K+2):
#(N-i)C(K-1)
ans-=(A[i-1]*factorial(N-i) // factorial(K-1) // factorial(N-i-K+1))%inf
print((ans%inf))
|
N, K=(int(i) for i in input().split())
A=[int(i) for i in input().split()]
A= sorted(A)
from math import factorial
inf=10**9+7
ans=0
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
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)
for i in range(K, N+1):
#(N-1)C(K-1)
ans+=(A[i-1]*cmb(i-1, K-1,p))%inf
for i in range(1, N-K+2):
#(N-i)C(K-1)
ans-=(A[i-1]*cmb(N-i, K-1,p))%inf
print((ans%inf))
|
p02804
|
def main():
def modinv(a, mod=10**9+7):
return pow(a, mod-2, mod)
def comb(n, r, mod=10**9+7):
r = min(r, n-r)
res = 1
for i in range(r):
res = res * (n - i) * modinv(i+1, mod) % mod
return res
import sys
input = sys.stdin.readline
mod = 10**9+7
n,k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a = sorted(a)
a = tuple(a)
ans = 0
for i in range(0,n-k+1):
p = a[i]*comb(n-1-i,k-1,mod)
ans -= (p%mod)
ans %= mod
for i in range(k-1,n):
q = a[i]*comb(i,k-1,mod)
ans += (q%mod)
ans %= mod
print(ans)
if __name__ == '__main__':
main()
|
def make_array_for_comb(N, mod=10**9+7):
fact = [1,1]
fact_inv = [1,1]
inv = [0,1]
for i in range(2, N+1):
fact.append((fact[-1]*i) % mod)
# モジュラ逆数の性質
inv.append((-inv[mod%i] * (mod//i)) % mod)
fact_inv.append((fact_inv[-1]*inv[i]) % mod)
return fact, fact_inv
def comb(n, r, mod=10**9+7):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * fact_inv[r] * fact_inv[n-r] % mod
import sys
input = sys.stdin.readline
mod = 10**9+7
n,k = [int(i) for i in input().split()]
fact, fact_inv = make_array_for_comb(n,mod)
a = [int(i) for i in input().split()]
a = sorted(a)
a = tuple(a)
ans = 0
for i in range(0,n-k+1):
p = a[i]*comb(n-1-i,k-1,mod)
ans -= (p%mod)
ans %= mod
for i in range(k-1,n):
q = a[i]*comb(i,k-1,mod)
ans += (q%mod)
ans %= mod
print(ans)
|
p02804
|
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
MOD = 1000000007
def pow(x, y):
if y == 0:
return 1
ans = 1
while y > 1:
if y % 2 != 0:
ans *= x
ans %= MOD
x *= x
x %= MOD
y //= 2
return ans * x % MOD
def mod_inv(x):
return pow(x, MOD - 2)
ans = 0
xCk_1 = {}
for i in range(k - 1, n):
if i == k - 1:
xCk_1[i] = 1
else:
xCk_1[i] = i * xCk_1[i - 1] * mod_inv(i - k + 1)
ans += ((a[i] - a[n - i - 1]) % MOD) * xCk_1[i]
ans %= MOD
print(ans)
|
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
MOD = 1000000007
def pow(x, y):
if y == 0:
return 1
ans = 1
while y > 1:
if y % 2 != 0:
ans *= x
ans %= MOD
x *= x
x %= MOD
y //= 2
return ans * x % MOD
def mod_inv(x):
return pow(x, MOD - 2)
ans = 0
xCk_1 = {}
for i in range(k - 1, n):
if i == k - 1:
xCk_1[i] = 1
else:
xCk_1[i] = (((i * xCk_1[i - 1]) % MOD) * mod_inv(i - k + 1)) % MOD
ans += ((a[i] - a[n - i - 1]) % MOD) * xCk_1[i]
ans %= MOD
print(ans)
|
p02804
|
# https://atcoder.jp/contests/abc151/tasks/abc151_e
def calc(x,y):
a = fac[x]
b = fac[y]
c = fac[x-y]
ret = ( (a%p)*pow(b,p-2,p)*pow(c,p-2,p))%p
return ret
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
p=10**9+7
fac=[1]
for i in range(1,N+1):
fac.append( (fac[-1]*i)%p )
#print(fac)
ans=0
for L in range(N-K+1):
for R in range(L+K-1,N):
if L==R:
tmp=0
diff=0
#print(L,R,diff)
elif L+(K-1)==R:
diff= A[R]-A[L]
ans += diff
#print(L,R,diff)
else:
tmp = calc(R-L-1,K-2)
diff= tmp*(A[R]-A[L])
ans += diff
#print(L,R,diff)
ans %=p
print(ans)
|
# https://atcoder.jp/contests/abc151/tasks/abc151_e
def calc(x,y):
a = fac[x]
b = fac[y]
c = fac[x-y]
ret = ( (a%p)*pow(b,p-2,p)*pow(c,p-2,p))%p
return ret
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
p=10**9+7
fac=[1]
for i in range(1,N+1):
fac.append( (fac[-1]*i)%p )
#print(fac)
ans=0
for i in range(N):
if i<=N-K:
nokori = N-1-i
kumi = calc(nokori,K-1)
ans -= (A[i]*kumi)%p
if i>=K-1:
nokori = i
kumi = calc(nokori,K-1)
ans += (A[i]*kumi)%p
print((ans%p))
#for L in range(N-K+1):
# for R in range(L+K-1,N):
# if L==R:
# tmp=0
# diff=0
# #print(L,R,diff)
# elif L+(K-1)==R:
# diff= A[R]-A[L]
# ans += diff
# #print(L,R,diff)
# else:
# tmp = calc(R-L-1,K-2)
# diff= tmp*(A[R]-A[L])
# ans += diff
# #print(L,R,diff)
# ans %=p
|
p02804
|
import math
def combinations_count(n, r):
a = 1
b = 1
if (n != 0) & (n >= r):
for i in range(n, n - r, -1):
a *= i
b *= i - n + r
return a // b
else:
return 0
n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
a.sort()
mod = 10 ** 9 + 7
ans = 0
for index, value in enumerate(a):
ans += (combinations_count(index, k - 1) - combinations_count(n - index - 1, k - 1)) * value % mod
print((ans % mod))
|
n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
a.sort()
mod = 10 ** 9 + 7
ans = 0
f = [1] * (n + 1)
inv = [1] * (n + 1)
for i in range(1, n + 1):
f[i] = (f[i - 1] * i) % (mod)
inv[n] = pow(f[n], mod - 2, mod)
for i in range(n - 1, 0, -1):
inv[i] = inv[i + 1] * (i + 1) % mod
def combination(n, r):
if (n != 0) & (n >= r):
return f[n] * inv[r] * inv[n - r] % mod
return 0
ans = 0
for index, value in enumerate(a):
ans += (combination(index, k - 1) - combination(n - index - 1, k - 1)) * value
print((ans % mod))
|
p02804
|
import math
def comb(n,r,m):
if r == 0: return 1
return math.factorial(n)*pow(f,m-2,m)*pow(math.factorial(n-r),m-2,m)
N,K,*a = list(map(int, open(0).read().split()))
m = 1000000007
f = math.factorial(K-1)
a.sort()
ans = 0
if K == 1:
print((0))
else:
for i in range(1,N-K+2):
ans = (ans + a[-i] * comb(N-i,K-1,m)) % m
for i in range(1,N-K+2):
ans = (ans - a[i-1] * comb(N-i,K-1,m)) % m
print(ans)
|
def memfact(a,m):
temp = 1
yield temp
for i in range(1,a+1):
temp = temp * i % m
yield temp
def comb(n,r,m):
if r == 0: return 1
return memf[n]*pow(memf[r],m-2,m)*pow(memf[n-r],m-2,m)
N,K,*a = list(map(int, open(0).read().split()))
m = 1000000007
memf = []
mfappend = memf.append
for x in memfact(N-1,m):
mfappend(x)
a.sort()
ans = 0
if K == 1:
print((0))
else:
for i in range(1,N-K+2):
ans = (ans + a[-i] * comb(N-i,K-1,m)) % m
for i in range(1,N-K+2):
ans = (ans - a[i-1] * comb(N-i,K-1,m)) % m
print(ans)
|
p02804
|
SIZE=10**5+1; MOD=10**9+7 #998244353 #ここを変更する
SIZE += 1
inv = [0]*SIZE # inv[j] = j^{-1} mod MOD
fac = [0]*SIZE # fac[j] = j! mod MOD
finv = [0]*SIZE # finv[j] = (j!)^{-1} mod MOD
inv[1] = 1
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
for i in range(2,SIZE):
inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD
fac[i] = fac[i-1]*i%MOD
finv[i]= finv[i-1]*inv[i]%MOD
def choose(n,r): # nCk mod MOD の計算
if 0 <= r <= n:
return (fac[n]*finv[r]%MOD)*finv[n-r]%MOD
else:
return 0
def chofuku(ball,box): # nHk mod MOD の計算
return choose(box+ball-1,box)
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
ans=0
for i in range(N):
for j in range(i+K-1,N):
ans+=(A[j]-A[i])*choose(j-i-1,K-2)
ans%=MOD
print(ans)
|
SIZE=10**5+1; MOD=10**9+7 #998244353 #ここを変更する
SIZE += 1
inv = [0]*SIZE # inv[j] = j^{-1} mod MOD
fac = [0]*SIZE # fac[j] = j! mod MOD
finv = [0]*SIZE # finv[j] = (j!)^{-1} mod MOD
inv[1] = 1
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
for i in range(2,SIZE):
inv[i] = MOD - (MOD//i)*inv[MOD%i]%MOD
fac[i] = fac[i-1]*i%MOD
finv[i]= finv[i-1]*inv[i]%MOD
def choose(n,r): # nCk mod MOD の計算
if 0 <= r <= n:
return (fac[n]*finv[r]%MOD)*finv[n-r]%MOD
else:
return 0
def chofuku(ball,box): # nHk mod MOD の計算
return choose(box+ball-1,box)
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
smax=0
smin=0
for i in range(N):
smax+=A[i]*choose(i,K-1)
smax%=MOD
smin+=A[i]*choose(N-i-1,K-1)
smin%=MOD
print(((smax-smin)%MOD))
|
p02804
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
mod=10**9+7
MAX_N=n+5
fac = [1,1] + [0]*MAX_N
finv = [1,1] + [0]*MAX_N
inv = [0,1] + [0]*MAX_N
for i in range(2,MAX_N):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod % i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
def nCk(n,k):
if n<k:
return 0
if n<0 or k<0:
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
max_x=0
for i in range(k-1,n):
max_x+=a[i]*nCk(i,k-1)
max_x%=mod
min_x=0
for i in range(n-k+1):
min_x+=a[i]*nCk(n-i-1,k-1)
min_x%=mod
print(((max_x-min_x)%mod))
|
from sys import stdin
nii=lambda:list(map(int,stdin.readline().split()))
lnii=lambda:list(map(int,stdin.readline().split()))
n,k=nii()
a=lnii()
a.sort()
mod=10**9+7
MAX_N = n+5
fac = [1,1] + [0]*MAX_N
finv = [1,1] + [0]*MAX_N
inv = [0,1] + [0]*MAX_N
for i in range(2,MAX_N):
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod % i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
def nCk(n,k):
if n<k:
return 0
if n<0 or k<0:
return 0
return fac[n] * (finv[k] * finv[n-k] % mod) % mod
min_X=0
for i in range(n-k+1):
min_X+=a[i]*nCk(n-i-1,k-1)
min_X%=mod
max_X=0
for i in range(k-1,n):
max_X+=a[i]*nCk(i,k-1)
max_X%=mod
ans=max_X-min_X
ans%=mod
print(ans)
|
p02804
|
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,K=list(map(int,input().split()))
A=list(map(int,input().split()))
MOD=10**9+7
A.sort()
ans=0
for i in range(N-K+1):
ans+=A[-(i+1)]*cmb(N-(1+i),K-1)
ans=ans%MOD
ans-=A[i]*cmb(N-(1+i),K-1)
ans=ans%MOD
print(ans)
|
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
MOD=10**9+7
A.sort()
fac=[None for i in range(N)]
finv=[None for i in range(N)]
inv=[None for i in range(N)]
def COMinit(num):
global fac
global finv
global inv
fac[0]=1
fac[1]=1
finv[0]=1
finv[1]=1
inv[1]=1
for i in range(2,num):
fac[i] = fac[i-1] * i % MOD
inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def COM(n,k):
if n<k:
return 0
elif n<0 or k<0:
return 0
else:
return int(fac[n] * (finv[k] * finv[n - k] % MOD) % MOD)
ans=0
COMinit(N)
for i in range(N-K+1):
ans+=A[-(i+1)]*COM(N-(1+i),K-1)
ans=ans%MOD
ans-=A[i]*COM(N-(1+i),K-1)
ans=ans%MOD
print(ans)
|
p02804
|
def main():
n,k = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
mod=10**9+7
sum=0
def we_want(x):
ans=1
for i in range(k-1):
ans=ans*(x-i)*pow(i+1,mod-2,mod)%mod
return ans
def check_min(i):
if n-i>=k:
minf=-we_want(n-1-i)*A[i]
return minf
else:return 0
def check_max(i):
if i>=k-1:
maxf=we_want(i)*A[i]
return maxf
else:return 0
for i in range(len(A)):
sum+=check_min(i)+check_max(i)
sum%=mod
print((sum%mod))
if __name__=='__main__':
main()
|
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
mod = 10 ** 9 + 7
b = 1
ans = 0
for i in range(k - 1, n):
ans += b * (a[i] - a[n - i - 1])
ans %= mod
b = (i+1)*pow(i-k+2, mod - 2, mod) * b % mod
print(ans)
|
p02804
|
import math
MOD = 10 ** 9 + 7
def comb(n, r):
if (r < 0) or n < r:
return 0
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def solve(N, K, A):
A.sort()
ans = 0
for i in range(1, N):
now = comb(i, K - 1)
ans += A[i] * now
A.sort(reverse=True)
for i in range(1, N):
now = comb(i, K - 1)
ans += A[i] * (-now)
return ans % MOD
# N = int(input())
# S = input()
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
print((solve(N, K, A)))
|
MOD = 10 ** 9 + 7
def solve(N, K, A):
A.sort()
ans = 0
for i in range(1, N):
now = cmb(i, K - 1, MOD)
ans += A[i] * now
A.sort(reverse=True)
for i in range(1, N):
now = cmb(i, K - 1, MOD)
ans += A[i] * (-now)
return ans % MOD
# N = int(input())
# S = input()
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
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
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)
print((solve(N, K, A)))
|
p02804
|
def combination(n, k, MOD):
if(k > n or k < 0):
return 0
frac = [1]*(n+1)
for i in range(1, n+1):
frac[i] = (frac[i-1]*i)%MOD
return (frac[n]*pow(frac[k], MOD-2, MOD)*pow(frac[n-k], MOD-2, MOD))%MOD
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
MOD = 10**9+7
ans = 0
for i in range(N):
ans = (ans + A[i]*combination(i, K-1, MOD))%MOD
for i in range(N):
ans = (ans - A[i]*combination(N-i-1, K-1, MOD))%MOD
print(ans)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
MOD = 10**9+7
#c[i] := (i)C(K-1)
c = [0] * (N+1)
#frac[i] = i!%MOD
frac = [1] * (N+1)
for i in range(1, N+1):
frac[i] = (frac[i-1]*i)%MOD
for i in range(1, N+1):
if(i >= K-1):
c[i] = frac[i]*pow(frac[K-1], MOD-2, MOD)*pow(frac[i-K+1], MOD-2, MOD)%MOD
ans = 0
for i in range(N):
ans = (ans + A[i]*c[i])%MOD
for i in range(N):
ans = (ans - A[i]*c[N-i-1])%MOD
print(ans)
|
p02804
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a=sorted(a)
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
else:
over=reduce(mul,list(range(n,n-r,-1)))
under=reduce(mul,list(range(1,r+1)))
return over//under
ans=0
for i in range(n-k+1):
ans+=cmb(k+i-1,k-1)*(a[k-1+i]-a[n-k-i])
print((ans%mod))
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a=sorted(a)
mod=10**9+7
ans=0
f=[1]
for i in range(1,n+1):
f.append((f[-1]*i)%mod)
for i in range(n-k+1):
ans+=(f[k+i-1]*pow(f[i],mod-2,mod)*pow(f[k-1],mod-2,mod))*(a[k-1+i]-a[n-k-i])
print((ans%mod))
|
p02804
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
mod = 10 ** 9 + 7
f = [1, 1]
for i in range(2, N+1):
f.append(f[i-1] * i)
fk = pow(f[K-1], mod - 2, mod)
total = 0
for i in range(N - K + 1):
p = N - i - 1
q = K - 1
c = (f[p] * fk * pow(f[p-q], mod-2, mod)) % mod
total += c * (A[-1 - i] - A[i])
total %= mod
print(total)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
mod = 10 ** 9 + 7
f = [i for i in range(N+1)]
for i in range(2, N+1):
f[i] *= f[i-1]
f[i] %= mod
f[0] = 1
q = K - 1
fk = pow(f[q], mod - 2, mod)
total = 0
for i in range(N - K + 1):
p = N - i - 1
c = (f[p] * fk * pow(f[p-q], mod-2, mod)) % mod
total += c * (A[-1 - i] - A[i])
total %= mod
print(total)
|
p02804
|
MOD=10**9+7
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort(reverse=True)
fact = [1]
fact_inv = [1]
mod=10**9+7
for i in range(10**5+1):
new_fact = fact[-1]*(i+1)%mod
fact.append(new_fact)
fact_inv.append(pow(new_fact,mod-2,mod))
def mod_comb_k(n,k,mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n-k] %mod
c=[]
for i in range(1,n-k+1+1):
c.append(mod_comb_k(n-i,k-1,MOD))
lc=len(c)
#print(c,a)
sum=0
for i in range(lc):
sum+=c[i]*(a[i]-a[-i-1])%MOD
print((sum%MOD))
|
MOD=10**9+7
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort(reverse=True)
#前計算
fact = [1]
fact_inv = [1]
mod=10**9+7
for i in range(n+1):
new_fact = fact[-1]*(i+1)%mod
fact.append(new_fact)
fact_inv.append(pow(new_fact,mod-2,mod))
def mod_comb_k(n,k,mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n-k] %mod
#前計算終わり
c=[]
for i in range(1,n-k+1+1):
c.append(mod_comb_k(n-i,k-1,MOD))
lc=len(c)
sum=0
for i in range(lc):
sum+=c[i]*(a[i]-a[-i-1])%MOD
print((sum%MOD))
|
p02804
|
MOD=10**9+7
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort(reverse=True)
#前計算
fact = [1]
fact_inv = [1]
mod=10**9+7
for i in range(n+1):
new_fact = fact[-1]*(i+1)%mod
fact.append(new_fact)
fact_inv.append(pow(new_fact,mod-2,mod))
def mod_comb_k(n,k,mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n-k] %mod
#前計算終わり
c=[]
for i in range(1,n-k+1+1):
c.append(mod_comb_k(n-i,k-1,MOD))
lc=len(c)
sum=0
for i in range(lc):
sum+=c[i]*(a[i]-a[-i-1])%MOD
print((sum%MOD))
|
MOD=10**9+7
n,k=list(map(int,input().split()))
a=sorted(list(map(int,input().split())),reverse=True)
#----------------------------------------------------------
# nCk mod 10**9+7
# 前計算
fact=[1]
fact_inv=[1]
mod=10**9+7
for i in range(n+1):
new_fact=fact[-1]*(i+1)%mod
fact.append(new_fact)
fact_inv.append(pow(new_fact,mod-2,mod))
def mod_comb_k(n,k,mod):
return fact[n]*fact_inv[k]%mod*fact_inv[n-k]%mod
#----------------------------------------------------------
c=[]
for i in range(1,n-k+1+1):
c.append(mod_comb_k(n-i,k-1,MOD))
lc=len(c)
sum=0
for i in range(lc):
sum+=c[i]*(a[i]-a[-i-1])%MOD
print((sum%MOD))
|
p02804
|
P = 10**9+7
N, K = list(map(int, input().split()))
S = list(map(int, input().split()))
S.sort()
ans = 0
c = 1
for i in range(N-K+1):
ans += (S[K-1+i]*c)%P
ans -= (S[N-K-i]*c)%P
ans %= P
c = c*(K+i)//(i+1)
print(ans)
|
P = 10**9+7
N, K = list(map(int, input().split()))
S = list(map(int, input().split()))
S.sort()
ans = 0
c = 1
for i in range(N-K+1):
ans += (S[K-1+i]*c)%P
ans -= (S[N-K-i]*c)%P
ans %= P
c = c*(K+i)*pow(i+1, P-2, P)%P
print(ans)
|
p02804
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 1000000007
def combinations(n, r):
r = min(r, n - r)
num = 1
den = 1
for i in range(1, r + 1):
num = num * (n + 1 - i) % MOD
den = den * i % MOD
return num * pow(den, MOD - 2, MOD) % MOD
A.sort()
max_sum = 0
min_sum = 0
for i, a in enumerate(A):
# max
if i >= K - 1:
max_sum += a * combinations(i, K - 1)
# min
if i <= N - K:
min_sum += a * combinations(N - i - 1, K - 1)
print((int((max_sum - min_sum) % MOD)))
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 1000000007
def combinations(n, r, MOD):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * fact_inv[r] * fact_inv[n - r] % MOD
A.sort()
fact = [1, 1]
fact_inv = [1, 1]
inv = [0, 1]
for i in range(2, N + 1):
fact.append((fact[-1] * i) % MOD)
inv.append((-inv[MOD % i] * (MOD // i)) % MOD)
fact_inv.append((fact_inv[-1] * inv[-1]) % MOD)
max_sum = 0
min_sum = 0
for i, a in enumerate(A):
# max
if i >= K - 1:
max_sum += a * combinations(i, K - 1, MOD)
# min
if i <= N - K:
min_sum += a * combinations(N - i - 1, K - 1, MOD)
print((int((max_sum - min_sum) % MOD)))
|
p02804
|
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
res = 0
a.sort()
cs = [0] * (N + 1)
for i in range(N): cs[i + 1] = cs[i] + a[i]
#print(cs)
class Factorial:
def __init__(self, n, mod):
self.f = [1]
for i in range(1, n + 1):
self.f.append(self.f[-1] * i % mod)
self.i = [pow(self.f[-1], mod - 2, mod)]
for i in range(1, n + 1)[: : -1]:
self.i.append(self.i[-1] * i % mod)
self.i.reverse()
def factorial(self, i):
return self.f[i]
def ifactorial(self, i):
return self.i[i]
def combi(self, n, k):
return self.f[n] * self.i[n - k] % mod * self.i[k] % mod
f = Factorial(N, mod)
t = [0] * (N + 1)
for i in range(1, N + 1):
if i - 1 < K - 2: continue
x = f.combi(i - 1, max(K - 2, 0))
y = -cs[i] + cs[-1] - cs[-1 - i]
t[i] = x * y % mod
res += t[i]
res %= mod
#print(t)
print(res)
|
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
a.sort()
class Factorial:
def __init__(self, n, mod):
self.mod = mod
self.f = [1]
for i in range(1, n + 1):
self.f.append(self.f[-1] * i % mod)
self.i = [pow(self.f[-1], mod - 2, mod)]
for i in range(1, n + 1)[: : -1]:
self.i.append(self.i[-1] * i % mod)
self.i.reverse()
def factorial(self, i):
return self.f[i]
def ifactorial(self, i):
return self.i[i]
def combi(self, n, k):
return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod
def permi(self, n, k):
return self.f[n] * self.i[n - k] % self.mod
f = Factorial(N, mod)
res = 0
for l in range(N - K + 1):
res -= f.combi(N - l - 1, K - 1) * a[l]
res %= mod
for r in range(K - 1, N):
res += f.combi(r, K - 1) * a[r]
res %= mod
print(res)
|
p02804
|
from heapq import heappush, heappop
from collections import deque
import re
import math
import functools
import itertools
import fractions
def sRaw():
return input().rstrip("\r")
def iRaw():
return int(eval(input()))
def ssRaw():
return input().split()
def isRaw():
return list(map(int, ssRaw()))
INF = 1 << 29
def mk1d(n, val=INF):
return [val for i in range(n)]
def mk2d(h, w, val=INF):
return [[val for i in range(w)]for i in range(h)]
DIV = 998244353
def gcd(a, b):
if(b == 0):
return a
return gcd(b, a % b)
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm(*numbers):
return functools.reduce(lcm_base, numbers, 1)
def floyd_warshall(costs):
N = len(costs)
for k in range(N):
for i in range(N):
for j in range(N):
costs[i][j] = min(costs[i][j], costs[i][k]+costs[k][j])
return costs
def lcm_list(numbers):
return functools.reduce(lcm_base, numbers, 1)
DIV = (10**9) + 7
def mod_inv_prime(a, mod=DIV):
return pow(a, mod-2, mod)
def mod_inv(a, b):
r = a
w = b
u = 1
v = 0
while w != 0:
t = r//w
r -= t*w
r, w = w, r
u -= t*v
u, v = v, u
return (u % b+b) % b
def ncr(n, r, mod=DIV):
r = min(r, n-r)
ret = 1
for i in range(1, r+1):
ret = ret * (n-i+1) % mod
ret = ret * mod_inv(i, mod) % mod
return ret
def main():
N,K = isRaw()
As = isRaw()
As.sort()
dp = [0]*N
dp[K-1] = As[K-1]-As[0]
for n in range(K,N):
dp[n] = dp[n-1]
for idx in range(n-K+2):
nCk = ncr(n-idx-1,K-2)
dp[n] = (dp[n]+nCk*(As[n]-As[idx])+DIV)%DIV
return dp[N-1]
if __name__ == "__main__":
print((main()))
|
def sRaw():
return input().rstrip("\r")
def iRaw():
return int(eval(input()))
def ssRaw():
return input().split()
def isRaw():
return list(map(int, ssRaw()))
INF = 1 << 29
DIV = (10**9) + 7
def mod_inv_prime(a, mod=DIV):
return pow(a, mod-2, mod)
def mod_inv(a, b):
r = a
w = b
u = 1
v = 0
while w != 0:
t = r//w
r -= t*w
r, w = w, r
u -= t*v
u, v = v, u
return (u % b+b) % b
def CONV_TBL(max,mod=DIV):
fac,finv,inv = [0]*max, [0]*max, [0]*max
fac[0]=fac[1]=1
finv[0]=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
class CONV:
def __init__(self):
pass
def ncr(self,n,k):
if(n<k):
return 0
if(n<0 or k<0 ):
return 0
return fac[n]*(finv[k]*finv[n-k]%mod)%mod
return CONV()
def main():
n,k = isRaw()
As = list(isRaw())
As.sort()
ct = CONV_TBL(n)
ans = 0
for i in range(n):
ans += As[i]*ct.ncr(i, k-1) - As[i]*ct.ncr(n-(i+1), k-1)
ans = ans%DIV
return ans
if __name__ == "__main__":
print((main()))
|
p02804
|
import itertools
N, K = (int(x) for x in input().split())
As = (int(x) for x in input().split())
def f(S):
m = 1000000001
M = -1000000001
for a in S:
m = min(m, a)
M = max(M, a)
return M - m
Ss = list(itertools.combinations(As, K))
answer = 0
for S in Ss:
answer = answer + f(S)
print((answer % 1000000007))
|
import itertools
N, K = (int(x) for x in input().split())
As = (int(x) for x in input().split())
def f(S):
m = 1000000001
M = -1000000001
for a in S:
m = min(m, a)
M = max(M, a)
return M - m
answer = 0
for S in itertools.combinations(As, K):
answer = answer + f(S)
print((answer % 1000000007))
|
p02804
|
import itertools
mod = 10**9 +7
n,k = [int(i) for i in input().split()]
l = [int(i) for i in input().split()]
f = list(itertools.combinations(l, k))
ans = 0
for i in f:
ans += (max(i) - min(i))
print((ans%mod))
|
import itertools
mod = 10**9 +7
n,k = [int(i) for i in input().split()]
l = [int(i) for i in input().split()]
f = itertools.combinations(l, k)
ans = 0
for i in f:
ans += abs(i[0] - i[k-1])
print((ans%mod))
|
p02804
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
p = 10 ** 9 + 7
#二項定理(nCr)を高速に計算する
def cmb(n,r,p):
N = 10 ** 5 + 5 #必要なサイズを指定
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))
if (r < 0) or (n < r):
return 0
r = min(r,n-r)
return fact[n] * factinv[r] * factinv[n-r] % p
A_max = 0
A_min = 0
for i in range(N-K+1):
A_max = (A_max + (A[(K-1)+i] * cmb((K+i-1),i,p))) % p
A_min = (A_min + (A[-1*(K+i)] * cmb((K+i-1),i,p))) % p
#print(A_max,A_min,cmb((K+i),i,p))
ans = (A_max - A_min)
if ans < 0:
ans = p + ans
ans %= p
print(ans)
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
mod = p = 10 ** 9 + 7
fact = [1]
fact_inv = [1]
for i in range(10**5+5):
new_fact = fact[-1]*(i+1)%mod
fact.append(new_fact)
fact_inv.append(pow(new_fact,mod-2,mod))
def mod_comb_k(n,k,mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n-k] %mod
A_max = 0
A_min = 0
for i in range(N-K+1):
A_max = (A_max + (A[(K-1)+i] * mod_comb_k((K+i-1),i,p))) % p
A_min = (A_min + (A[-1*(K+i)] * mod_comb_k((K+i-1),i,p))) % p
#print(A_max,A_min,cmb((K+i),i,p))
ans = (A_max - A_min)
if ans < 0:
ans = p + ans
ans %= p
print(ans)
|
p02804
|
def cmb1(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, k = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9+7
A.sort(reverse=True)
max_ = 0
for i in range(n):
max_ += cmb1(n-1-i, k-1, mod)*A[i]
max_ %= mod
min_ = 0
for i in range(n):
min_ += cmb1(n-1-i, k-1, mod)*A[n-1-i]
min_ %= mod
ans = max_-min_
ans %= mod
print(ans)
|
n, k =list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9+7
N = 10**5+50
fac = [1]*(N+1)
finv = [1]*(N+1)
for i in range(N):
fac[i+1] = fac[i] * (i+1) % mod
finv[-1] = pow(fac[-1], mod-2, mod)
for i in reversed(list(range(N))):
finv[i] = finv[i+1] * (i+1) % mod
def cmb1(n, r, mod):
if r <0 or r > n:
return 0
r = min(r, n-r)
return fac[n] * finv[r] * finv[n-r] % mod
A.sort()
ans = 0
for i, a in enumerate(A):
M = n-1-i
m = i
if m >= 0:
ans += a*cmb1(m, k-1, mod)
if M >= 0:
ans -= a*cmb1(M, k-1, mod)
ans %= mod
print(ans)
|
p02804
|
#import sys
#input = sys.stdin.readline
Q = 10**9+7
def getInv(N):#Qはmod
inv = [0] * (N + 1)
inv[0] = 1
inv[1] = 1
for i in range(2, N + 1):
inv[i] = (-(Q // i) * inv[Q%i]) % Q
return inv
def getFactorialInv(N):
inv = [0] * (N + 1)
inv[0] = 1
inv[1] = 1
ret = [1]*(N+1)
for i in range(2, N + 1):
inv[i] = (-(Q // i) * inv[Q%i]) % Q
ret[i] = ret[i-1]*inv[i]
return ret
def getFactorial(N):
ret = [1]*(N+1)
for i in range(2,N+1):
ret[i] = ret[i-1]*i%Q
return ret
def main():
N, K = list(map( int, input().split()))
if K == 1:
print((0))
return
A = list( map( int, input().split()))
A.sort()
ans = 0
# cnt = 1
fact = getFactorial(N)
invfact = getFactorialInv(N)
for i in range(K-1,N):
# if i < N-1:
# if A[i+1] == A[i]:
# cnt += 1
# continue
ans += fact[i]*invfact[K-1]%Q*invfact[i-(K-1)]%Q*A[i]%Q
# print(A[i], fact[i]*invfact[K-1]%Q*invfact[i-(K-1)]%Q*cnt%Q)
ans %= Q
A = A[::-1]
for i in range(K-1,N):
# if i < N-1:
# if A[i+1] == A[i]:
# cnt += 1
# continue
ans -= fact[i]*invfact[K-1]%Q*invfact[i-(K-1)]%Q*A[i]%Q
# print(A[i], fact[i]*invfact[K-1]%Q*invfact[i-(K-1)]%Q*cnt%Q)
ans %= Q
print(ans)
if __name__ == '__main__':
main()
|
#import sys
#input = sys.stdin.readline
Q = 10**9+7
# def getInv(N):#Qはmod
# inv = [0] * (N + 1)
# inv[0] = 1
# inv[1] = 1
# for i in range(2, N + 1):
# inv[i] = (-(Q // i) * inv[Q%i]) % Q
# return inv
def main():
N, K = list(map( int, input().split()))
if K == 1:
print((0))
return
A = list( map( int, input().split()))
A.sort()
ans = 0
cnt = 1
for i in range(K-1,N):
if i >= K:
cnt *= i*pow(i-(K-1), Q-2, Q)%Q
cnt %= Q
ans += cnt*A[i]
ans -= cnt*A[N-1-i]
ans %= Q
print(ans)
if __name__ == '__main__':
main()
|
p02804
|
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
mod = 10**9 + 7
n,k = list(map(int,input().split()))
inv = [0,1]
for i in range(2,n):
inv += [inv[mod % i]*(mod - mod//i) % mod]
a = list(map(int,input().split()))
a.sort()
ans = 0
c = cmb(n-1,k-1,mod)
if k == 1:
print((0))
exit()
for i in range(n-k+1):
ans -= a[i] * c
ans += a[-i-1] * c
ans %= mod
c = c*(n-k-i)*inv[n-i-1]
if ans < 0:
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
mod = 10**9 + 7
n,k = list(map(int,input().split()))
inv = [0,1]
for i in range(2,n):
inv += [inv[mod % i]*(mod - mod//i) % mod]
a = list(map(int,input().split()))
a.sort()
ans = 0
c = 1
x = 1
if k == 1:
print((0))
exit()
for i in range(n-k+1):
ans -= a[n-k-i] * c
ans += a[k+i-n-1] * c
ans %= mod
c = c*(i+k)*inv[i+1] % mod
if ans < 0:
ans += mod
print(ans)
|
p02804
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = int(1e+9 + 7)
a = sorted(a)
kai = [1, 1]
gyaku = [1, 1]
for i in range(2, n+1):
kai.append(kai[-1]*i % mod)
gyaku.append(gyaku[-1]*pow(i, mod-2, mod))
answer = 0
for i in range(n-k+1):
for j in range(i+k-1,n):
answer = (answer + (a[j] - a[i]) * kai[j-i-1] *gyaku[j-i-1-(k-2)] * gyaku[k-2])%mod
if k == 1:
print((0))
else:
print(answer)
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = int(1e+9 + 7)
a = sorted(a)
kai = [1]*(n+1)
gyaku = [1]*(n+1)
for i in range(2, n+1):
kai[i] = kai[i-1]*i % mod
gyaku[i] = gyaku[i-1]*pow(i, mod-2, mod) %mod
answer = 0
for i in range(n-k+1):
for j in range(i+k-1,n):
answer = (answer + (a[j] - a[i]) * kai[j-i-1] *gyaku[j-i-1-(k-2)] * gyaku[k-2])%mod
if k == 1:
print((0))
else:
print(answer)
|
p02804
|
from functools import lru_cache
@lru_cache(maxsize=2**17, typed=int)
def comb(n, r, p):
r = min(n - r, r)
if r == 0:
return 1
over = 1
for i in range(n, n - r, -1):
over = over * i % p
under = 1
for i in range(1, r + 1):
under = under * i % p
inv = pow(under, p - 2, p)
return over * inv % p
def main():
n, k = list(map(int, input().split()))
a = sorted(int(i) for i in input().split())
mod = 10**9 + 7
f = 0
for i in range(n - k + 1):
f = (f + a[k + i - 1] * comb(k - 1 + i, k - 1, mod) % mod) % mod
f = (f - a[i] * comb(n - 1 - i, k - 1, mod) % mod) % mod
print(f)
if __name__ == '__main__':
main()
|
def main():
n, k = list(map(int, input().split()))
a = sorted(int(i) for i in input().split())
mod = 10**9 + 7
comb = [1] * (n - k + 1)
for i in range(n - k):
comb[i + 1] = (comb[i] * (k + i) * pow(i + 1, mod - 2, mod)) % mod
f = 0
for i in range(n - k + 1):
f = (f + a[k + i - 1] * comb[i] % mod) % mod
f = (f - a[i] * comb[-1 - i] % mod) % mod
print(f)
if __name__ == '__main__':
main()
|
p02804
|
import sys
input = sys.stdin.readline
mod = 10 ** 9 + 7
N, K = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
minus = 0
plus = 0
fact = [0] * (N+1)
fact[0] = 1
pow_fact = [0] * (N+1)
pow_fact[0] = 1
fa = 1
for i in range(1, N+1):
fa *= i
fact[i] = fa
pow_fact[i] = pow(fa, mod-2, mod)
b = pow_fact[K-1]
for i in range(N-K+1):
a = fact[N-i-1]
c = pow_fact[N-i-K]
comb = (a*b*c) % mod
minus += (A[i] * comb)
plus += (A[-i-1] * comb)
print(((plus - minus) % mod))
|
import sys
input = sys.stdin.readline
mod = 10 ** 9 + 7
N, K = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
minus = 0
plus = 0
fact = [0] * (N+1)
fact[0] = 1
pow_fact = [0] * (N+1)
pow_fact[0] = 1
fa = 1
for i in range(1, N+1):
fa *= i
fa %= mod
fact[i] = fa
pow_fact[i] = pow(fa, mod-2, mod)
b = pow_fact[K-1]
for i in range(N-K+1):
a = fact[N-i-1]
c = pow_fact[N-i-K]
comb = (a*b*c) % mod
minus += (A[i] * comb) % mod
plus += (A[-i-1] * comb) % mod
print(((plus - minus) % mod))
|
p02804
|
import itertools as it
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
ans=0
for i in it.combinations([i for i in range(n)], k):
max_x = a[max(i)]
min_x = a[min(i)]
ans += (max_x - min_x)
print((ans%(10**9 +7)))
|
class Combination(): # nCr(mod p) #n<=10**6
def __init__(self, N, MOD): # cmbの前処理
self.mod = MOD
self.FACT = [1, 1] # 階乗
self.INV = [0, 1] # 各iの逆元
self.FACTINV = [1, 1] # 階乗の逆元
for i in range(2, N + 1):
self.FACT.append((self.FACT[-1] * i) % self.mod)
self.INV.append(pow(i, self.mod - 2, self.mod))
self.FACTINV.append((self.FACTINV[-1] * self.INV[-1]) % self.mod)
def count(self, N, R): # nCr(mod p) #前処理必要
if (R < 0) or (N < R):
return 0
R = min(R, N - R)
return self.FACT[N] * self.FACTINV[R] * self.FACTINV[N-R] % self.mod
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
mod = 10 ** 9 + 7
ans = 0
cmb = Combination(n, mod)
for i in range(n):
cnt = cmb.count(i, k - 1) - cmb.count(n - i - 1, k - 1)
ans += a[i] * cnt % mod
print((ans % mod))
|
p02804
|
n,k=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
mod = 10**9+7 # 変える
fac = [1]*n
finv = [1]*n
inv = [0]*n
inv[1] = 1
for i in range(2,n):
fac[i] = fac[i-1]*i % mod
inv[i] = mod - inv[mod%i] *(mod//i) %mod
finv[i] = finv[i-1] * inv[i] % mod
def comb(n,k):
if n<k:
return 0
if n<0 or k<0:
return 0
return fac[n]*(finv[k] * finv[n-k] % mod)%mod
ans=0
for i in range(n-k+1):
ans+=comb(n-i-1,k-1)*(a[n-i-1]-a[i])
print((ans%mod))
|
n,k=list(map(int,input().split()))
a=sorted(list(map(int,input().split())))
mod = 10**9+7 # 変える
fac = [1]*n
finv = [1]*n
inv = [0]*n
inv[1] = 1
for i in range(2,n):
fac[i] = fac[i-1]*i % mod
inv[i] = mod - inv[mod%i] *(mod//i) %mod
finv[i] = finv[i-1] * inv[i] % mod
def comb(n,k):
if n<k:
return 0
if n<0 or k<0:
return 0
return fac[n]*(finv[k] * finv[n-k] % mod)%mod
ans=0
for i in range(n-k+1):
ans=(ans+comb(n-i-1,k-1)*(a[n-i-1]-a[i]))%mod
print(ans)
|
p02804
|
# -*- coding: utf-8 -*-
# E
import sys
from functools import reduce
# 再起回数上限変更
# sys.setrecursionlimit(1000000)
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10**9 + 7
A.sort()
# print(A)
def cmb(n, r):
from operator import mul
from functools import reduce
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
ans = 0
num1=None
num2=None
for i in range(N):
if N - i - 1 >= K-1:
if num1 is None:
num1 = cmb(N-i-1, K-1) % mod
else:
num1 = int(num1 * ((N-i-K+1) % mod) * pow(N-i, mod-2, mod))
# print(N-i-1, K-1, num1)
if A[i] * num1 < 0:
ans += (-A[i] * num1) % mod
else:
ans -= (A[i] * num1) % mod
# print(f'-: {i}, {num}, {A[i]}')
if i >= K-1:
if num2 is None:
num2 = cmb(i, K-1) % mod
else:
num2 = num2 * (i % mod) * pow(i-K+1, mod-2, mod)
# print(i, K-1, num2)
if A[i] * num2 < 0:
ans -= (-A[i] * num2) % mod
else:
ans += (A[i] * num2) % mod
# print(f'+: {i}, {num}, {A[i]}')
print((ans % mod))
|
# -*- coding: utf-8 -*-
# E
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
mod = 10**9 + 7
class Cmb(object):
def cmb_precalc(self, n, r, mod: int = 10 ** 9 + 7):
if (r < 0) or (r > n):
return 0
r = min(r, n - r)
return self.g1[n] * self.g2[r] * self.g2[n - r] % mod
def cmb_prep(self, N: int, mod: int = 10 ** 9 + 7):
self.g1 = [1, 1] # 元テーブル
self.g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N + 1):
self.g1.append((self.g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
self.g2.append((self.g2[-1] * inverse[-1]) % mod)
ans = 0
cmb = Cmb()
cmb.cmb_prep(N + 5)
for i in range(N):
if i >= K-1:
ans += A[i] * cmb.cmb_precalc(i, i-K+1)
if N - i - 1 >= K-1:
ans -= A[i] * cmb.cmb_precalc(N-i-1, K-1)
print((ans % mod))
|
p02804
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
mod = 10**9+7
import itertools
ans = 0
for a in itertools.combinations(A,K):
ans += (max(a)-min(a))%mod
ans %= mod
print(ans)
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
fact_l=[1]*(N+10)
mod = 10**9+7
for i in range(2,N+1):
fact_l[i]=(fact_l[i-1]*i)%mod
fact_inv_l = [1]*(N+10)
for i in range(2,N+1):
fact_inv_l[i]=pow(fact_l[i],mod-2,mod)
ans = 0
for i in range(1,N-K+2):
b = N-i
c = K-1
ans -= A[i-1]*fact_l[b]%mod*fact_inv_l[b-c]%mod*fact_inv_l[c]%mod
ans += A[-i]*fact_l[b]%mod*fact_inv_l[b-c]%mod*fact_inv_l[c]%mod
print((ans%mod))
|
p02804
|
def factorial(n, p):
ret = 1
for i in range(n, 0, -1):
ret *= i
ret %= p
return ret
def comb(n, r, p):
r = min(r, n - r)
a = factorial(r, p)
b = factorial(n - r, p)
ret = factorial(n, p) * pow(a, p - 2, p) * pow(b, p - 2, p) % p
return ret
mod = 10 ** 9 + 7
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
ans = 0
sum_min = 0
for i in range(n - k + 1):
cnt = comb(n - 1 - i, k - 1, mod)
sum_min += a[i] * cnt
sum_min %= mod
a_rev = a[::-1]
sum_max = 0
for i in range(n - k + 1):
cnt = comb(n - 1 - i, k - 1, mod)
sum_max += a_rev[i] * cnt
sum_max %= mod
ans = (sum_max - sum_min) % mod
print(ans)
|
def cmb(n, r, p):
if r < 0 or n < r:
return 0
r = min(r, n - r)
return fact[n] * fact_inv[r] * fact_inv[n - r] % p
n, k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())), reverse=True)
p = 10 ** 9 + 7
fact = [1, 1] # fact[n] = (n! mod p)
fact_inv = [1, 1] # fact_inv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # fact_invの計算用
for i in range(2, n + 1):
fact.append(fact[-1] * i % p)
inv.append((-inv[p % i] * (p // i)) % p)
fact_inv.append(fact_inv[-1] * inv[-1] % p)
i = 0
sum_max = 0
sum_min = 0
while n - i - 1 >= k - 1:
cnt = cmb(n - i - 1, k - 1, p)
sum_max += a[i] * cnt
sum_min += a[n - i - 1] * cnt
# print(i, a[i] * cnt, a[n - i - 1] * cnt)
i += 1
ans = (sum_max - sum_min) % p
print(ans)
|
p02804
|
import sys,bisect
input = sys.stdin.readline
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
mod = 10**9+7
fact = [1]
fact_inv = [1]
for i in range(10**5+5):
new_fact = fact[-1]*(i+1)%mod
fact.append(new_fact)
fact_inv.append(pow(new_fact,mod-2,mod))
def mod_comb_k(n,k,mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n-k] %mod
a.sort()
mi = 0
for i in range(n-k+1):
mi = (mi + a[i]*mod_comb_k(n-i-1,k-1,mod)%mod)%mod
a = a[::-1]
ma = 0
for i in range(n-k+1):
ma = (ma + a[i]*mod_comb_k(n-i-1,k-1,mod)%mod)%mod
print(((ma-mi)%mod))
|
def main():
import sys
input = sys.stdin.readline
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
mod = 10**9+7
fact = [1]
fact_inv = [1]
for i in range(10**5+5):
new_fact = fact[-1]*(i+1)%mod
fact.append(new_fact)
fact_inv.append(pow(new_fact,mod-2,mod))
def mod_comb_k(n,k,mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n-k] %mod
a.sort()
res = 0
for i in range(n-k+1):
res = (res + (a[n-1-i]- a[i])*mod_comb_k(n-i-1,k-1,mod)%mod)%mod
print(res)
if __name__ == '__main__':
main()
|
p02804
|
def main():
import sys
input = sys.stdin.readline
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
mod = 10**9+7
fact = [1]
fact_inv = [1]
for i in range(10**5+5):
fact.append(fact[-1]*(i+1)%mod)
fact_inv.append(pow(fact[-1],mod-2,mod))
def mod_comb_k(n,k,mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n-k] %mod
a.sort()
res = 0
for i in range(n-k+1):
res = (res + (a[n-1-i]- a[i])*mod_comb_k(n-i-1,k-1,mod)%mod)%mod
print(res)
if __name__ == '__main__':
main()
|
def main():
import sys
input = sys.stdin.readline
n,k = list(map(int,input().split()))
a = list(map(int,input().split()))
mod = 10**9+7
fact = [1]
fact_inv = [1]
for i in range(10**5+5):
fact.append(fact[-1]*(i+1)%mod)
fact_inv.append(pow(fact[-1],mod-2,mod))
def mod_comb_k(n,k,mod):
return fact[n] * fact_inv[k] % mod * fact_inv[n-k] %mod
a.sort()
res = 0
for i in range(n-k+1):
res = (res + (a[n-1-i]- a[i])*mod_comb_k(n-i-1,k-1,mod))%mod
print(res)
if __name__ == '__main__':
main()
|
p02804
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
#階乗#
lim = 10**5 #必要そうな階乗の限界を入力
fact = [1] * (lim+1)
for n in range(1, lim+1):
fact[n] = n * fact[n-1] % mod
#階乗の逆元#
fact_inv = [1]*(lim+1)
fact_inv[lim] = pow(fact[lim], mod-2, mod)
for n in range(lim, 0, -1):
fact_inv[n-1] = n*fact_inv[n]%mod
def C(n, r):
if n < r:
return 0
else:
return (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod
N, K = MAP()
A = LIST()
A.sort()
A_cnt = Counter(A)
P = list(A_cnt.keys())
p = list(A_cnt.values())
#print("P={}".format(P))
#print("p={}".format(p))
p_acc = list(accumulate(p))
p_acc_rev = list(accumulate(p[::-1]))
#print("p_acc={}".format(p_acc))
#print("p_acc_rev={}".format(p_acc_rev))
n = len(p)
T = [[0]*4 for _ in range(n)]
for i in range(n):
T[i][0] = p_acc[i]
for i in range(1, n):
T[i][1] = p_acc[i-1]
for i in range(n):
T[(-i-1)][3] = p_acc_rev[i]
for i in range(1, n):
T[(-i-1)][2] = p_acc_rev[i-1]
#for i in range(n):
# print(T[i])
t = [0]*n
for idx, x in enumerate(T):
t[idx] = (C(x[0], K) - C(x[1], K) + C(x[2], K) - C(x[3], K))%mod
ans = 0
for i in range(n):
ans = (ans + P[i]*t[i]%mod)%mod
print(ans)
|
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
#階乗#
lim = 10**5 #必要そうな階乗の限界を入力
fact = [1] * (lim+1)
for n in range(1, lim+1):
fact[n] = n * fact[n-1] % mod
#階乗の逆元#
fact_inv = [1]*(lim+1)
fact_inv[lim] = pow(fact[lim], mod-2, mod)
for n in range(lim, 0, -1):
fact_inv[n-1] = n*fact_inv[n]%mod
def C(n, r):
if n < r:
return 0
else:
return (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod
N, K = MAP()
A = LIST()
A.sort()
max_sum = 0
for i in range(K-1, N):
max_sum = (max_sum + A[i]*C(i, K-1)%mod)%mod
A = A[::-1]
min_sum = 0
for i in range(K-1, N):
min_sum = (min_sum + A[i]*C(i, K-1)%mod)%mod
print(((max_sum - min_sum)%mod))
|
p02804
|
import math
def nCr(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
mod = 10**9 + 7
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
a_reverse = a[::-1]
plus = 0
minus = 0
cnt = 0
ind = 0
# ceil = nCr(n, k)
kaisu = nCr(n, k-1)
# while cnt < ceil:
for _ in range(n-k+1):
kaisu = kaisu * ((n-ind)-(k-1)) // (n-ind)
cnt += kaisu
plus = (plus + (kaisu * a_reverse[ind]) % mod) % mod
minus = (minus + (kaisu * a[ind]) % mod) % mod
ind += 1
print(((plus-minus) % mod))
|
n,k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
a_reverse = a[::-1]
mod = 10**9+7
factorial = [1]
inverse = [1]
for i in range(1, n+2):
factorial.append(factorial[-1] * i % mod)
inverse.append(pow(factorial[-1], mod - 2, mod))
def comb(n, r, mod):
if n < r or r < 0:
return 0
elif r == 0:
return 1
return factorial[n] * inverse[r] * inverse[n - r] % mod
plus = 0
minus = 0
cnt = 0
ind = 0
for i in range(n-k+1):
kaisu = comb(n-i-1, k-1, mod)
plus = (plus + (kaisu * a_reverse[ind]) % mod) % mod
minus = (minus + (kaisu * a[ind]) % mod) % mod
ind += 1
print(((plus-minus) % mod))
|
p02804
|
n,k = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
a_reverse = a[::-1]
mod = 10**9+7
factorial = [1]
inverse = [1]
for i in range(1, n+1):
factorial.append(factorial[-1] * i % mod)
inverse.append(pow(factorial[-1], mod - 2, mod))
def comb(n, r, mod):
if n < r or r < 0:
return 0
elif r == 0:
return 1
return factorial[n] * inverse[r] * inverse[n - r] % mod
plus = 0
minus = 0
cnt = 0
ind = 0
for i in range(n-k+1):
kaisu = comb(n-i-1, k-1, mod)
plus = (plus + (kaisu * a_reverse[ind]) % mod) % mod
minus = (minus + (kaisu * a[ind]) % mod) % mod
ind += 1
print(((plus-minus) % mod))
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10**9 + 7
factorial = [1]
inverse = [1]
for i in range(1, n+1):
factorial.append(factorial[-1] * i % mod)
inverse.append(pow(factorial[-1], mod - 2, mod))
def comb(n, r, mod):
if n < r or r < 0: return 0
elif r == 0: return 1
return factorial[n] * inverse[r] * inverse[n - r] % mod
a.sort()
mini = 0
for i in range(n-1):
mini += a[i] * comb(n-i-1, k-1, mod)
mini %= mod
a.sort(reverse=True)
maxi = 0
for i in range(n-1):
maxi += a[i] * comb(n-i-1, k-1, mod)
maxi %= mod
print(((maxi-mini)%mod))
|
p02804
|
def cmb(n, r):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % mod
N = pow(10, 5) # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
mod = pow(10, 9) + 7
for i in range(2, N + 1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
n,k = list(map(int,input().split()))
a = [int(i) for i in input().split()]
a.sort()
if k > 1:
ans = 0
for i in range(k-1, n):
for j in range(0, i - k + 2):
ans += (a[i] - a[j]) * cmb(i - j - 1, k - 2)
#print(j, i, ' ', a[j],a[i], ' ', a[i] - a[j])
ans %= pow(10, 9) + 7
print(ans)
else:
print((0))
|
def cmb(n, r):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % mod
N = pow(10, 5) # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
mod = pow(10, 9) + 7
for i in range(2, N + 1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
n,k = list(map(int,input().split()))
a = [int(i) for i in input().split()]
a.sort()
if k > 1:
ans = 0
for i in range(k-1, n):
maxs = a[i]
ncr = cmb(i, k-1)
#print(maxs, ncr, maxs * ncr)
ans += maxs * ncr
ans %= mod
for i in range(n-k+1):
mins = a[i]
ncr = cmb(n-i-1, k-1)
#print(mins, ncr, mins * ncr)
ans -= mins * ncr
ans %= mod
print(ans)
else:
print((0))
|
p02804
|
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 ** 5 * 2 + 1
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range(2, N + 1 ):
g1.append((g1[-1] * i) % MOD)
inverse.append((-inverse[MOD % i] * (MOD // i) ) % MOD)
g2.append((g2[-1] * inverse[-1]) % MOD)
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
answer = 0
for i in range(N):
if i > N - K:
break
answer = (answer + (A[N - i - 1] - A[i]) * cmb(N - 1 - i, K - 1, MOD)) % MOD
print(answer)
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
### Combination Table ###
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
def comb(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
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)
#########################
A.sort()
answer = 0
for i in range(N):
if i > N - K:
break
answer = (answer + (A[N - i - 1] - A[i]) * comb(N - 1 - i, K - 1, MOD)) % MOD
print(answer)
|
p02804
|
MOD = 10**9 + 7
def getInvs(n, MOD):
invs = [1] * (n+1)
for x in range(2, n+1):
invs[x] = (-(MOD//x) * invs[MOD%x]) % MOD
return invs
def getCombKs(n, k, invs, MOD):
combKs = [0] * (n+1)
combKs[k] = 1
for x in range(k+1, n+1):
combKs[x] = (combKs[x-1] * x * invs[x-k]) % MOD
return combKs
N, K = list(map(int, input().split()))
As = list(map(int, input().split()))
As.sort()
invs = getInvs(N, MOD)
combKs = getCombKs(N, K-1, invs, MOD)
ans = 0
for i, A in enumerate(As):
numMax = combKs[i]
numMin = combKs[N-1-i]
ans += A * (numMax - numMin) % MOD
ans %= MOD
print(ans)
|
MOD = 10**9 + 7
N, K = list(map(int, input().split()))
As = list(map(int, input().split()))
def getInvs(n, MOD):
invs = [1] * (n+1)
for x in range(2, n+1):
invs[x] = (-(MOD//x) * invs[MOD%x]) % MOD
return invs
invs = getInvs(N, MOD)
def getCombKs(n, k, invs, MOD):
combKs = [0] * (n+1)
combKs[k] = 1
for x in range(k+1, n+1):
combKs[x] = (combKs[x-1] * x * invs[x-k]) % MOD
return combKs
combKs = getCombKs(N, K-1, invs, MOD)
As.sort()
ans = 0
for i, A in enumerate(As):
if i >= K-1:
ans += combKs[i] * A
if N-1-i >= K-1:
ans -= combKs[N-1-i] * A
ans %= MOD
print(ans)
|
p02804
|
MAX_NUM = 10**6 + 1
MOD = 10**9+7
fac = [0 for _ in range(MAX_NUM)]
finv = [0 for _ in range(MAX_NUM)]
inv = [0 for _ in range(MAX_NUM)]
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,MAX_NUM):
fac[i] = fac[i-1] * i % MOD
inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def combinations(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % MOD) % MOD
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A=sorted(A)
ANSWER = 0
# Sの最大値をイテレート
for i in range(K-1, N):
for j in range(i-K+2):
ANSWER += (A[i]-A[j])*combinations(i-j+1-2, K-2)
ANSWER %= MOD
print(ANSWER)
|
MAX_NUM = 10**6 + 1
MOD = 10**9+7
fac = [0 for _ in range(MAX_NUM)]
finv = [0 for _ in range(MAX_NUM)]
inv = [0 for _ in range(MAX_NUM)]
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,MAX_NUM):
fac[i] = fac[i-1] * i % MOD
inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def combinations(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n-k] % MOD) % MOD
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A=sorted(A)
ANSWER = 0
# Sの最大値をイテレート
for i in range(K-1, N):
ANSWER += A[i]*combinations(i, K-1)
# print(ANSWER)
for i in range(N-K+1):
ANSWER -= A[i]*combinations(N-i-1, K-1)
# print(ANSWER)
ANSWER %= MOD
print(ANSWER)
|
p02804
|
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, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
mi = [0] * n
ma = [0] * n
s_mi = 0
s_ma = 0
for i in range(n):
nn = n - i - 1
if nn < k - 1:
break
else:
mi[i] = comb(nn, k - 1)
ma[-(i + 1)] = mi[i]
for i, j, k in zip(a, mi, ma):
s_mi += i * j
s_ma += i * k
print(((s_ma - s_mi) % (10 ** 9 + 7)))
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
fac = {0: 1, 1: 1}
finv = {0: 1, 1: 1}
inv = {1: 1}
a.sort()
mi = [0] * n
ma = [0] * n
s_mi = 0
s_ma = 0
def comb_init():
for i in range(2, n + 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 comb(n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k] * finv[n - k] % mod) % mod
comb_init()
for i in range(n):
nn = n - i - 1
if nn < k - 1:
break
else:
mi[i] = comb(nn, k - 1)
ma[-(i + 1)] = mi[i]
s_mi = (s_mi + mi[i] * a[i]) % mod
s_ma = (s_ma + ma[-(i + 1)] * a[-(i + 1)]) % mod
print(((s_ma - s_mi) % mod))
|
p02804
|
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
r = 0
if False:
for i in range(K+1):
r += (A[-i-1] - A[i]) * cmb(N-i-1, K-1, mod)
else:
for i in range(N-K+1):
r += (A[-i-1] - A[i]) * cmb(N-i-1, K-1, mod)
print((r % mod))
def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, 10 ** 6 + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
main()
|
def main():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
r = 0
if False:
for i in range(K+1):
r += (A[-i-1] - A[i]) * cmb(N-i-1, K-1, mod)
else:
for i in range(N-K+1):
r += (A[N-i-1] - A[i]) * cmb(N-i-1, K-1, mod)
print((r % mod))
def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, 10 ** 6 + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
main()
|
p02804
|
n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
a.sort()
total = 0
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**5
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)
mem = {}
def cmb(n, r, mod):
if (n,r) not in mem:
mem[(n,r)] = _cmb(n, r, mod)
return mem[(n,r)]
for i in range(n-k+1):
for j in range(i+k-1,n):
total += cmb(j-i-1,k-2,mod)*(a[j]-a[i])
total %= mod
print(total)
|
n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
a.sort()
total = 0
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**5
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)
for i in range(n-k+1):
total += cmb(n-i-1,k-1,mod)*(a[n-i-1]-a[i])
total %= mod
print(total)
|
p02804
|
from itertools import permutations, combinations
n,k=list(map(int, input().split()))
c=combinations(list(map(int, input().split())),k)
t=sum( [max(v)-min(v) for v in list(c)] )
print((t%(10**9+7)))
|
from itertools import combinations
n,k=list(map(int, input().split()))
c=combinations(list(map(int, input().split())),k)
print((sum( [max(v)-min(v) for v in c] )%(10**9+7)))
|
p02804
|
H, K = list(map(int,input().split()))
A = list(map(int, input().split()))
mod = int(10**9) + 7
A.sort()
nCkminu1 = [1] * H
for n in range(K, H):
nCkminu1[n] = nCkminu1[n-1] * n // (n - (K-1))
ans = 0
for nCk, amin, amax in zip(nCkminu1[K-1:], A[:-(K-1)][::-1], A[K-1:]):
ans += nCk % mod * (amax - amin)
print((ans % mod))
|
H, K = list(map(int,input().split()))
A = list(map(int, input().split()))
mod = int(10**9) + 7
A.sort()
nCkminu1 = [1] * H
for n in range(K, H):
nCkminu1[n] = nCkminu1[n-1] * n // (n - (K-1))
nCkminu1[n-1] %= mod
ans = 0
for nCk, amin, amax in zip(nCkminu1[K-1:], A[:-(K-1)][::-1], A[K-1:]):
ans += nCk * (amax - amin)
print((ans % mod))
|
p02804
|
p = 1000000007
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
fac = [0] * (N + 1)
fac[0] = 1
for i in range(N):
fac[i + 1] = fac[i] * (i + 1) % p
def mcomb(n, k):
if n == 0 and k == 0:
return 1
if n < k or k < 0:
return 0
return fac[n] * pow(fac[n - k], p - 2, p) * pow(fac[k], p - 2, p) % p
A.sort(reverse=True)
result = 0
for i in range(N - K + 1):
result += A[i] * mcomb(N - (i + 1), K - 1)
result %= p
A.reverse()
for i in range(N - K + 1):
result -= A[i] * mcomb(N - (i + 1), K - 1)
result %= p
# result += p
# result %= p
print(result)
|
# フェルマーの小定理
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
m = 1000000007
fac = [0] * (N + 1)
fac[0] = 1
for i in range(N):
fac[i + 1] = fac[i] * (i + 1) % m
def mcomb(n, k):
if n == 0 and k == 0:
return 1
if n < k or k < 0:
return 0
return fac[n] * pow(fac[n - k], m - 2, m) * pow(fac[k], m - 2, m) % m
A.sort(reverse=True)
result = 0
for i in range(N - K + 1):
result += A[i] * mcomb(N - (i + 1), K - 1)
result %= m
A.sort()
t = 0
for i in range(N - K + 1):
t += A[i] * mcomb(N - (i + 1), K - 1)
t %= m
result -= t
result %= m
print(result)
|
p02804
|
# -*- coding: utf-8 -*-
class FactMod():
'''
modの値が素数の時のfactと組み合わせを求める
フェルマーの小定理を用いているため、modが素数以外の時は使えない
'''
def __init__(self, n, mod):
'''
コンストラクタ
f:nまでの i!の値を 配列に入れる
inv: (i!)^-1 の値を配列に入れる
'''
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 range(1, n+1)[::-1]:
self.inv.append(self.inv[-1]*i % mod)
self.inv.reverse()
def fact(self, n):
'''
n!の値を返す
'''
return self.f[n]
def comb(self, n, r):
'''
nCrの値を返す
'''
ret = self.f[n] * self.inv[n-r]*self.inv[r]
ret %= self.mod
return ret
def perm(self, n, r):
"""
nPrの値を返す
"""
ret = self.f[n] * self.inv[n-r]
ret %= self.mod
return ret
N, K = list(map(int, input().split()))
L = list(map(int, input().split()))
L = sorted(L)
MOD = 10**9+7
F = FactMod(N+1, MOD)
sub = 0
add = 0
for i in reversed(list(range(K-1, N))):
add += L[i]*F.comb(i, K-1)
sub += L[N-i-1]*F.comb(i, K-1)
print(((-sub+add+MOD) % MOD))
|
# -*- coding: utf-8 -*-
class FactMod():
'''
modの値が素数の時のfactと組み合わせを求める
フェルマーの小定理を用いているため、modが素数以外の時は使えない
'''
def __init__(self, n, mod):
'''
コンストラクタ
f:nまでの i!の値を 配列に入れる
inv: (i!)^-1 の値を配列に入れる
'''
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 range(1, n+1)[::-1]:
self.inv.append(self.inv[-1]*i % mod)
self.inv.reverse()
def fact(self, n):
'''
n!の値を返す
'''
return self.f[n]
def comb(self, n, r):
'''
nCrの値を返す
'''
ret = self.f[n] * self.inv[n-r]*self.inv[r]
ret %= self.mod
return ret
def perm(self, n, r):
"""
nPrの値を返す
"""
ret = self.f[n] * self.inv[n-r]
ret %= self.mod
return ret
N, K = list(map(int, input().split()))
L = list(map(int, input().split()))
L = sorted(L)
MOD = 10**9+7
F = FactMod(N+1, MOD)
print((sum([(L[i]-L[N-i-1]+MOD)*F.comb(i, K-1) % MOD
for i in reversed(list(range(K-1, N)))]) % MOD))
|
p02804
|
# 組み合わせ(高速，フェルマーの小定理を利用)
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 ** 5
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 )
mod = 10 ** 9 + 7
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
ans = 0
for i in range(N-K+1):
now_A = A[i]
tmp = 1
count = 0
for k in range(i+K-1, N):
ans += cmb(K-2+count, count, mod) * (A[k] - now_A)
ans %= mod
count += 1
print((ans%mod))
|
# 組み合わせ(高速，フェルマーの小定理を利用)
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 10 ** 5
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 )
mod = 10 ** 9 + 7
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
ans_max = 0
ans_min = 0
# ans_minを求める
for i in range(N-K+1):
ans_min += A[i] * cmb(N-1-i, K-1, mod)
ans_min %= mod
for i in range(K-1, N):
ans_max += A[i] * cmb(i, K-1, mod)
ans_max %= mod
##print(ans_max, ans_min)
print(((ans_max - ans_min + mod)%mod))
|
p02804
|
P = 10**9 + 7
N = 1000000
inv_t = [0]+[1]
for i in range(2,N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
A.sort()
mini_count = 0
maxim_count = 0
pattern = 1
for i in range(n-k, -1, -1):
mini = A[i]
mini_count += mini * pattern % mod
mini_count %= mod
pattern = pattern * (n-i) * inv_t[n-i-k+1] % mod
pattern = 1
for i in range(n-k+1, 0, -1):
maxim = A[-i]
maxim_count += maxim * pattern % mod
maxim_count %= mod
pattern = pattern * (n-i+1) * inv_t[n-i-k+2] % mod
ans = maxim_count - mini_count
ans %= mod
print(ans)
|
P = 10**9 + 7
N = 200000
inv_t = [0]+[1] # 逆元
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
A.sort()
mini_count = 0
maxim_count = 0
pattern = 1
"""
minX, maxXとして選ばれるのはそれぞれ
minX:sortAの右からk番目(大きい数値からk個取った時の最小値)とそれより左の要素
maxX:sortAの左からk番目(小さい数値からk個取った時の最大値)とそれより右の要素
選ばれるパターンはminXの場合自分の要素より右にある要素からk-1個を選ぶパターン数
つまり最初は(k-1)C(k-1) = 1
選べる要素が一つ増えるごとに
tC(k-1) ⇒ (t+1)C(k-1)のように増えるので
t * t-1 * t-2 ... * t-k ⇒ t+1 * t * t-1 ... * t-k+1 であり
つまりパターン数は (t+1) / (t-k) 倍になる
"""
for idx in range(k, n + 1):
mini = A[-idx] #
mini_count += mini * pattern % mod
mini_count %= mod
maxim = A[idx - 1]
maxim_count += maxim * pattern % mod
maxim_count %= mod
pattern = pattern * (idx) * inv_t[idx + 1 - k] % mod # 割り算のmodは逆元をかける
ans = maxim_count - mini_count
ans %= mod
print(ans)
|
p02804
|
P = 10**9 + 7
N = 200000
inv_t = [0]+[1] # 逆元
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
A.sort()
mini_count = 0
maxim_count = 0
pattern = 1
"""
minX, maxXとして選ばれるのはそれぞれ
minX:sortAの右からk番目(大きい数値からk個取った時の最小値)とそれより左の要素
maxX:sortAの左からk番目(小さい数値からk個取った時の最大値)とそれより右の要素
選ばれるパターンはminXの場合自分の要素より右にある要素からk-1個を選ぶパターン数
つまり最初は(k-1)C(k-1) = 1
選べる要素が一つ増えるごとに
tC(k-1) ⇒ (t+1)C(k-1)のように増えるので
t * t-1 * t-2 ... * t-k ⇒ t+1 * t * t-1 ... * t-k+1 であり
つまりパターン数は (t+1) / (t-k) 倍になる
"""
for idx in range(k, n + 1):
mini = A[-idx] #
mini_count += mini * pattern % mod
mini_count %= mod
maxim = A[idx - 1]
maxim_count += maxim * pattern % mod
maxim_count %= mod
pattern = pattern * (idx) * inv_t[idx + 1 - k] % mod # 割り算のmodは逆元をかける
ans = maxim_count - mini_count
ans %= mod
print(ans)
|
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
mod = 10 ** 9 + 7
P = 10**9 + 7
N = n-k+10
inv_t = [0]+[1] # 逆元
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
A.sort()
mini_count = 0
maxim_count = 0
pattern = 1
"""
minX, maxXとして選ばれるのはそれぞれ
minX:sortAの右からk番目(大きい数値からk個取った時の最小値)とそれより左の要素
maxX:sortAの左からk番目(小さい数値からk個取った時の最大値)とそれより右の要素
選ばれるパターンはminXの場合自分の要素より右にある要素からk-1個を選ぶパターン数
つまり最初は(k-1)C(k-1) = 1
選べる要素が一つ増えるごとに
tC(k-1) ⇒ (t+1)C(k-1)のように増えるので
t * t-1 * t-2 ... * t-k ⇒ t+1 * t * t-1 ... * t-k+1 であり
つまりパターン数は (t+1) / (t-k) 倍になる
"""
for idx in range(k, n + 1):
mini = A[-idx] #
mini_count += mini * pattern % mod
mini_count %= mod
maxim = A[idx - 1]
maxim_count += maxim * pattern % mod
maxim_count %= mod
pattern = pattern * (idx) * inv_t[idx + 1 - k] % mod # 割り算のmodは逆元をかける
ans = maxim_count - mini_count
ans %= mod
print(ans)
|
p02804
|
class BinomialCoefficient(object):
def __init__(self, N=510000, MOD=10**9+7):
self.fac = [1, 1]
self.finv = [1, 1]
self.inv = [0, 1]
self.MOD = MOD
for i in range(2, N + 1):
self.fac.append((self.fac[-1] * i) % MOD)
self.inv.append((-self.inv[MOD % i] * (MOD // i)) % MOD)
self.finv.append((self.finv[-1] * self.inv[-1]) % MOD)
def comb(self, n, r):
if r < 0 or n < r or r < 0:
return 0
return self.fac[n] * self.finv[r] * self.finv[n - r] % self.MOD
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
A.sort()
bc = BinomialCoefficient()
nCk = bc.comb(N, K)
ans = 0
for i in range(N - 1):
c = nCk - bc.comb(i + 1, K) - bc.comb((N - i - 1), K)
ans += c * (A[i + 1] - A[i]) % MOD
ans %= MOD
print(ans)
|
class BinomialCoefficient(object):
def __init__(self, N=510000, MOD=10**9+7):
self.fac = [1, 1]
self.finv = [1, 1]
self.inv = [0, 1]
self.MOD = MOD
for i in range(2, N + 1):
self.fac.append((self.fac[-1] * i) % MOD)
self.inv.append((-self.inv[MOD % i] * (MOD // i)) % MOD)
self.finv.append((self.finv[-1] * self.inv[-1]) % MOD)
def comb(self, n, r):
if r < 0 or n < r or r < 0:
return 0
return self.fac[n] * self.finv[r] * self.finv[n - r] % self.MOD
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
A.sort()
bc = BinomialCoefficient(N)
nCk = bc.comb(N, K)
ans = 0
for i in range(N - 1):
c = nCk - bc.comb(i + 1, K) - bc.comb((N - i - 1), K)
ans += c * (A[i + 1] - A[i]) % MOD
ans %= MOD
print(ans)
|
p02804
|
from bisect import bisect_right, bisect_left
class Combination:
def __init__(self, size, mod=10**9 + 7):
self.size = size + 2
self.mod = mod
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % self.mod
self.inv[i] = -self.inv[self.mod % i] * (self.mod // i) % self.mod
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % self.mod
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % self.mod
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % self.mod) % self.mod
def nhr(self, n, r): # 重複組合せ
return self.ncr(n + r - 1, n - 1)
def factN(self, n):
if n < 0:
return 0
return self.fact[n]
N, K = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(N + 100)
A = list(map(int, input().split()))
A.sort()
ans = 0
for i, a in enumerate(A):
mi = min(i, bisect_right(A, a) - 1)
mx = N - max(i + 1, bisect_left(A, a))
ans = (ans + (comb.ncr(mi, K - 1) - comb.ncr(mx, K - 1)) * a) % MOD
print(ans)
|
MOD = 10**9 + 7
class Combination:
def __init__(self, size):
self.size = size + 2
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % MOD
self.inv[i] = -self.inv[MOD % i] * (MOD // i) % MOD
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % MOD
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % MOD
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % MOD) % MOD
def nhr(self, n, r): # 重複組合せ: x_1 + ... + x_n = r
return self.ncr(n + r - 1, n - 1)
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(N + 10)
A.sort()
ans = 0
for i, a in enumerate(A):
mi = comb.ncr(N - i - 1, K - 1)
mx = comb.ncr(i, K - 1)
ans += (mx - mi) * a
ans %= MOD
print(ans)
|
p02804
|
MOD = 10**9 + 7
class Combination:
def __init__(self, size):
self.size = size + 2
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % MOD
self.inv[i] = -self.inv[MOD % i] * (MOD // i) % MOD
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % MOD
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % MOD
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % MOD) % MOD
def nhr(self, n, r): # 重複組合せ: x_1 + ... + x_n = r
return self.ncr(n + r - 1, n - 1)
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10**9 + 7
comb = Combination(N + 10)
A.sort()
ans = 0
for i, a in enumerate(A):
mi = comb.ncr(N - i - 1, K - 1)
mx = comb.ncr(i, K - 1)
ans += (mx - mi) * a
ans %= MOD
print(ans)
|
MOD = 10**9 + 7
class Combination:
def __init__(self, size):
self.size = size + 2
self.fact = [1, 1] + [0] * size
self.factInv = [1, 1] + [0] * size
self.inv = [0, 1] + [0] * size
for i in range(2, self.size):
self.fact[i] = self.fact[i - 1] * i % MOD
self.inv[i] = -self.inv[MOD % i] * (MOD // i) % MOD
self.factInv[i] = self.factInv[i - 1] * self.inv[i] % MOD
def npr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * self.factInv[n - r] % MOD
def ncr(self, n, r):
if n < r or n < 0 or r < 0:
return 0
return self.fact[n] * (self.factInv[r] * self.factInv[n - r] % MOD) % MOD
def nhr(self, n, r): # 重複組合せ: x_1 + ... + x_n = r
return self.ncr(n + r - 1, n - 1)
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
comb = Combination(N + 100)
A.sort()
ans = 0
for i, a in enumerate(A):
ans += a * comb.ncr(i, K - 1)
ans -= a * comb.ncr(N - i - 1, K - 1)
ans %= MOD
print(ans)
|
p02804
|
def comb(a,b,m):
if b == 0 or b == a:
ret = 1
else:
ret = 1
for i in range(a-b+1,a+1):
ret = (ret * i) % m
for i in range(1,b+1):
ret = (ret * pow(i,m-2,m) ) % m
return ret
mod = 10**9+7
n, k = [ int(v) for v in input().split() ]
num = sorted([ int(v) for v in input().split() ])
max_list2 = [ (i, i-k+1) for i in range(n) ]
max_list2 = [ comb(a, b, mod) if b >= 0 else 0 for a, b in max_list2 ]
min_list_2 = list(reversed(max_list2))
max_min_list = [ (max_list2[i] - min_list_2[i]) * num[i] for i in range(n) ]
print((sum(max_min_list) % mod))
|
mod = 10**9+7
n, k = [ int(v) for v in input().split() ]
num = sorted([ int(v) for v in input().split() ])
max_list2 = [ (i, i-k+1) for i in range(n) ]
max_list = []
for a, b in max_list2:
if b < 0:
max_list.append(0)
elif b == 0:
max_list.append(1)
else:
s = max_list[-1]
s *= a * pow(b, mod-2, mod)
max_list.append(s%mod)
min_list = list(reversed(max_list))
max_min_list = [ (max_list[i] - min_list[i]) * num[i] for i in range(n) ]
print((sum(max_min_list) % mod))
|
p02804
|
from math import factorial
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
mod = 10**9+7
if K==1:print((0))
else:
def comb(n,k):
return factorial(n)*pow(factorial(n-k)*factorial(k), -1, mod)
A1=sorted(A)
A2=A1[::-1]
ans=0
for i in range(N-K+1):
ans += (A2[i]-A1[i])*comb(N-i-1,K-1)
ans %= mod
print(ans)
|
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
mod = 10**9+7
if K==1:print((0))
else:
factorial=[1 for i in range(N+1)]
for i in range(1,N+1):
if i==1:factorial[i]=1
else:factorial[i] = factorial[i-1]*i % mod
def comb(n,k):
return factorial[n]*pow(factorial[n-k]*factorial[k], -1, mod)
A1=sorted(A)
A2=A1[::-1]
ans=0
for i in range(N-K+1):
ans += (A2[i]-A1[i])*comb(N-i-1,K-1)
ans %= mod
print(ans)
|
p02804
|
N, K = list(map(int,input().split()))
A = list(map(int,input().split()))
MAX = 10 ** 5 + 1
MOD = 10 ** 9 + 7
fac = [0] * (MAX + 1)
fac[0] = 1
fac[1] = 1
for i in range(2, MAX + 1):
fac[i] = fac[i - 1] * i % MOD
finv = [0] * (MAX + 1)
finv[MAX] = pow(fac[MAX], MOD - 2, MOD)
for i in range(MAX, 0, -1):
finv[i - 1] = finv[i] * i % MOD
def comb(n, k):
if n < k or k < 0:
return 0
return (fac[n] * finv[k] * finv[n - k]) % MOD
A.sort()
ans = 0
for i in range(N):
if i >= K - 1:
ans += comb(i, K - 1) * A[i]
if i + K - 1 < N:
ans -= comb(N - i - 1, K - 1) * A[i]
ans %= MOD
print(ans)
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
MAX = 10 ** 5 + 1
MOD = 10 ** 9 + 7
fac = [0]*(MAX+1)
fac[0] = 1
fac[1] = 1
for i in range(2,MAX+1):
fac[i] = fac[i-1]*i%MOD
finv = [0]*(MAX+1)
finv[MAX] = pow(fac[MAX], MOD-2, MOD)
for i in range(MAX, 0, -1):
finv[i-1] = finv[i] * i % MOD
def comb(n, k):
if n < k or k < 0:
return 0
return (fac[n] * finv[k] * finv[n - k]) % MOD
ans = 0
for i in range(N):
if K - 1 <= i:
ans += comb(i,K-1) * A[i]
if K-1+i < N:
ans -= comb(N-i-1,K-1)*A[i]
ans %= MOD
print(ans)
|
p02804
|
def power(a,n):
x=1
L=list(format(n,'b'))
l=len(L)
for i in range(l):
if int(L[l-i-1])==1:
x=(x*a)%(10**9+7)
a=(a*a)%(10**9+7)
return x
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
b=sorted(A)
c=sorted(A,reverse=True)
D=[]
M=0
for i in range(N-K+1):
x=1
y=1
for l in range(K-1):
x=(x*(N-i-1-l))%(10**9+7)
y=(y*(l+1))%(10**9+7)
y=power(y,10**9+5)
m=(x*y*(c[i]-b[i]))
if m>0:
m=m%(10**9+7)
M+=m
M%(10**9+7)
print((M%(10**9+7)))
|
def power(a,n):
x=1
L=list(format(n,'b'))
l=len(L)
for i in range(l):
if int(L[l-i-1])==1:
x=(x*a)%(10**9+7)
a=(a*a)%(10**9+7)
return x
N,K=list(map(int,input().split()))
A=list(map(int,input().split()))
b=sorted(A)
c=sorted(A,reverse=True)
D=[]
M=0
x=1
y=1
for l in range(K-1):
x=(x*(N-l-1))%(10**9+7)
y=(y*(l+1))%(10**9+7)
y=power(y,10**9+5)
M+=(x*y*(c[0]-b[0]))%(10**9+7)
for i in range(1,N-K+1):
y1=power(N-i,10**9+5)
x=(x*y1)%(10**9+7)
x=(x*(N-K-i+1))%(10**9+7)
m=(x*y*(c[i]-b[i]))
if m>0:
m=m%(10**9+7)
M+=m
M%(10**9+7)
print((M%(10**9+7)))
|
p02804
|
def cmb(n,r,mod):
a=1
b=1
r = min(r,n-r)
for i in range(r):
a = a*(n-i)%mod
b = b*(i+1)%mod
return a*pow(b,mod-2,mod)%mod
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
mod = 10**9+7
ans = 0
if K == 1:
print((0))
else:
for i in range(0,N-K+1):
ans -= A[i]*cmb(N-i-1,K-1,10**9+7)
for i in range(K-1,N):
ans += A[i]*cmb(i,K-1,10**9+7)
print((ans%mod))
|
# kurimu_usamaro様のメソッドを拝借しています。
class Combi():
def __init__(self, N, mod):
self.power = [1 for _ in range(N+1)]
self.rev = [1 for _ in range(N+1)]
self.mod = mod
for i in range(2, N+1):
self.power[i] = (self.power[i-1]*i) % self.mod
self.rev[N] = pow(self.power[N], self.mod-2, self.mod)
for j in range(N, 0, -1):
self.rev[j-1] = (self.rev[j]*j) % self.mod
def com(self, K, R):
if K < R:
return 0
else:
return ((self.power[K])*(self.rev[K-R])*(self.rev[R])) % self.mod
def pom(self, K, R):
if K < R:
return 0
else:
return (self.power[K])*(self.rev[K-R]) % self.mod
def main():
mod = 10**9+7
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
c = Combi(N,mod)
ans = 0
if K == 1:
print((0))
else:
for i, a in enumerate(A):
ans += c.com(i, K-1)*a
ans -= c.com(N-1-i, K-1)*a
ans %= mod
print((ans%mod))
if __name__ == "__main__":
main()
|
p02804
|
def COMint():
fac[0]=1
fac[1]=1
finv[0]=1
finv[1]=1
inv[1]=1
for i in range(2,N+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,k):
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
MOD=10**9+7
N,K=[int(x) for x in input().split()]
A= [int(x) for x in input().split()]
A= sorted(A)
fac=[0]*(N+1)
inv=[0]*(N+1)
finv=[0]*(N+1)
COMint()
ans=0
#print(fac)
for j in range(N-1,-1,-1):
for i in range(j-K+2):
mi = A[i]
ma = A[j]
#print(ma,mi,i,j,L[j-i-1])
# print(j-i-1,com(j-i-1,K-2))
ans+=(ma-mi)*com(j-i-1,K-2)
print((ans%(10**9+7)))
|
def COMint():
fac[0]=1
fac[1]=1
finv[0]=1
finv[1]=1
inv[1]=1
for i in range(2,N+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,k):
if n<k:
return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
MOD=10**9+7
N,K=[int(x) for x in input().split()]
A= [int(x) for x in input().split()]
A= sorted(A)
fac=[0]*(N+1)
inv=[0]*(N+1)
finv=[0]*(N+1)
COMint()
ans=0
#print(fac)
for j in range(N):
ans+=(A[j])*com(j,K-1)
ans-=(A[j])*com(N-1-j,K-1)
print((ans%(10**9+7)))
|
p02804
|
MOD = 10**9+7
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort(reverse=True)
f = [1]
for i in range(10**5+7):
f.append(f[-1]*(i+1)%MOD)
def nCr(n, r, mod=MOD):
return f[n] * pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod
ans = 0
for i in range(N-K+1):
ans += (A[i] - A[-1-i]) * nCr(N-1-i, K-1)
ans %= MOD
print(ans)
|
MOD = 10**9+7
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
f = [1]
for i in range(10**5):
f.append(f[-1] * (i+1) % MOD)
def nCr(n, r, mod=MOD):
return f[n] * pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod
ans = 0
for i in range(N-K+1):
ans -= (A[i] - A[-1-i]) * nCr(N-1-i, K-1)
ans %= MOD
print(ans)
|
p02804
|
MOD = 10**9+7
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
f = [1]
for i in range(10**5):
f.append(f[-1] * (i+1) % MOD)
def nCr(n, r, mod=MOD):
return f[n] * pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod
ans = 0
for i in range(N-K+1):
ans += (A[-1-i] - A[i]) * nCr(N-1-i, K-1)
ans %= MOD
print(ans)
|
import sys
readline = sys.stdin.buffer.readline
MOD = 10**9+7
N, K = list(map(int, readline().split()))
A = list(map(int, readline().split()))
A.sort()
f = [1]
for i in range(10**5):
f.append(f[-1] * (i+1) % MOD)
def nCr(n, r, mod=MOD):
return f[n] * pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod
ans = 0
for i in range(N-K+1):
ans += (A[-1-i] - A[i]) * nCr(N-1-i, K-1)
ans %= MOD
print(ans)
|
p02804
|
import sys
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
#import numpy as np
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
def main():
n,k=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
ans=0
for i in range(n-k+1):
ans+=((comb(k-1+i,k-1,mod)*A[k-1+i])-(comb(k-1+i,k-1,mod)*A[n-k-i]))%mod
ans=ans%mod
print(ans)
if __name__ == "__main__":
main()
|
import sys
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
#import numpy as np
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 main():
n,k=list(map(int,input().split()))
A=list(map(int,input().split()))
A.sort()
comb=[1]
for i in range(n-k):
comb.append((comb[-1]*(k+i)*pow(i+1,mod-2,mod))%mod)
ans=0
for i in range(n-k+1):
ans+=((comb[i]*A[k-1+i])-(comb[i]*A[n-k-i]))%mod
ans=ans%mod
print(ans)
if __name__ == "__main__":
main()
|
p02804
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
mod=10**9+7
def modfc(x,y,p):
f=1
for i in range(x,y+1):
f=f%p*i%p
return f%p
def comb(x,y,p):
return modfc(x-y+1,x,p)*pow(modfc(1,y,p),p-2,p)
maxs=0
for i in range(k,n+1):
maxs+=a[i-1]*comb(i-1,k-1,mod)
maxs%=mod
mins=0
for i in range(n-k+1):
mins+=a[i]*comb(n-i-1,k-1,mod)
mins%=mod
ans=(maxs-mins)%mod
print((ans+mod if ans<0 else ans))
|
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
mod=10**9+7
fcl=[1]*(n+1)
for i in range(1,n+1):
fcl[i]=(fcl[i-1]*i)%mod
def comb(x,y,p):
return ((fcl[x]*pow(fcl[y],p-2,p))%mod*pow(fcl[x-y],p-2,p))%mod
maxs=0
for i in range(k,n+1):
maxs+=a[i-1]*comb(i-1,k-1,mod)
maxs%=mod
mins=0
for i in range(n-k+1):
mins+=a[i]*comb(n-i-1,k-1,mod)
mins%=mod
ans=(maxs-mins)%mod
print((ans+mod if ans<0 else ans))
|
p02804
|
N_MAX = 10**6
MOD = 10**9 + 7
fac, finv, inv = [0]*N_MAX ,[0]*N_MAX, [0]*N_MAX
def com_init():
fac[0], fac[1] = 1, 1
finv[0], finv[1] = 1, 1
inv[1] = 1
for i in range(2, N_MAX):
fac[i] = fac[i - 1] * i % MOD
inv[i] = MOD - inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
def com(n, k):
if n < k: return 0
if n < 0 or k < 0: return 0
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD
n,k = list(map(int, input().split()))
al = list(map(int, input().split()))
com_init()
al.sort()
ans_max = 0
ans_min = 0
for i,a in enumerate(al):
ans_max += a*com(i,k-1)
ans_max%=MOD
ans_min += a*com(n-1-i,k-1)
ans_min%=MOD
print(((ans_max-ans_min)%MOD))
|
class Combination:
def __init__(self, n_max=10**6, mod=10**9+7):
# self._n_max = n_max
self._fac, self._finv, self._inv = [0]*n_max, [0]*n_max, [0]*n_max
self._fac[0], self._fac[1] = 1, 1
self._finv[0], self._finv[1] = 1, 1
self._inv[1] = 1
for i in range(2, n_max):
self._fac[i] = self._fac[i - 1] * i % MOD
self._inv[i] = MOD - self._inv[MOD%i] * (MOD // i) % MOD
self._finv[i] = self._finv[i - 1] * self._inv[i] % MOD
def com(self, n, r):
if n < r: return 0
if n < 0 or r < 0: return 0
return self._fac[n] * (self._finv[r] * self._finv[n - r] % MOD) % MOD
MOD = 10**9+7
# comb.com(10,3)
comb = Combination(10**5+1, MOD)
n,k = list(map(int, input().split()))
al=list(map(int, input().split()))
al.sort(reverse=True)
fmax = 0
for i,a in enumerate(al):
cnt = comb.com(n-i-1,k-1)
fmax += cnt*a
fmax%=MOD
al.sort()
fmin = 0
for i,a in enumerate(al):
cnt = comb.com(n-i-1,k-1)
fmin += cnt*a
fmin%=MOD
ans = fmax-fmin
ans%=MOD
print(ans)
|
p02804
|
class Combinatorics:
def __init__(self, N, mod):
'''
Preprocess for calculating binomial coefficients nCr (0 <= r <= n, 0 <= n <= N)
over the finite field Z/(mod)Z.
Input:
N (int): maximum n
mod (int): a prime number. The order of the field Z/(mod)Z over which nCr is calculated.
'''
self.mod = mod
self.fact = {i: None for i in range(N+1)} # n!
self.inverse = {i: None for i in range(1, N+1)} # inverse of n in the field Z/(MOD)Z
self.fact_inverse = {i: None for i in range(N+1)} # inverse of n! in the field Z/(MOD)Z
# preprocess
self.fact[0] = self.fact[1] = 1
self.fact_inverse[0] = self.fact_inverse[1] = 1
self.inverse[1] = 1
for i in range(2, N+1):
self.fact[i] = i * self.fact[i-1] % self.mod
q, r = divmod(self.mod, i)
self.inverse[i] = (- (q % self.mod) * self.inverse[r]) % self.mod
self.fact_inverse[i] = self.inverse[i] * self.fact_inverse[i-1] % self.mod
def perm(self, n, r):
'''
Calculate nPr = n! / (n-r)! % mod
'''
if n < r or n < 0 or r < 0:
return 0
else:
return (self.fact[n] * self.fact_inverse[n-r]) % self.mod
def binom(self, n, r):
'''
Calculate nCr = n! /(r! (n-r)!) % mod
'''
if n < r or n < 0 or r < 0:
return 0
else:
return self.fact[n] * (self.fact_inverse[r] * self.fact_inverse[n-r] % self.mod) % self.mod
def hom(self, n, r):
'''
Calculate nHr = {n+r-1}Cr % mod.
Assign r objects to one of n classes.
Arrangement of r circles and n-1 partitions:
o o o | o o | | | o | | | o o | | o
'''
if n == 0 and r > 0:
return 0
if n >= 0 and r == 0:
return 1
return self.binom(n + r - 1, r)
MOD = 10**9 + 7
N, K = list(map(int, input().split()))
*A, = list(map(int, input().split()))
if K == 1:
print((0))
else:
A = sorted(A)
com = Combinatorics(N, MOD)
ans = 0
for i in range(N-K+1):
min_S = A[i]
for j in range(i+K-1, N):
max_S = A[j]
ans += (max_S - min_S) * com.binom(j - i - 1, K - 2)
ans %= MOD
print(ans)
|
class Combinatorics:
def __init__(self, N, mod):
'''
Preprocess for calculating binomial coefficients nCr (0 <= r <= n, 0 <= n <= N)
over the finite field Z/(mod)Z.
Input:
N (int): maximum n
mod (int): a prime number. The order of the field Z/(mod)Z over which nCr is calculated.
'''
self.mod = mod
self.fact = {i: None for i in range(N+1)} # n!
self.inverse = {i: None for i in range(1, N+1)} # inverse of n in the field Z/(MOD)Z
self.fact_inverse = {i: None for i in range(N+1)} # inverse of n! in the field Z/(MOD)Z
# preprocess
self.fact[0] = self.fact[1] = 1
self.fact_inverse[0] = self.fact_inverse[1] = 1
self.inverse[1] = 1
for i in range(2, N+1):
self.fact[i] = i * self.fact[i-1] % self.mod
q, r = divmod(self.mod, i)
self.inverse[i] = (- (q % self.mod) * self.inverse[r]) % self.mod
self.fact_inverse[i] = self.inverse[i] * self.fact_inverse[i-1] % self.mod
def perm(self, n, r):
'''
Calculate nPr = n! / (n-r)! % mod
'''
if n < r or n < 0 or r < 0:
return 0
else:
return (self.fact[n] * self.fact_inverse[n-r]) % self.mod
def binom(self, n, r):
'''
Calculate nCr = n! /(r! (n-r)!) % mod
'''
if n < r or n < 0 or r < 0:
return 0
else:
return self.fact[n] * (self.fact_inverse[r] * self.fact_inverse[n-r] % self.mod) % self.mod
def hom(self, n, r):
'''
Calculate nHr = {n+r-1}Cr % mod.
Assign r objects to one of n classes.
Arrangement of r circles and n-1 partitions:
o o o | o o | | | o | | | o o | | o
'''
if n == 0 and r > 0:
return 0
if n >= 0 and r == 0:
return 1
return self.binom(n + r - 1, r)
MOD = 10**9 + 7
N, K = list(map(int, input().split()))
*A, = list(map(int, input().split()))
A = sorted(A)
com = Combinatorics(N, MOD)
ans = 0
for i, a in enumerate(A):
ans = (ans + a * com.binom(i, K-1)) % MOD
ans = (ans - a * com.binom(N-i-1, K-1)) % MOD
print(ans)
|
p02804
|
N, K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
MOD = 10**9+7
fac = [0]*(N+1) # 階乗テーブル
fac[0] = fac[1] = 1
inv = [0]*(N+1) # 逆元テーブル
inv[1] = 1
facinv = [0]*(N+1) # 階乗の逆元テーブル
facinv[0] = facinv[1] = 1
for i in range(2,N+1):
fac[i] = fac[i-1]*i%MOD
inv[i] = MOD - inv[MOD%i] * (MOD//i) % MOD
facinv[i] = facinv[i-1] * inv[i] % MOD
def nCr(n,r):
if n < r or n < 0 or r < 0:return 0
else:return fac[n] * (facinv[r] * facinv[n-r] % MOD) % MOD
# 各要素が最大値、最小値として何回使われるか考える
maxsum = 0
minsum = 0
for i,a in enumerate(A):
maxsum += nCr(i,K-1)*a
maxsum %= MOD
minsum += nCr(N-i-1,K-1)*a
minsum %= MOD
ans = (maxsum-minsum)%MOD
print(ans)
|
N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
A.sort()
MOD = 10**9+7
# 各aが何回最大最小として選ばれるか考える
ans = 0
class Combination:
def __init__(self, n_max, mod=10**9+7):
self.mod = mod
self.modinv = self.make_modinv_list(n_max)
self.fac, self.facinv = self.make_factorial_list(n_max)
def __call__(self, n, r):
return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod
def make_factorial_list(self, n):
# 階乗のリストと階乗のmod逆元のリストを返す O(n)
# self.make_modinv_list()が先に実行されている必要がある
fac = [1]
facinv = [1]
for i in range(1, n+1):
fac.append(fac[i-1] * i % self.mod)
facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
return fac, facinv
def make_modinv_list(self, n):
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
return modinv
comb = Combination(N+1)
for i in range(N):
if i >= K-1:
ans += (A[i] * comb(i,K-1))%MOD
ans %= MOD
for i in range(N):
if i <= N-K:
ans -= (A[i] * comb(N-1-i,K-1))%MOD
ans %= MOD
print(ans)
|
p02804
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
kai = [1]
for i in range(1, N + 1):
kai.append(kai[-1] * i)
def comb(n, r):
return kai[n] // (kai[n - r] * kai[r])
if K >= 2:
A.sort(reverse = True)
ans = 0
for i in range(N - K + 1):
for j in range(i + K - 1, N):
ans += (A[i] - A[j]) * comb(j - i - 1, max(0, K - 2))
ans %= MOD
print(ans)
else:
print((0))
|
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
MOD = 10 ** 9 + 7
kai1 = [1, 1]
kai2 = [1, 1]
inverse = [0, 1]
for i in range(2, N + 1):
kai1.append((kai1[-1] * i) % MOD)
inverse.append((-inverse[MOD % i] * (MOD // i)) % MOD)
kai2.append((kai2[-1] * inverse[-1]) % MOD)
def comb(n, r):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return (kai1[n] * kai2[r] * kai2[n - r]) % MOD
if K >= 2:
A.sort(reverse = True)
ans = 0
for i in range(N - K + 1):
for j in range(i + K - 1, N):
ans += (A[i] - A[j]) * comb(j - i - 1, max(0, K - 2))
ans %= MOD
print(ans)
else:
print((0))
|
p02804
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
a2 = []
for i, x in enumerate(a):
a2.append((x, i))
from math import factorial
def c(n, r):
if n - r < 0:
return 0
return factorial(n) // factorial(r) // factorial(n - r)
ma = 0
mi = 0
for i in range(n):
ma += a[i] * c(i, k - 1)
mi += a[i] * c(n - i - 1, k - 1)
MOD = 10**9 + 7
print(((ma - mi) % MOD))
|
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
a2 = []
for i, x in enumerate(a):
a2.append((x, i))
from math import factorial
def c(n, r):
if n - r < 0:
return 0
return factorial(n) // factorial(r) // factorial(n - r)
MOD = 10**9 + 7 # 出力の制限
# https://qiita.com/derodero24/items/91b6468e66923a87f39f
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
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)
ma = 0
mi = 0
for i in range(n):
ma += a[i] * cmb(i, k - 1)
mi += a[i] * cmb(n - i - 1, k - 1)
print(((ma - mi) % MOD))
|
p02804
|
from functools import lru_cache
@lru_cache(None)
def factrial(n):
ans = 1
for i in range(1, n+1):
ans *= i
return ans
@lru_cache(None)
def combinations(n, r,mod):
return (factrial(n) // (factrial(n - r) * factrial(r))) % mod
def main():
n, k = list(map(int, input().split()))
mod = 10 ** 9 + 7
A = tuple([x % mod for x in sorted(map(int, input().split()))])
ans = 0
for i, a in enumerate(A[k - 1:], k - 1):
ans += (a * combinations(i, k - 1,mod)) % mod
ans %= mod
for i, a in enumerate(A[: n - k + 1], 1):
ans -= (a * combinations(n - i, k - 1,mod)) % mod
ans %= mod
print(ans)
if __name__ == "__main__":
main()
|
from functools import lru_cache
n, k = list(map(int, input().split()))
A = sorted(map(int, input().split()))
mod = 10 ** 9 + 7
# 階乗とその逆元の計算
factrial = [0 for _ in range(n + 1)]
factrial[0] = 1
for i in range(1, n + 1):
factrial[i] = (factrial[i - 1] * i) % mod
inverse_factrial = list()
for f in factrial:
inverse_factrial.append(pow(f, -1, mod))
@lru_cache(maxsize=None)
def nCr(n, r):
return (factrial[n] * inverse_factrial[r] * inverse_factrial[n - r]) % mod
ans = 0
# 最大値の和
for i, a in enumerate(A[k - 1:], k - 1):
ans += ((a % mod) * nCr(i, k-1)) % mod
ans %= mod
# 最小値の和
A.reverse()
for i, a in enumerate(A[k - 1:], k - 1):
ans -= ((a % mod) * nCr(i, k-1)) % mod
ans %= mod
print(ans)
|
p02804
|
import math
N, K = list(map(int, input().split()))
A = sorted(list(map(int, input().split())))
Ar = A[::-1]
Ai = [Ar[i] - A[i] for i in range(N)]
ans = 0
if K > N//2:
n, r = N-1, K-1
C = math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
for i in range(N-K+1):
ans += Ai[i] * C
C *= N-i-K
if N-i-1 != 0:
C //= N-i-1
else:
C = 1
for i in range(N-K, -1, -1):
ans += Ai[i] * C
C *= N - i
if N-K+1 - i != 0:
C //= N-K+1 - i
print((ans % 1000000007))
|
N, K = list(map(int, input().split()))
MOD = 10**9+7
A = [a % MOD for a in sorted(list(map(int, input().split())))]
MIN, MAX = 0, 0
def div_MOD(a): # (a^{-1} mod MOD) をフェルマーの小定理より求める
return pow(a, MOD - 2, MOD) # a^{-1} = a^{p-2} (mod p)
C = [0]*(K-1) + [1]
for n in range(K, N):
C.append((C[n-1] * n * div_MOD(n-(K-1))) % MOD)
for i in range(N-K+1):
MIN = (MIN + (A[i] * C[N-i-1]) % MOD) %MOD
for i in range(N-K+1):
MAX = (MAX + (A[N-1-i] * C[N-i-1]) % MOD) %MOD
print(((MAX - MIN) % MOD))
|
p02804
|
def prepare(N, MOD):
fac = [None] * (N+2)
finv = [None] * (N+2)
inv = [None] * (N+2)
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 % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
return fac, finv
def combination(N, K, fac, finv, MOD):
if N < K:
return 0
if N < 0 or K < 0:
return 0
else:
return fac[N] * (finv[K] * finv[N - K] % MOD) % MOD
MOD = 10 ** 9 + 7
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
ans = 0
for i in range(N):
fac, finv = prepare(i, MOD)
comb = combination(i, K-1, fac, finv, MOD)
ans += A[i] * comb
A.sort(reverse=True)
for i in range(N):
fac, finv = prepare(i, MOD)
comb = combination(i, K-1, fac, finv, MOD)
ans -= A[i] * comb
ans %= MOD
print(ans)
|
def prepare(N, MOD):
fac = [None] * (N+2)
finv = [None] * (N+2)
inv = [None] * (N+2)
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 % MOD
inv[i] = MOD - inv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * inv[i] % MOD
return fac, finv
def combination(N, K, fac, finv, MOD):
if N < K:
return 0
if N < 0 or K < 0:
return 0
else:
return fac[N] * (finv[K] * finv[N - K] % MOD) % MOD
MOD = 10 ** 9 + 7
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
fac, finv = prepare(N, MOD)
ans = 0
for i in range(N):
comb = combination(i, K-1, fac, finv, MOD)
ans += A[i] * comb
A.sort(reverse=True)
for i in range(N):
comb = combination(i, K-1, fac, finv, MOD)
ans -= A[i] * comb
ans %= MOD
print(ans)
|
p02804
|
"""
ジャガー「わからん」
先にmax,minそれぞれの和を求める
"""
import sys
input = sys.stdin.readline
mod = 10**9+7
def getComb(n, k, MOD):
if n < k:
return 0
if n-k < k:
k = n-k
# n!/(n-k)!
comb = 1
for x in range(n-k+1, n+1):
comb = (comb * x) % MOD
# k!
d = 1
for x in range(1, k+1):
d = (d * x) % MOD
# n!/((n-k)!*k!)
comb *= pow(d, MOD-2, MOD)
return comb % MOD
def main():
N,K = list(map(int,input().split()))
A = sorted([int(i) for i in input().split()])
cmb = [0] * (N-K+1)
for i in range(N-K+1):
cmb[i] = getComb(i+(K-1),K-1,mod)
sum_min = 0
sum_max = 0
for i in range(N):
if i >= K-1:
sum_max = (sum_max + (cmb[i-(K-1)] * A[i]) % mod) % mod
if i <= N-K:
sum_min = (sum_min + (cmb[(N-K)-i] * A[i]) % mod) % mod
answer = (sum_max - sum_min) % mod
print(answer)
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
def getComb(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
N,K = list(map(int,input().split()))
A = sorted([int(i) for i in input().split()])
# ref: https://www.planeta.tokyo/entry/5195/
mod = 10**9+7
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2,N+1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
cmb = [0] * (N-K+1)
for i in range(N-K+1):
cmb[i] = getComb(i+(K-1),K-1,mod)
sum_max = 0
for i in range(K-1,N):
sum_max = (sum_max + cmb[i-(K-1)] * A[i]) % mod
sum_min = 0
for i in range(N-K,-1,-1):
sum_min = (sum_min + cmb[(N-K)-i] * A[i]) % mod
answer = sum_max - sum_min
print((answer % mod))
|
p02804
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
def getComb(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
N,K = list(map(int,input().split()))
A = sorted([int(i) for i in input().split()])
# ref: https://www.planeta.tokyo/entry/5195/
mod = 10**9+7
fact = [1, 1]
factinv = [1, 1]
inv = [0, 1]
for i in range(2,N+1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
cmb = [0] * (N-K+1)
for i in range(N-K+1):
cmb[i] = getComb(i+(K-1),K-1,mod)
sum_max = 0
for i in range(K-1,N):
sum_max = (sum_max + cmb[i-(K-1)] * A[i]) % mod
sum_min = 0
for i in range(N-K,-1,-1):
sum_min = (sum_min + cmb[(N-K)-i] * A[i]) % mod
answer = sum_max - sum_min
print((answer % mod))
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
class Combination():
# コンストラクタ
def __init__(self, N:int, P:int):
self.N = N
self.P = P
# fact[i] = (i! mod P)
self.fact = [1, 1]
# factinv[i] = ((i!)^(-1) mod P)
self.factinv = [1, 1]
# factinv 計算用
self.inv = [0, 1]
for i in range(2, N+1):
self.fact.append((self.fact[-1] * i) % P)
self.inv.append((-self.inv[P % i] * (P // i)) % P)
self.factinv.append((self.factinv[-1] * self.inv[-1]) % P)
# nCk (mod P) (ただし、n<=N)
def getComb(self, n:int, k:int):
if (k < 0) or (n < k):
return 0
k = min(k, n - k)
return self.fact[n] * self.factinv[k] * self.factinv[n-k] % self.P
def main():
N,K = list(map(int,input().split()))
A = sorted([int(i) for i in input().split()])
mod = 10**9+7
COMB = Combination(N,mod)
cmb = [0] * (N-K+1)
for i in range(N-K+1):
cmb[i] = COMB.getComb(i+(K-1),K-1)
sum_max = 0
for i in range(K-1,N):
sum_max = (sum_max + cmb[i-(K-1)] * A[i]) % mod
sum_min = 0
for i in range(N-K,-1,-1):
sum_min = (sum_min + cmb[(N-K)-i] * A[i]) % mod
answer = sum_max - sum_min
print((answer % mod))
if __name__ == "__main__":
main()
|
p02804
|
from math import factorial
p=10**9+7
n,k=list(map(int,input().split()))
A=[int(i) for i in input().split()]
A.sort()
def nck(n,k):
return factorial(n)//factorial(n-k)//factorial(k)
ans=0
if k==1:
ans=0
else:
for i in range(n):
for j in range(k-1,n-i):
ans+=(A[i+j]-A[i])*nck(j-1,k-2)
ans=ans%p
print(ans)
|
n,k=list(map(int,input().split()))
arr=[int(i) for i in input().split()]
arr.sort()
mod=10**9+7
#nCk
factorial=[1]
for i in range(1, n+1):
factorial.append(factorial[-1] * i % mod)
inv_factorial = [-1] * (n+1)
inv_factorial[-1] = pow(factorial[-1], mod-2, mod)
for i in reversed(list(range(n))):
inv_factorial[i] = inv_factorial[i+1] * (i+1) % mod
def fact(n):
return factorial[n]
def nck(n, k):
if k>n or k<0:
return 0
else:
return factorial[n] * inv_factorial[n-k] * inv_factorial[k] %mod
m=0
for i in range(n):
m%=mod
m+=arr[i]*nck(n-i-1, k-1)
M=0
for i in range(n-1, -1, -1):
M%=mod
M+=arr[i]*nck(i, k-1)
print(((M-m)%mod))
|
p02804
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.