input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import heapq
import sys
from collections import deque
input=sys.stdin.readline
n=int(eval(input()))
a=[int(i) for i in input().split()]
#f=[-i for i in a[:n]]
f=a[:n]
l=[-i for i in a[2*n:]]
heapq.heapify(f)
heapq.heapify(l)
fs=[0]*(n+1)
ls=[0]*(n+1)
fs[0]=sum(f)
ls[n]=-sum(l)
for i in range(n):
c=a[n+i]
m=heapq.heappushpop(f,c)
fs[i+1]=fs[i]+c-m
# print(f,c,m)
for i in range(n):
c=a[2*n-1-i]
m=heapq.heappushpop(l,-c)
ls[n-i-1]=ls[n-i]+c+m
# print(l,-c,m)
ans=fs[0]-ls[0]
for k in range(n+1):
ans=max(ans,fs[k]-ls[k])
print(ans)#,a,n,fs,ls)
| import heapq
n=int(eval(input()))
a=[int(i) for i in input().split()]
f=a[:n]
l=[-i for i in a[2*n:]]
heapq.heapify(f)
heapq.heapify(l)
fs=[0]*(n+1)
ls=[0]*(n+1)
fs[0]=sum(f)
ls[n]=-sum(l)
for i in range(n):
c=a[n+i]
m=heapq.heappushpop(f,c)
fs[i+1]=fs[i]+c-m
for i in range(n):
c=a[2*n-1-i]
m=heapq.heappushpop(l,-c)
ls[n-i-1]=ls[n-i]+c+m
ans=fs[0]-ls[0]
for k in range(n+1):
ans=max(ans,fs[k]-ls[k])
print(ans)
| p03716 |
import heapq
N = int(eval(input()))
A = list(map(int, input().split()))
left = A[:N]
lefty = sum(left)
right = [-A[i] for i in range(3*N-1, 2*N-1, -1)]
righty = sum(right)
left_list = [lefty]
right_list = [righty]
heapq.heapify(left)
heapq.heapify(right)
for i in range(N, 2*N):
heapq.heappush(left, A[i])
x = heapq.heappop(left)
lefty += A[i] - x
left_list.append(lefty)
for i in range(2*N-1, N-1, -1):
heapq.heappush(right, -A[i])
y = heapq.heappop(right)
righty += -A[i] - y
right_list.append(righty)
ans = - float('inf')
for i in range(len(left_list)):
ans = max(ans, left_list[i]+right_list[len(right_list)-1-i])
print(ans)
| import heapq
N = int(eval(input()))
A = list(map(int, input().split()))
# L = heapq.heapify(A[:N])
# R = heapq.heapify(A[2*N:]) この記法ないらしい
# BC125C の累積GCDの直後にやっているので、似たやり方で解いてみる
L = A[:N]
R = [-a for a in A[2*N:]]
L_sum, R_sum = sum(L), sum(R)
heapq.heapify(L)
heapq.heapify(R)
L_acc = [L_sum]
R_acc = [R_sum]
for i in range(N, 2*N):
if L[0] >= A[i]:
if i > N:
L_acc.append(L_acc[-1])
elif i == N:
pass
else:
heapq.heappush(L, A[i])
out = heapq.heappop(L)
L_acc.append(L_acc[-1] - out + A[i])
#print(L_acc)
for i in range(2*N-1, N-1, -1):
if R[0] >= -A[i]:
if i <= 2*N-1:
R_acc.append(R_acc[-1])
elif i == 2*N-1:
pass
else:
heapq.heappush(R, -A[i])
out = heapq.heappop(R)
R_acc.append(R_acc[-1] - out - A[i])
#print(R_acc)
ans = -float('inf')
for i in range(len(L_acc)):
ans = max(ans, L_acc[i]+R_acc[-(i+1)])
print(ans) | p03716 |
import heapq
N = int(eval(input()))
a = list(map(int, input().split()))
m = len(a) // 2
cumsumA = []
prefix = [x for x in a[:N]]
heapq.heapify(prefix)
cumsumA.append(sum(prefix))
for k in range(N, 2*N):
heapq.heappush(prefix, a[k])
heapq.heappop(prefix)
cumsumA.append(sum(prefix))
cumsumB = []
suffix = [-x for x in a[2*N:]]
heapq.heapify(suffix)
cumsumB.append(-sum(suffix))
for k in range(2*N-1, N-1, -1):
heapq.heappush(suffix, -a[k])
heapq.heappop(suffix)
cumsumB.append(-sum(suffix))
res = -float('inf')
for i in range(0, len(cumsumA)):
res = max(res, cumsumA[i] - cumsumB[len(cumsumA)-i-1])
print(res)
| import heapq
N = int(eval(input()))
a = list(map(int, input().split()))
m = len(a) // 2
cumsumA = []
prefix = [x for x in a[:N]]
heapq.heapify(prefix)
cumsumA.append(sum(prefix))
cursum = sum(prefix)
for k in range(N, 2*N):
heapq.heappush(prefix, a[k])
ele = heapq.heappop(prefix)
cursum = cursum + a[k] - ele
cumsumA.append(cursum)
# cumsumA.append(sum(prefix))
cumsumB = []
suffix = [-x for x in a[2*N:]]
heapq.heapify(suffix)
cumsumB.append(-sum(suffix))
cursum = -sum(suffix)
for k in range(2*N-1, N-1, -1):
heapq.heappush(suffix, -a[k])
ele = heapq.heappop(suffix)
cursum = cursum + a[k] + ele
cumsumB.append(cursum)
res = -float('inf')
for i in range(0, len(cumsumA)):
res = max(res, cumsumA[i] - cumsumB[len(cumsumA)-i-1])
print(res) | p03716 |
import heapq
def solve(n,a):
res = -float('inf')
for k in range(n,2*n+1):
a1 = a[:k]
a2 = [-a[i] for i in range(k,3*n)]
heapq.heapify(a1)
heapq.heapify(a2)
while len(a1) > n:
heapq.heappop(a1)
while len(a2) > n:
heapq.heappop(a2)
tmp = sum(a1) + sum(a2)
res = max(res,tmp)
return res
if __name__ == '__main__':
n = int(eval(input()))
a = list(map(int,input().split()))
print((solve(n,a))) | import heapq
def solve(n,a):
a1 = a[:n]
a2 = [-a[i] for i in range(2*n,3*n)]
l = [[0,0] for i in range(n+1)]
heapq.heapify(a1)
heapq.heapify(a2)
l[0][0] = sum(a1)
l[n][1] = sum(a2)
for k in range(n,2*n):
heapq.heappush(a1,a[k])
tmp = heapq.heappop(a1)
l[k-n+1][0] = l[k-n][0] + a[k] - tmp
heapq.heappush(a2,-a[3*n-k-1])
tmp = heapq.heappop(a2)
l[2*n-k-1][1] = l[2*n-k][1] - a[3*n-k-1] - tmp
res = -float('inf')
for ans in l:
res = max(res,ans[0]+ans[1])
return res
if __name__ == '__main__':
n = int(eval(input()))
a = list(map(int,input().split()))
print((solve(n,a))) | p03716 |
# -*- coding: utf-8 -*-
def inpl(): return list(map(int, input().split()))
from heapq import heapify, heappop, heappush
from copy import deepcopy
N = int(eval(input()))
A = inpl()
before = deepcopy(A[:N])
heapify(before)
middle = A[N:-N]
after = [-a for a in A[-N:]]
heapify(after)
sb = sum(A[:N])
sa = -sum(A[-N:])
SB = [sb]
SA = [sa]
for m in middle:
b = heappop(before)
if b < m:
heappush(before, m)
sb += m - b
else:
heappush(before, b)
SB.append(sb)
for m in middle[::-1]:
m = -m
a = heappop(after)
if a < m:
heappush(after, m)
sa += m - a
else:
heappush(after, a)
SA.append(sa)
print((max([b+a for b, a in zip(SB, SA[::-1])]))) | # -*- coding: utf-8 -*-
def inpl(): return list(map(int, input().split()))
from heapq import heapify, heapreplace
N = int(eval(input()))
A = inpl()
L = A[:N]
M = A[N:2*N]
R = [-a for a in A[2*N:]]
ans = sum(L) + sum(R)
heapify(L)
heapify(R)
i = 0
j = N+1
S = [0]*(N+1)
s = 0
for i, m in enumerate(M):
if m > L[0]:
s += m - heapreplace(L, m)
S[i+1] += s
s = 0
for i, m in enumerate(M[::-1]):
if m < -R[0]:
s += -m - heapreplace(R, -m)
S[-i-2] += s
ans += max(S)
print(ans) | p03716 |
import sys
import heapq
input=sys.stdin.readline
N=int(eval(input()))
A=tuple(map(int,input().split()))
hq=list(A[:N])
heapq.heapify(hq)
s=[0]*(N+1)
s[0]=sum(hq)
for i in range(N):
x=heapq.heappop(hq)
if x >= A[N+i]:
s[i+1]=s[i]
heapq.heappush(hq,x)
else:
s[i+1]=s[i]+A[N+i]-x
heapq.heappush(hq,A[N+i])
hq=list([-x for x in A[2*N:]])
heapq.heapify(hq)
t=[0]*(N+1)
t[-1]=-sum(hq)
for i in range(N-1,-1,-1):
x=heapq.heappop(hq)
x=-x
if x <= A[N+i]:
t[i]=t[i+1]
heapq.heappush(hq,-x)
else:
t[i]=t[i+1]-x+A[N+i]
heapq.heappush(hq,-A[N+i])
ans=-10**15
for x,y in zip(s,t):
ans=max(x-y,ans)
print(ans) | import heapq
import bisect
N = int(eval(input()))
a = list(map(int, input().split()))
b = a[:N]
c = a[-N:]
L = [0]*(N+1)
R = [0]*(N+1)
L[0] = sum(b)
heapq.heapify(b)
R[-1] = sum(c)
c = list([-x for x in c])
heapq.heapify(c)
for i in range(N):
k = a[i+N]
x = heapq.heappop(b)
if x < k:
L[i+1] = L[i] + k - x
heapq.heappush(b, k)
else:
L[i+1] = L[i]
heapq.heappush(b, x)
for i in range(N-1, -1, -1):
k = a[i+N]
x = heapq.heappop(c)
if -x > k:
heapq.heappush(c, -k)
R[i] = R[i+1] + x + k
else:
R[i] = R[i+1]
heapq.heappush(c, x)
ans = -10**14
for i in range(N+1):
ans = max(ans, L[i]-R[i])
#print(L, R)
print(ans)
| p03716 |
# -*- coding: utf-8 -*-
import heapq
class MaxHeap:
def __init__(self, li):
self.heap = [-e for e in li]
heapq.heapify(self.heap)
def push(self, val):
heapq.heappush(self.heap, -val)
def pop(self):
return -heapq.heappop(self.heap)
n = int(eval(input()))
a = list(map(int, input().split()))
fh_sum = 0
fh = []
sh_sum = 0
sh = MaxHeap([])
for i in range(n):
heapq.heappush(fh, a[i])
fh_sum += a[i]
sh.push(a[-(i+1)])
sh_sum += a[-(i+1)]
fh_sums = [fh_sum]
sh_sums = [sh_sum]
for k in range(n, 2 * n):
fh_sum += a[k]
heapq.heappush(fh, a[k])
fh_sum -= heapq.heappop(fh)
fh_sums.append(fh_sum)
sh_sum += a[-(k+1)]
sh.push(a[-(k+1)])
sh_sum -= sh.pop()
sh_sums.append(sh_sum)
sh_sums = sh_sums[::-1]
ans = -float("inf")
for fh_sum, sh_sum in zip(fh_sums, sh_sums):
score = fh_sum - sh_sum
ans = max(ans, score)
print(ans)
| from heapq import heapify, heappop, heappush
class MaxHeap:
def __init__(self, li):
self.hp = []
for e in li:
heappush(self.hp, -e)
def push(self, x):
heappush(self.hp, -x)
def pop(self):
ret = heappop(self.hp)
ret *= -1
return ret
def seak(self):
return -self.hp[0]
def sum(self):
return -sum(self.hp)
n = int(eval(input()))
a = list(map(int, input().split()))
f = a[:n]
s = a[n:2*n]
t = a[2*n:]
heapify(f)
t = MaxHeap(t)
f_sm = sum(f)
f_sm_li = [f_sm]
for e in s:
heappush(f, e)
f_sm += e
pp = heappop(f)
f_sm -= pp
f_sm_li.append(f_sm)
t_sm = t.sum()
t_sm_li = [t_sm]
for e in s[::-1]:
t.push(e)
t_sm += e
pp = t.pop()
t_sm -= pp
t_sm_li.append(t_sm)
t_sm_li = t_sm_li[::-1]
ans = -float("inf")
for ef, et in zip(f_sm_li, t_sm_li):
ans = max(ans, ef - et)
print(ans)
| p03716 |
import heapq
n = int(eval(input()))
a = [int(i) for i in input().split()]
k = 0
a_front = []
a_center = []
a_back = []
front_sum = 0
back_sum = 0
for i in a:
k += 1
if k <= n:
a_front += [i]
front_sum += i
elif k <= 2 * n:
a_center += [i]
else:
a_back += [-i]
back_sum += i
heapq.heapify(a_front)
heapq.heapify(a_back)
front_sums = [front_sum]
back_sums = [back_sum]
for i in range(n):
front_sum += a_center[i] - heapq.heappushpop(a_front, a_center[i])
front_sums += [front_sum]
back_sum += a_center[-i-1] + heapq.heappushpop(a_back, -a_center[-i-1])
back_sums += [back_sum]
print((max([front_sums[i] - back_sums[-i-1] for i in range(n+1)])))
#print(front_sums, back_sums)
| import heapq
def calc(front_sum, back_sum):
heapq.heapify(a_front)
heapq.heapify(a_back)
front_sums = [front_sum]
back_sums = [back_sum]
for i in range(n):
front_sum += a_center[i] - heapq.heappushpop(a_front, a_center[i])
front_sums += [front_sum]
back_sum += a_center[-i - 1] + heapq.heappushpop(a_back, -a_center[-i - 1])
back_sums += [back_sum]
return max([front_sums[i] - back_sums[-i-1] for i in range(n+1)])
if __name__ == "__main__":
n = int(eval(input()))
a = [int(i) for i in input().split()]
k = 0
a_front = []
a_center = []
a_back = []
front_sum = 0
back_sum = 0
for i in a:
k += 1
if k <= n:
a_front += [i]
front_sum += i
elif k <= 2 * n:
a_center += [i]
else:
a_back += [-i]
back_sum += i
print((calc(front_sum, back_sum)))
| p03716 |
import heapq
def calc(front_sum, back_sum):
heapq.heapify(a_front)
heapq.heapify(a_back)
front_sums = [front_sum]
back_sums = [back_sum]
for i in range(n):
front_sum += a_center[i] - heapq.heappushpop(a_front, a_center[i])
front_sums += [front_sum]
back_sum += a_center[-i - 1] + heapq.heappushpop(a_back, -a_center[-i - 1])
back_sums += [back_sum]
return max([front_sums[i] - back_sums[-i-1] for i in range(n+1)])
if __name__ == "__main__":
n = int(eval(input()))
a = [int(i) for i in input().split()]
k = 0
a_front = []
a_center = []
a_back = []
front_sum = 0
back_sum = 0
for i in a:
k += 1
if k <= n:
a_front += [i]
front_sum += i
elif k <= 2 * n:
a_center += [i]
else:
a_back += [-i]
back_sum += i
print((calc(front_sum, back_sum)))
| import heapq
def calc(front_sum, back_sum):
heapq.heapify(a_front)
heapq.heapify(a_back)
front_sums = [front_sum]
back_sums = [back_sum]
for i in a_center:
front_sum += i - heapq.heappushpop(a_front, i)
front_sums += [front_sum]
a_center.reverse()
for i in a_center:
back_sum += i + heapq.heappushpop(a_back, -i)
back_sums += [back_sum]
return max([front_sums[i] - back_sums[-i-1] for i in range(n+1)])
if __name__ == "__main__":
n = int(eval(input()))
a = [int(i) for i in input().split()]
k = 0
a_front = []
a_center = []
a_back = []
front_sum = 0
back_sum = 0
for i in a:
k += 1
if k <= n:
a_front += [i]
front_sum += i
elif k <= 2 * n:
a_center += [i]
else:
a_back += [-i]
back_sum += i
print((calc(front_sum, back_sum)))
| p03716 |
import heapq
def calc(front_sum, back_sum):
heapq.heapify(a_front)
heapq.heapify(a_back)
front_sums = [front_sum]
back_sums = [back_sum]
for i in a_center:
front_sum += i - heapq.heappushpop(a_front, i)
front_sums += [front_sum]
a_center.reverse()
for i in a_center:
back_sum += i + heapq.heappushpop(a_back, -i)
back_sums += [back_sum]
return max([front_sums[i] - back_sums[-i-1] for i in range(n+1)])
if __name__ == "__main__":
n = int(eval(input()))
a = [int(i) for i in input().split()]
k = 0
a_front = []
a_center = []
a_back = []
front_sum = 0
back_sum = 0
for i in a:
k += 1
if k <= n:
a_front += [i]
front_sum += i
elif k <= 2 * n:
a_center += [i]
else:
a_back += [-i]
back_sum += i
print((calc(front_sum, back_sum)))
| import heapq
import sys
input = sys.stdin.readline
def calc(front_sum, back_sum):
heapq.heapify(a_front)
heapq.heapify(a_back)
front_sums = [front_sum]
back_sums = [back_sum]
for i in a_center:
front_sum += i - heapq.heappushpop(a_front, i)
front_sums += [front_sum]
a_center.reverse()
for i in a_center:
back_sum += i + heapq.heappushpop(a_back, -i)
back_sums += [back_sum]
return max([front_sums[i] - back_sums[-i-1] for i in range(n+1)])
if __name__ == "__main__":
n = int(eval(input()))
a = [int(i) for i in input().split()]
k = 0
a_front = []
a_center = []
a_back = []
front_sum = 0
back_sum = 0
for i in a:
k += 1
if k <= n:
a_front += [i]
front_sum += i
elif k <= 2 * n:
a_center += [i]
else:
a_back += [-i]
back_sum += i
print((calc(front_sum, back_sum)))
| p03716 |
import heapq
n = int(eval(input()))
array = [int(i) for i in input().split()]
ans=-1e14
l_array = []
r_array = []
l_sum = [0]*(n+1)
r_sum = [0]*(n+1)
# left-n and right-n numbers
for i in range(n):
heapq.heappush(l_array, array[i])
heapq.heappush(r_array, (-array[3*n-1-i], array[3*n-1-i]))
l_sum[0] = sum(l_array)
r_sum[n] = sum([i[1] for i in r_array])
for i in range(n, 2*n):
heapq.heappush(l_array, array[i])
heapq.heappush(r_array, (-array[3*n-1-i], array[3*n-1-i]))
heapq.heappop(l_array)
heapq.heappop(r_array)
l_sum[i-n+1] = sum(l_array)
r_sum[2*n-1-i] = sum([j[1] for j in r_array])
for i in range(n+1):
ans = max(ans, l_sum[i]-r_sum[i])
print(ans) | import heapq
n = int(eval(input()))
array = [int(i) for i in input().split()]
ans=-1e14
l_array = []
r_array = []
l_sum = [0]*(n+1)
r_sum = [0]*(n+1)
# left-n and right-n numbers
for i in range(n):
heapq.heappush(l_array, array[i])
heapq.heappush(r_array, (-array[3*n-1-i], array[3*n-1-i]))
l_sum[0] = sum(l_array)
r_sum[n] = sum([i[1] for i in r_array])
for i in range(n, 2*n):
heapq.heappush(l_array, array[i])
heapq.heappush(r_array, (-array[3*n-1-i], array[3*n-1-i]))
l_min = heapq.heappop(l_array)
r_max = heapq.heappop(r_array)[1]
# l_sum[i-n+1] = sum(l_array)
# r_sum[2*n-1-i] = sum([j[1] for j in r_array])
l_sum[i-n+1] = l_sum[i-n] - l_min + array[i]
r_sum[2*n-1-i] = r_sum[2*n-i] - r_max + array[3*n-1-i]
for i in range(n+1):
ans = max(ans, l_sum[i]-r_sum[i])
print(ans) | p03716 |
#!/usr/bin/env python3
import sys
import heapq
from collections import deque
inf = float("inf")
def solve(N: int, a: "List[int]"):
L = a[:N]
R = [-x for x in a[2*N:]]
heapq.heapify(L)
heapq.heapify(R)
M = a[N:2*N]
sumL = [0 for _ in range(N+1)] # sumL[i]: a[0]からa[N-1+i]までの大きい順にN個の和
sumR = [0 for _ in range(N+1)] # sumR[i]: -(a[N-1+i]からa[3*N-1]までの小さい順にN個の和)
sumL[0] = sum(L)
sumR[N] = sum(R)
for i in range(N):
l = heapq.heappop(L)
diff = M[i] - l
if diff > 0:
sumL[i+1] = sumL[i] + diff
heapq.heappush(L, M[i])
else:
sumL[i+1] = sumL[i]
heapq.heappush(L, l)
for i in range(N-1, -1, -1):
r = heapq.heappop(R)
diff = -M[i] - r
if diff > 0:
sumR[i] = sumR[i+1] + diff
heapq.heappush(R, -M[i])
else:
sumR[i] = sumR[i+1]
heapq.heappush(R, r)
res = -inf
for suml, sumr in zip(sumL, sumR):
res = max(res, suml + sumr)
print(res)
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
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
a = [ int(next(tokens)) for _ in range(3*N) ] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
import heapq
inf = float("inf")
def solve(N: int, a: "List[int]"):
L = a[:N]
R = [-x for x in a[2*N:]]
heapq.heapify(L)
heapq.heapify(R)
M = a[N:2*N]
sumL = [0 for _ in range(N+1)] # sumL[i]: a[0]からa[N-1+i]までの大きい順にN個の和
sumR = [0 for _ in range(N+1)] # sumR[i]: -(a[N-1+i]からa[3*N-1]までの小さい順にN個の和)
sumL[0] = sum(L)
sumR[N] = sum(R)
for i in range(N):
heapq.heappush(L, M[i])
l = heapq.heappop(L)
diff = M[i] - l
sumL[i+1] = sumL[i] + diff
for i in range(N-1, -1, -1):
heapq.heappush(R, -M[i])
r = heapq.heappop(R)
diff = -M[i] - r
sumR[i] = sumR[i+1] + diff
res = max(suml + sumr for suml, sumr in zip(sumL, sumR))
print(res)
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
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
a = [ int(next(tokens)) for _ in range(3*N) ] # type: "List[int]"
solve(N, a)
if __name__ == '__main__':
main()
| p03716 |
import heapq
N = int(eval(input()))
A = list(map(int,input().split()))
#前半部分の最適化辞書作成
SUM = sum(A[:N])
firstDic = {N-1:SUM}
que = A[:N]
heapq.heapify(que)
for i in range(N,2*N):
SUM += A[i]
heapq.heappush(que,A[i])
SUM -= heapq.heappop(que)
firstDic[i] = SUM
#後半部分の最適化辞書作成
SUM = sum(A[2*N:])*-1
latterDic = {2*N-1:SUM*-1}
que = [A[i]*-1 for i in range(2*N,3*N)]
heapq.heapify(que)
for i in range(2*N-1,N-1,-1):
SUM += A[i]*-1
heapq.heappush(que,A[i]*-1)
SUM -= heapq.heappop(que)
latterDic[i-1] = SUM*-1
ans = -1*float("INF")
for k,v in list(firstDic.items()):
ans = max(ans,v-latterDic[k])
print(ans) | N = int(eval(input()))
A = list(map(int,input().split()))
B = []
for i in range(3*N-1,-1,-1):
B.append(A[i]*-1)
"""
前半をできるだけおおきく、後半をできるだけ小さくする。
前半はpriority queにぶっこんでいって、最小値を除去していく
"""
import heapq
frontSum = sum(A[:N])
frontQue = A[:N]
heapq.heapify(frontQue)
front = [frontSum]
for i in range(N,2*N):
frontSum += A[i]
heapq.heappush(frontQue,A[i])
frontSum -= heapq.heappop(frontQue)
front.append(frontSum)
backSum = sum(B[:N])
backQue = B[:N]
heapq.heapify(backQue)
back = [backSum*-1]
for i in range(N,2*N):
backSum += B[i]
heapq.heappush(backQue,B[i])
backSum -= heapq.heappop(backQue)
back.append(backSum*-1)
back = back[::-1]
candi = []
for i in range(len(front)):
candi.append(front[i]-back[i])
print((max(candi)))
| p03716 |
# ABC140E
class SegTree:
def __init__(self, init_val, ide_ele, seg_func):
self.segfunc = seg_func
N = len(init_val)
self.num = 2**(N-1).bit_length()
self.ide_ele = ide_ele
self.seg=[self.ide_ele]*2*self.num
for i in range(N):
self.seg[i+self.num-1]=init_val[i]
for i in range(self.num-2,-1,-1) :
self.seg[i]=self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k+1:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1],self.seg[k*2+2])
def query(self, p, q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res,self.seg[p])
if q&1 == 1:
res = self.segfunc(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res,self.seg[p])
else:
res = self.segfunc(self.segfunc(res,self.seg[p]),self.seg[q])
return res
N, = list(map(int, input().split()))
A = list(map(int, input().split()))
B = sorted([(a, i) for i, a in enumerate(A)], key=lambda x:x[0])
z = dict()
for i, (b, j) in enumerate(B):
z[(b, j)] = i
ss = SegTree([3*N]*3*N, 3*N, min)
bs = []
y = 0
for i, x in enumerate(A):
if i == 2*N:
break
ss.update(z[(x, i)], z[(x, i)])
y += x
if i < N-1:
continue
if i == N-1:
bs.append(y)
else:
mx = ss.query(0, 3*N)
y = y - B[mx][0]
ss.update(mx, 3*N)
bs.append(y)
ss = SegTree([-1]*3*N, -1, max)
nbs = []
#tmp = set()
y = 0
for i, x in enumerate(A[::-1]):
if i == 2*N:
break
ss.update(z[(x, 3*N-i-1)], z[(x, 3*N-i-1)])
# tmp.add((x, i))
y += x
if i < N-1:
continue
if i == N-1:
nbs.append(y)
else:
mx = ss.query(0, 3*N)
# print(max(tmp), B[mx])
# tmp.remove(max(tmp))
y = y - B[mx][0]
ss.update(mx, -1)
nbs.append(y)
#print(B)
#print(bs)
#print(nbs)
r = -10**18
for i in range(N+1):
r = max(r, bs[i] - nbs[N-i])
print(r)
| from heapq import *
N, = list(map(int, input().split()))
A = list(map(int, input().split()))
s = sum(A[:N])
rs = [s] + [0] * N
l = []
for i in range(N):
heappush(l, A[i])
for i in range(N, 2*N):
s += A[i]
heappush(l, A[i])
x = heappop(l)
s -= x
rs[i-N+1] = s
l2 = []
s2 = 0
for i in range(2*N, 3*N):
heappush(l2, -A[i])
s2+=A[i]
rs2 = [0] * N + [s2]
for i in range(2*N-1, N-1, -1):
s2 += A[i]
heappush(l2, -A[i])
x = -heappop(l2)
# print(A[i])
# print(x)
s2 -= x
rs2[i-N] = s2
#print(rs2)
r = -10**18
for i in range(N+1):
c = rs[i] - rs2[i]
r = max(c, r)
print(r)
| p03716 |
# diverta 2019 Programming Contest 2: A – Ball Distribution
n, k = [int(s) for s in input().split()]
if k == 1:
print((0))
else:
print((n - k)) | # diverta 2019 Programming Contest 2: A – Ball Distribution
n, k = list(map(int, input().split()))
print((n - k if k > 1 else 0)) | p03005 |
import sys
from collections import deque # 双方向キュー
from collections import defaultdict # 初期化済み辞書
from heapq import heapify, heappush, heappop, heappushpop # プライオリティキュー
from bisect import bisect_left, bisect_right # 二分探索
#import numpy as np # 1.8.2
#import scipy # 0.13.3
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in ss]
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
def main():
N, K = i2nn()
if K == 1:
print((0))
else:
print((N - K))
main()
| import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in ss]
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2sss = lambda n: [list(sys.stdin.readline().rstrip()) for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
def main():
N, K = i2nn()
if K == 1:
print((0))
else:
print((N-K))
main()
| p03005 |
N, K = list(map(int, input().split()))
if K == 1:
print((0))
else:
print((N - K))
| N, K = list(map(int, input().split()))
print((0 if K == 1 else N - K))
| p03005 |
n, k = list(map(int, input().split()))
if k == 1:
print((0))
else:
print((n - k))
| n, k = list(map(int, input().split()))
print((n % k))
| p03005 |
MOD = 10**9 + 7
def main():
N, X = list(map(int, input().split()))
S = list(map(int, input().split()))
S = sorted(S, reverse=True)
dp = [0]*(X+1)
dp[X] = 1
for i in range(N):
new = [0] * (X+1)
for x in range(X+1):
xx = x % S[i]
new[x] += dp[x] * (N-i-1)
new[x] %= MOD
new[xx] += dp[x]
new[xx] %= MOD
dp = new
total = 0
for x in range(X):
total += dp[x] * x
total %= MOD
print(total)
main()
| from collections import defaultdict as dd
MOD = 10**9 + 7
def main():
N, X = list(map(int, input().split()))
S = list(map(int, input().split()))
S = sorted(S, reverse=True)
dp = dd(int)
dp[X] = 1
for i in range(N):
new = dd(int)
for x in dp:
xx = x % S[i]
new[x] += dp[x] * (N-i-1)
new[x] %= MOD
new[xx] += dp[x]
new[xx] %= MOD
dp = new
total = 0
for x in dp:
total += dp[x] * x
total %= MOD
print(total)
main()
| p03082 |
N,X = list(map(int,input().split()))
S = list(map(int,input().split()))
S.sort()
mod = 10**9+7
dp = [[0]*(N+1) for i in range(X+1)]
for x in range(X+1):
for n in range(N+1):
if n == 0:
dp[x][n] = x
else:
dp[x][n] = (dp[x%S[n-1]][n-1] + (n-1)*dp[x][n-1])%mod
print((dp[X][N])) | N,X = list(map(int,input().split()))
S = list(map(int,input().split()))
S.sort()
mod = 10**9+7
dp = [[x]+[0]*N for x in range(X+1)]
for x in range(X+1):
for n in range(1,N+1):
dp[x][n] = (dp[x%S[n-1]][n-1] + (n-1)*dp[x][n-1])%mod
print((dp[X][N])) | p03082 |
N,X = list(map(int,input().split()))
S = list(map(int,input().split()))
S.sort()
mod = 10**9+7
dp = [[x]+[0]*N for x in range(X+1)]
for x in range(X+1):
for n in range(1,N+1):
dp[x][n] = (dp[x%S[n-1]][n-1] + (n-1)*dp[x][n-1])%mod
print((dp[X][N])) | N,X = list(map(int,input().split()))
S = list(map(int,input().split()))
S.sort()
mod = 10**9+7
dp = [[x]+[0]*N for x in range(X+1)]
for n in range(1,N+1):
for x in range(X+1):
dp[x][n] = (dp[x%S[n-1]][n-1] + (n-1)*dp[x][n-1])%mod
print((dp[X][N])) | p03082 |
import sys
# import bisect
# import math
import itertools
# import numpy as np
# import collections
"""Template"""
class IP:
"""
入力を取得するクラス
"""
def __init__(self):
self.input = sys.stdin.readline
def I(self):
"""
1文字の取得に使います
:return: int
"""
return int(self.input())
def S(self):
"""
1文字の取得(str
:return: str
"""
return self.input()
def IL(self):
"""
1行を空白で区切りリストにします(int
:return: リスト
"""
return list(map(int, self.input().split()))
def SL(self):
"""
1行の文字列を空白区切りでリストにします
:return: リスト
"""
return list(map(str, self.input().split()))
def ILS(self, n):
"""
1列丸々取得します(int
:param n: 行数
:return: リスト
"""
return [int(self.input()) for _ in range(n)]
def SLS(self, n):
"""
1列丸々取得します（str
:param n: 行数
:return: リスト
"""
return [self.input() for _ in range(n)]
def SILS(self, n):
"""
Some Int LineS
横に複数、縦にも複数
:param n: 行数
:return: list
"""
return [self.IL() for _ in range(n)]
def SSLS(self, n):
"""
Some String LineS
:param n: 行数
:return: list
"""
return [self.SL() for _ in range(n)]
class Idea:
def __init__(self):
pass
def HF(self, p):
"""
Half enumeration
半分全列挙です
pの要素の和の組み合わせを作ります。
ソート、重複削除行います
:param p: list : 元となるリスト
:return: list : 組み合わせられた和のリスト
"""
return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))
def Bfs2(self, a):
"""
bit_full_search2
bit全探索の改良版
全探索させたら2進数のリストと10進数のリストを返す
:return: list２つ : １個目 2進数(16桁) 2個目 10進数
"""
# 参考
# https://blog.rossywhite.com/2018/08/06/bit-search/
# https://atcoder.jp/contests/abc105/submissions/4088632
value = []
for i in range(1 << len(a)):
output = []
for j in range(len(a)):
if self.bit_o(i, j):
"""右からj+1番目のiが1かどうか判定"""
# output.append(a[j])
output.append(a[j])
value.append([format(i, 'b').zfill(16), sum(output)])
value.sort(key=lambda x: x[1])
bin = [value[k][0] for k in range(len(value))]
val = [value[k][1] for k in range(len(value))]
return bin, val
def S(self, s, r=0, m=-1):
"""
ソート関係行います。色々な設定あります。
:param s: 元となるリスト
:param r: reversするかどうか 0=False 1=True
:param m: （2次元配列）何番目のインデックスのソートなのか
:return: None
"""
r = bool(r)
if m == -1:
s.sort(reverse=r)
else:
s.sort(reverse=r, key=lambda x: x[m])
def bit_n(self, a, b):
"""
bit探索で使います。0以上のときにTrue出します
自然数だからn
:param a: int
:param b: int
:return: bool
"""
return bool((a >> b & 1) > 0)
def bit_o(self, a, b):
"""
bit探索で使います。1のときにTrue出すよ
oneで1
:param a: int
:param b: int
:return: bool
"""
return bool(((a >> b) & 1) == 1)
def ceil(self, x, y):
"""
Round up
小数点切り上げ割り算
:param x: int
:param y: int
:return: int
"""
return -(-x // y)
def ave(self, a):
"""
平均を求めます
:param a: list
:return: int
"""
return sum(a) / len(a)
def gcd(self, x, y):
if y == 0:
return x
else:
return self.gcd(y, x % y)
"""ここからメインコード"""
def main():
# 1文字に省略
r, e, p = range, enumerate, print
ip = IP()
id = Idea()
mod = 10 ** 9 + 7
"""この下から書いてね"""
n, x = ip.IL()
s = ip.IL()
ans = 0
o = list(itertools.permutations(s))
for y in o:
res = x
for z in y:
res = res % z
if res == 1:
break
ans += res
p(ans % mod)
main()
| import sys
# import bisect
# import math
import itertools
# import numpy as np
# import collections
"""Template"""
class IP:
"""
入力を取得するクラス
"""
def __init__(self):
self.input = sys.stdin.readline
def I(self):
"""
1文字の取得に使います
:return: int
"""
return int(self.input())
def S(self):
"""
1文字の取得(str
:return: str
"""
return self.input()
def IL(self):
"""
1行を空白で区切りリストにします(int
:return: リスト
"""
return list(map(int, self.input().split()))
def SL(self):
"""
1行の文字列を空白区切りでリストにします
:return: リスト
"""
return list(map(str, self.input().split()))
def ILS(self, n):
"""
1列丸々取得します(int
:param n: 行数
:return: リスト
"""
return [int(self.input()) for _ in range(n)]
def SLS(self, n):
"""
1列丸々取得します（str
:param n: 行数
:return: リスト
"""
return [self.input() for _ in range(n)]
def SILS(self, n):
"""
Some Int LineS
横に複数、縦にも複数
:param n: 行数
:return: list
"""
return [self.IL() for _ in range(n)]
def SSLS(self, n):
"""
Some String LineS
:param n: 行数
:return: list
"""
return [self.SL() for _ in range(n)]
class Idea:
def __init__(self):
pass
def HF(self, p):
"""
Half enumeration
半分全列挙です
pの要素の和の組み合わせを作ります。
ソート、重複削除行います
:param p: list : 元となるリスト
:return: list : 組み合わせられた和のリスト
"""
return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))
def Bfs2(self, a):
"""
bit_full_search2
bit全探索の改良版
全探索させたら2進数のリストと10進数のリストを返す
:return: list２つ : １個目 2進数(16桁) 2個目 10進数
"""
# 参考
# https://blog.rossywhite.com/2018/08/06/bit-search/
# https://atcoder.jp/contests/abc105/submissions/4088632
value = []
for i in range(1 << len(a)):
output = []
for j in range(len(a)):
if self.bit_o(i, j):
"""右からj+1番目のiが1かどうか判定"""
# output.append(a[j])
output.append(a[j])
value.append([format(i, 'b').zfill(16), sum(output)])
value.sort(key=lambda x: x[1])
bin = [value[k][0] for k in range(len(value))]
val = [value[k][1] for k in range(len(value))]
return bin, val
def S(self, s, r=0, m=-1):
"""
ソート関係行います。色々な設定あります。
:param s: 元となるリスト
:param r: reversするかどうか 0=False 1=True
:param m: （2次元配列）何番目のインデックスのソートなのか
:return: None
"""
r = bool(r)
if m == -1:
s.sort(reverse=r)
else:
s.sort(reverse=r, key=lambda x: x[m])
def bit_n(self, a, b):
"""
bit探索で使います。0以上のときにTrue出します
自然数だからn
:param a: int
:param b: int
:return: bool
"""
return bool((a >> b & 1) > 0)
def bit_o(self, a, b):
"""
bit探索で使います。1のときにTrue出すよ
oneで1
:param a: int
:param b: int
:return: bool
"""
return bool(((a >> b) & 1) == 1)
def ceil(self, x, y):
"""
Round up
小数点切り上げ割り算
:param x: int
:param y: int
:return: int
"""
return -(-x // y)
def ave(self, a):
"""
平均を求めます
:param a: list
:return: int
"""
return sum(a) / len(a)
def gcd(self, x, y):
if y == 0:
return x
else:
return self.gcd(y, x % y)
"""ここからメインコード"""
def main():
# 1文字に省略
r, e, p = range, enumerate, print
ip = IP()
id = Idea()
mod = 10 ** 9 + 7
"""この下から書いてね"""
n, x = ip.IL()
ans = 0
for y in list(itertools.permutations(ip.IL())):
res = x
for z in y:
res = res % z
ans += res
p(ans % mod)
main()
| p03082 |
import sys
from collections import defaultdict
def input():
return sys.stdin.readline()[:-1]
MOD = 1e9+7
n, x = list(map(int, input().split()))
s = list(map(int, input().split()))
s.sort(reverse=True)
dp = defaultdict(int)
dp[x] = 1
for i in range(n):
dpp = defaultdict(int)
for j in range(x+1):
dpp[j] += (n-1-i) * dp[j]
dpp[j%s[i]] += dp[j]
for j in range(x+1):
dpp[j] %= MOD
dp = dpp
#print(dp)
ans = 0
for j in range(x+1):
ans += dp[j] * j
ans %= MOD
print((int(ans))) | import sys
from collections import defaultdict
def input():
return sys.stdin.readline()[:-1]
MOD = 1e9+7
n, x = list(map(int, input().split()))
s = list(map(int, input().split()))
s.sort(reverse=True)
dp = defaultdict(int)
dp[x] = 1
for i in range(n):
ss = s[i]
dpp = defaultdict(int)
for key, value in list(dp.items()):
dpp[key] += (n-1-i) * value
dpp[key%ss] += value
for key in list(dpp.keys()):
dpp[key] %= MOD
dp = dpp
ans = 0
for key, value in list(dp.items()):
ans += value * key
ans %= MOD
print((int(ans))) | p03082 |
N, X = list(map(int, input().split()))
*S, = list(map(int, input().split()))
MOD = 10**9 + 7
fact = [1]*(X+1)
rfact = [1]*(X+1)
for i in range(X):
fact[i+1] = r = fact[i] * (i+1) % MOD
rfact[i+1] = pow(r, MOD-2, MOD)
S.sort()
memo = {}
def dfs(i, k):
key = (i, k)
if key in memo:
return memo[key]
if i == N:
return k == X
r = dfs(i+1, k) * i % MOD
if k <= S[i]:
for j in range(k, X+1, S[i]):
r = (r + dfs(i+1, j)) % MOD
memo[key] = r
return r
print((sum(x*dfs(0, x)%MOD for x in range(S[0])) % MOD)) | N, X = list(map(int, input().split()))
*V, = list(map(int, input().split()))
MOD = 10**9 + 7
fact = [1]*(X+1)
rfact = [1]*(X+1)
for i in range(X):
fact[i+1] = r = fact[i] * (i+1) % MOD
rfact[i+1] = pow(r, MOD-2, MOD)
V.sort()
S = [0]*(X+1)
S[X] = 1
for i in range(N-1, -1, -1):
T = [0]*(X+1)
for k in range(X+1):
S[k] %= MOD
T[k] += S[k] * i % MOD
T[k % V[i]] += S[k]
S = T
print((sum(k*S[k] % MOD for k in range(V[0])) % MOD)) | p03082 |
N, X = list(map(int, input().split()))
*V, = list(map(int, input().split()))
MOD = 10**9 + 7
fact = [1]*(X+1)
rfact = [1]*(X+1)
for i in range(X):
fact[i+1] = r = fact[i] * (i+1) % MOD
rfact[i+1] = pow(r, MOD-2, MOD)
V.sort()
S = [0]*(X+1)
S[X] = 1
for i in range(N-1, -1, -1):
T = [0]*(X+1)
for k in range(X+1):
S[k] %= MOD
T[k] += S[k] * i % MOD
T[k % V[i]] += S[k]
S = T
print((sum(k*S[k] % MOD for k in range(V[0])) % MOD)) | N, X = list(map(int, input().split()))
*V, = list(map(int, input().split()))
MOD = 10**9 + 7
V.sort()
S = [0]*(X+1)
S[X] = 1
T = [0]*(X+1)
zeros = [0]*(X+1)
for i in range(N-1, -1, -1):
T[:] = zeros
for k in range(X+1):
S[k] %= MOD
T[k] += S[k] * i % MOD
T[k % V[i]] += S[k]
S, T = T, S
print((sum(k*S[k] % MOD for k in range(V[0])) % MOD)) | p03082 |
mod=10**9+7
N,X=list(map(int,input().split()))
S=[int(i) for i in input().split()]
S.sort(reverse=True)
Factorial=[1]*(N+1)
for i in range(1,N+1):
Factorial[i]=Factorial[i-1]*(i)%mod
def power(x,y):
if y==0:
return 1
elif y==1:
return x%mod
elif y%2==0:
return power(x,y//2)**2%mod
else:
return ((power(x,y//2)**2)*x)%mod
inv=[0]*(N+1)
for i in range(N+1):
inv[i]=power(i,mod-2)
dp=[[0]*(X+1) for i in range(N+1)]
for x in range(X+1):
dp[N][x]=x
for i in range(N)[::-1]:
for x in range(X+1):
dp[i][x]+=dp[i+1][x%S[i]]*inv[N-i]
dp[i][x]%=mod
dp[i][x]+=(N-i-1)*dp[i+1][x]*inv[N-i]
dp[i][x]%=mod
print(((dp[0][X]*Factorial[N])%mod)) | mod=10**9+7
N,X=list(map(int,input().split()))
S=[int(i) for i in input().split()]
S.sort(reverse=True)
Factorial=[1]*(N+1)
for i in range(1,N+1):
Factorial[i]=Factorial[i-1]*(i)%mod
def power(x,y):
if y==0:
return 1
elif y==1:
return x%mod
elif y%2==0:
return power(x,y//2)**2%mod
else:
return ((power(x,y//2)**2)*x)%mod
inv=[0]*(N+1)
for i in range(N+1):
inv[i]=power(i,mod-2)
dp=[[0]*(X+1) for i in range(N+1)]
for x in range(X+1):
dp[N][x]=x
for i in range(N)[::-1]:
for x in range(X+1):
dp[i][x]=dp[i+1][x%S[i]]+(N-i-1)*dp[i+1][x]
dp[i][x]%=mod
print(((dp[0][X])%mod)) | p03082 |
import sys
sys.setrecursionlimit(10**9)
MOD = 10**9 + 7
N, X = list(map(int, input().split()))
Ss = list(map(int, input().split()))
Ss.sort(reverse=True)
def dfs(i, xNow):
if (i, xNow) in memo:
return memo[(i, xNow)]
if i == N-1:
ans = xNow % Ss[i]
else:
ans = dfs(i+1, xNow % Ss[i])
ans += dfs(i+1, xNow) * (N-i-1)
ans %= MOD
memo[(i, xNow)] = ans
return ans
memo = {}
dfs(0, X)
print((memo[(0, X)]))
| MOD = 10**9 + 7
N, X = list(map(int, input().split()))
Ss = list(map(int, input().split()))
Ss.sort(reverse=True)
minS = Ss[-1]
D = {X: 1}
for i, S in enumerate(Ss[:-1]):
D2 = {}
for x, num in list(D.items()):
D2[x] = (D2.get(x, 0) + num*(N-1-i)) % MOD
D2[x%S] = (D2.get(x%S, 0) + num) % MOD
D = D2
ans = 0
for x, num in list(D.items()):
ans += (x%minS) * num % MOD
ans %= MOD
print(ans)
| p03082 |
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
# 挿入dp
def solve():
n,x = LI()
s = LI()
s.sort()
dp = [[0]*(x+1) for i in range(n+1)] # dp[i][j] := スタート時点の値がjの時に最初のi個の順列すべてを試し、えられる総和
for j in range(x+1):
dp[0][j] = j # dpの定義より明らか
for i in range(n):
si = s[i]
ni = i+1
nd = dp[i][j%si] # 先頭にsiを挿入 (スタートの値がj%siとなる)
nd += i*dp[i][j] # 先頭以外にsiを挿入 (スタートの値も間の値も変わらない)
dp[ni][j] += nd
if dp[ni][j] >= mod:
dp[ni][j] %= mod
print((dp[n][x]))
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
# 挿入dp
def solve():
n,x = LI()
s = LI()
s.sort()
dp = [[0]*(x+1) for i in range(n+1)] # dp[i][j] := スタート時点の値がjの時に最初のi個の順列すべてを試し、えられる総和
for j in range(x+1):
dp[0][j] = j # dpの定義より明らか
for i in range(n):
si = s[i]
ni = i+1
nd = dp[i][j%si] # 先頭にsiを挿入 (スタートの値がj%siとなる)
nd += i*dp[i][j] # 先頭以外にsiを挿入 (スタートの値も間の値も変わらない)
dp[ni][j] += nd
if dp[ni][j] >= mod:
dp[ni][j] %= mod
print((dp[n][x]))
return
# 空間の節約
def solve_1():
n,x = LI()
s = LI()
s.sort()
#dp = [[0]*(x+1) for i in range(n+1)] # dp[i][j] := スタート時点の値がjの時に最初のi個の順列すべてを試し、えられる総和
dp = [j for j in range(x+1)]
for i in range(n):
si = s[i]
ndp = [0]*(x+1)
for j in range(x+1):
nd = dp[j%si] # 先頭にsiを挿入 (スタートの値がj%siとなる)
nd += i*dp[j] # 先頭以外にsiを挿入 (スタートの値も間の値も変わらない)
ndp[j] += nd
if ndp[j] >= mod:
ndp[j] %= mod
dp = [j for j in ndp]
print((dp[x]))
return
#Solve
if __name__ == "__main__":
solve_1()
| p03082 |
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():
n,x = LI()
a = sorted(LI(), reverse=True)
d = collections.defaultdict(int)
d[(x,0)] = 1
fm = {}
def f(i):
if i < 2:
return 1
if i in fm:
return fm[i]
r = i * f(i-1) % mod
fm[i] = r
return r
for ai in range(n):
c = a[ai]
e = collections.defaultdict(int)
for kk,v in d.items():
k,i = kk
if ai < n-1:
e[(k,i+1)] += v
e[(k,i+1)] %= mod
kc = k % c
e[(kc,i)] += v
e[(kc,i)] %= mod
for j in range(i-1,-1,-1):
e[(kc,j)] += v * f(i) // f(j)
e[(kc,j)] %= mod
d = e
r = 0
for kk,v in d.items():
k,i = kk
if i > 0:
continue
r += k * v
r %= mod
return r
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():
n,x = LI()
a = sorted(LI(),reverse=True)
d = collections.defaultdict(int)
d[x] = 1
for i in range(n):
c = a[i]
e = collections.defaultdict(int)
for k,v in d.items():
e[k] += v * (n-i-1)
e[k] %= mod
e[k%c] += v
e[k%c] %= mod
d = e
r = 0
for k,v in d.items():
r += k * v
r %= mod
return r
print(main())
| p03082 |
import sys
input = sys.stdin.readline
mod = 10**9+7
def main():
N, X = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
L = max(A[-1], X)
dp = [[0]*N for _ in range(L+1)]
a = A[0]
for x in range(L+1):
dp[x][0] = x%a
dp1 = [[0]*N for _ in range(L+1)] #累積和見たいな
for n in range(1, N):
a = A[n]
for x in range(L+1):
dp1[x][n] = ((n-1) * dp1[x][n-1] + dp[x][n-1]) % mod
for x in range(L+1):
dp[x][n] = dp1[x%a][n]
ans = 0
t = 1
for n in reversed(list(range(N))):
ans = (ans + dp[X][n]*t) % mod
t = t * n % mod
print(ans)
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
mod = 10**9+7
def main():
N, X = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
L = max(A[-1], X)
dp = [[0]*N for _ in range(L+1)]
a = A[0]
for x in range(L+1):
dp[x][0] = x%a
dp1 = [0 for _ in range(L+1)] #累積和見たいな
for n in range(1, N):
a = A[n]
for x in range(L+1):
dp1[x] = ((n-1) * dp1[x] + dp[x][n-1]) % mod
dp[x][n] = dp1[x%a]
ans = 0
t = 1
for n in reversed(list(range(N))):
ans = (ans + dp[X][n]*t) % mod
t = t * n % mod
print(ans)
if __name__ == "__main__":
main() | p03082 |
N, X = [int(i) for i in input().split()]
sList = [int(i) for i in input().split()]
sList.sort(reverse=True)
mod = 10 ** 9 + 7
dp = [0 for _ in range(X + 1)]
dp[X] = 1
for i, s in enumerate(sList):
new_dp = [0 for _ in range(X + 1)]
for x in range(X + 1):
new_dp[x] += dp[x] * (N - i - 1)
new_dp[x] %= mod
new_dp[x % s] += dp[x]
new_dp[x % s] %= mod
dp = new_dp
ans = 0
for i in range(len(dp)):
ans += i * dp[i]
ans %= mod
print(ans) | from collections import defaultdict as dd
N, X = [int(i) for i in input().split()]
sList = [int(i) for i in input().split()]
sList.sort(reverse=True)
mod = 10 ** 9 + 7
dp = dd(int)
dp[X] = 1
for i, s in enumerate(sList):
new_dp = dd(int)
for x in dp:
new_dp[x] += dp[x] * (N - i - 1)
new_dp[x] %= mod
new_dp[x % s] += dp[x]
new_dp[x % s] %= mod
dp = new_dp
ans = 0
for x in dp:
ans += x * dp[x]
ans %= mod
print(ans)
| p03082 |
from collections import defaultdict
n,x = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort(reverse=True)
mod = 10**9+7
rng = 300
fctr = [1]
finv = [1]
for i in range(1,rng):
fctr.append(fctr[-1]*i%mod)
def inv(a):
return pow(a,mod-2,mod)
dp = [{} for i in range(n+1)]
dp[0][x] = 1
for i in range(n):
for j in range(i+1,n+1):
for k in list(dp[i].keys()):
num = dp[i][k]
k %= a[j-1]
if k in dp[j]:
dp[j][k] = (dp[j][k]+num*fctr[n-i-1]*inv(fctr[n-j]))%mod
else:
dp[j][k] = (num*fctr[n-i-1]*inv(fctr[n-j]))%mod
ans = 0
for i,x in list(dp[n].items()):
ans = (ans+i*x)%mod
print(ans) | from collections import defaultdict
n,x = list(map(int,input().split()))
a = list(map(int,input().split()))
a.sort(reverse=True)
mod = 10**9+7
dp = [defaultdict(int) for i in range(n+1)]
dp[0][x] = 1
for i in range(1,n+1):
for j in list(dp[i-1].keys()):
k = j%a[i-1]
dp[i][j] = (dp[i][j]+dp[i-1][j]*(n-i))%mod
dp[i][k] = (dp[i][k]+dp[i-1][j])%mod
ans = 0
for i,x in list(dp[n].items()):
ans = (ans+i*x)%mod
print(ans) | p03082 |
mod = 10**9+7
n, X = list(map(int, input().split()))
s = [int(x) for x in input().split()]
s = sorted(s)
dp = [[0 for _ in range(X+1)] for _ in range(n+1)]
inv = [pow(i, mod-2, mod) for i in range(n+1)]
for i in range(n+1):
if i == 0:
for x in range(X+1):
dp[i][x] = x
else:
for x in range(X+1):
dp[i][x] = dp[i-1][x % s[i-1]] * inv[i] + dp[i-1][x]*(1-inv[i])
dp[i][x] %= mod
ans = dp[n][X]
for i in range(n):
ans *= i+1
ans %= mod
print(ans)
| mod = 10**9+7
n, X = list(map(int, input().split()))
s = [int(x) for x in input().split()]
s = sorted(s)
dp = [[0 for _ in range(X+1)] for _ in range(n+1)]
for i in range(n+1):
if i == 0:
for x in range(X+1):
dp[i][x] = x
else:
for x in range(X+1):
dp[i][x] = dp[i-1][x % s[i-1]] + dp[i-1][x]*(i-1)
dp[i][x] %= mod
ans = dp[n][X]
print(ans)
| p03082 |
x,y,z=list(map(int,input().split()))
n=[i for i in range(z,x-z,y+z)]
if n[-1]+y+z<=x:
print((len(n)))
else:
print((len(n)-1)) | x,y,z=list(map(int,input().split()));print(((x-z)//(y+z))) | p03548 |
x,y,z = list(map(int, input().split()))
print((int((x-z)/(y+z)))) | x,y,z = list(map(int,input().split()))
print(((x-z)//(y+z))) | p03548 |
# -*- coding utf-8 -*-
x,y,z=list(map(int,input().split()))
print(((x-z)//(y+z)))
| x,y,z=list(map(int,input().split()))
x=x-z
print((x//(y+z)))
| p03548 |
X, Y, Z = (int(x) for x in input().split())
ans = (X-Z)//(Y+Z)
print(ans) | X, Y, Z = list(map(int, input().split()))
print(((X-Z)//(Y+Z)))
| p03548 |
x,y,z = list(map(int,input().split()))
ans = 0
while (y + z) * ans <= (x - z):
ans += 1
# print((y + z) * ans)
# print(ans)
print((ans-1))
|
x,y,z = list(map(int,input().split()))
ans = int((x-z)//(y+z))
print(ans)
| p03548 |
def answer(x: int, y: int, z: int) -> int:
return (x - z) // (y + z)
def main():
x, y, z = list(map(int, input().split()))
print((answer(x, y, z)))
if __name__ == '__main__':
main() | def answer(x: int, y: int, z: int) -> int:
return len(list(range(y + z * 2, x + 1, y + z)))
def main():
x, y, z = list(map(int, input().split()))
print((answer(x, y, z)))
if __name__ == '__main__':
main() | p03548 |
X, Y, Z = list(map( int, input().split()))
m = X - Z
n = Y + Z
print((m//n)) | X, Y, Z = list(map( int, input().split()))
m = X - Z
print((m//(Y+Z)))
| p03548 |
X,Y,Z=list(map(int,input().split()))
for i in range(1,10**9):
width=i*Y+(i+1)*Z
if width>X:
break
print((i-1)) | X,Y,Z=list(map(int,input().split()))
answer=0
width=Y+2*Z
while(width<=X):
answer+=1
width+=Y+Z
print(answer) | p03548 |
x,y,z=list(map(int,input().split()))
w=y+2*z
ans=1
while w<=x-(y+z):
w+=y+z
ans+=1
print(ans) | x,y,z=list(map(int,input().split()))
ans=(x-z)//(y+z)
print(ans) | p03548 |
import sys
# import collections
# import math
# import string
# import bisect
# import re
# import itertools
# import statistics
def main():
x, y, z = (int(i) for i in sys.stdin.read().split())
n = 0
while True:
total = (n + 1) * z + n * y
if total <= x: n += 1; continue
else:
if n == 0: print((0))
else:print((n-1))
exit()
if __name__ == "__main__":
# execute only if run as a script
main()
| import sys
L, l, d = list(map(int, sys.stdin.readline().split()))
def main():
x = (L - d) // (l + d)
return x
if __name__ == '__main__':
ans = main()
print(ans) | p03548 |
X, Y, Z = list(map(int, input().split()))
print(((X-Z)//(Y+Z))) | x,y,z = list(map(int, input().split()))
x -= z
y += z
print((x//y)) | p03548 |
x,y,z = list(map(int,input().split()))
p = y + z + z
c = 0
while p <= x:
c += 1
p = p + y + z
print(c) | x,y,z = list(map(int,input().split()))
yz = y + z
x -= z
print((x // yz)) | p03548 |
x,y,z=list(map(int,input().split()))
x = x - z
sum = 0
cnt = 0
while sum <= x:
sum += y + z
cnt += 1
print((cnt - 1))
| x,y,z=list(map(int,input().split()))
print(((x-z)//(y+z))) | p03548 |
X,Y,Z=list(map(int,input().split()))
ans=0
K=Z
while(True):
if K+Y+Z>X:
break
K+=Y+Z
ans+=1
print(ans) | X,Y,Z=list(map(int,input().split()))
A=X-Z
ans=A//(Y+Z)
print(ans)
| p03548 |
x, y, z = list(map(int, input().split()))
cnt = 0
x -= z
while x > 0:
if x-y-z >= 0:
x -= y+z
cnt += 1
else:
break
print(cnt) | x,y,z=list(map(int,input().split()))
print(((x-z)//(y+z))) | p03548 |
X, Y, Z = list(map(int, input().split()))
for n in range(10 ** 5, 0, -1):
if X >= n * (Y + Z) + Z:
break
print(n) | X, Y, Z = list(map(int, input().split()))
print(((X - Z) // (Y + Z))) | p03548 |
X, Y, Z = list(map(int, input().split()))
ans = 1
while ans * (Y + Z) + Z <= X:
ans += 1
print((ans - 1))
| X, Y, Z = list(map(int, input().split()))
print(((X - Z) // (Y + Z)))
| p03548 |
X, Y, Z = list(map(int, input().split()))
ans = 0
X -= Z
while Y+Z <= X:
X -= Y+Z
ans += 1
print(ans) | X, Y, Z = list(map(int, input().split()))
print(((X - Z) // (Y + Z))) | p03548 |
#!/usr/bin/env python
def main():
X, Y, Z = list(map(int, input().split(" ")))
max_num = 0
for i in range(100000):
if Y * i + Z * (i + 1) <= X:
max_num = i
else:
break
print(max_num)
if __name__ == '__main__':
main()
| #!/usr/bin/env python
def main():
X, Y, Z = list(map(int, input().split(" ")))
# max_num = 0
# for i in range(100000):
# if Y * i + Z * (i + 1) <= X:
# max_num = i
# else:
# break
# print(max_num)
print((int((X - Z) / (Y + Z))))
if __name__ == '__main__':
main()
| p03548 |
X,Y,Z = list(map(int,input().split()))
print(((X-Z) // (Y+Z)))
| x,y,z = list(map(int,input().split()))
print(((x-z)//(y+z))) | p03548 |
x, y, z = list(map(int, input().split()))
n = 1
while True:
if y * n + z * (n+1) <= x:
n += 1
else:
print((n-1))
break | x, y, z = list(map(int, input().split()))
s = z
cnt = 0
while True:
s += y + z
if s > x:
break
cnt += 1
print(cnt)
| p03548 |
X, Y, Z = list(map(int, input().split()))
num = 0
for i in range(1, 100000):
if X < i * Y + (i - 1) * Z + 2 * Z:
break
num = i
print(num)
| X, Y, Z = list(map(int, input().split()))
for i in range(1, 100000):
if X < i * Y + (i - 1) * Z + 2 * Z:
break
print((i - 1))
| p03548 |
x,y,z=list(map(int,input().split()))
ans=int(0)
x-=z
while x>=y+z:
ans+=1
x-=(y+z)
print(ans) | x,y,z=list(map(int,input().split()))
x-=z
print((int(x/(y+z)))) | p03548 |
X,Y,Z = list(map(int,input().split()))
X -= Y+2*Z
answer = 1
while X >= Y+Z :
X -= Y+Z
answer += 1
print(answer)
| X,Y,Z = list(map(int,input().split()))
answer = 0
X -= Y+2*Z
answer += 1
answer += X//(Y+Z)
print(answer)
| p03548 |
x, y, z = list(map(int, input().split()))
ans = 1
for i in range(x // y):
ans += 1
if y * ans + z * (ans + 1) > x:
print((ans - 1))
exit() | x, y, z = list(map(int, input().split()))
ans = 1
q = x // (y + z)
r = x % (y + z)
if r < z:
print((q - 1))
else:
print(q) | p03548 |
#!/usr/bin/env python
# encoding: utf-8
class Solution:
def __init__(self):
self.count = 0
def shell_sort(self):
array_length = int(input())
array = []
# array = list(map(int, sys.stdin.readlines()))
# array_length = 10
# array = [15, 12, 8, 9, 3, 2, 7, 2, 11, 1]
for m in range(array_length):
array.append(int(input()))
G = [1]
while True:
g = G[0] * 3 + 1
if g > array_length:
break
G.insert(0, g)
g_length = len(G)
result = []
for j in range(g_length):
result = self.insertion_sort(array=array, array_length=array_length, g=G[j])
# print(result, 'r', G[j])
print(g_length)
print(*G)
print(self.count)
print(*result, sep='\n')
def insertion_sort(self, array, array_length, g):
# write your code here
for i in range(g, array_length):
v = array[i]
j = i - g
while j >= 0 and array[j] > v:
array[j + g] = array[j]
j -= g
self.count += 1
array[j + g] = v
# print(" ".join(map(str, array)))
return array
if __name__ == '__main__':
solution = Solution()
solution.shell_sort()
| #!/usr/bin/env python
# encoding: utf-8
import sys
class Solution:
def __init__(self):
self.count = 0
def shell_sort(self):
_input = sys.stdin.readlines()
array_length = int(_input[0])
array = list(map(int, _input[1:]))
G = [1]
while True:
g = G[0] * 3 + 1
if g > array_length:
break
G.insert(0, g)
g_length = len(G)
result = []
for j in range(g_length):
result = self.insertion_sort(array=array, array_length=array_length, g=G[j])
# print(result, 'r', G[j])
print(g_length)
print(*G)
print(self.count)
print(*result, sep='\n')
def insertion_sort(self, array, array_length, g):
# write your code here
for i in range(g, array_length):
v = array[i]
j = i - g
while j >= 0 and array[j] > v:
array[j + g] = array[j]
j -= g
self.count += 1
array[j + g] = v
# print(" ".join(map(str, array)))
return array
if __name__ == '__main__':
solution = Solution()
solution.shell_sort()
| p02262 |
n = int(input())
A = [int(input()) for _ in range(n)]
cnt = 0
G = [797161,265720,88573,29524,9841,3280,1093,364,121,40,13,4,1]
G = [v for v in G if v <= n]
m = len(G)
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
for g in G:
insertionSort(A, n, g)
print(m)
print(*G)
print(cnt)
print(*A, sep='\n')
| import sys
n = int(input())
A=[int(e)for e in sys.stdin]
cnt = 0
G = [797161,265720,88573,29524,9841,3280,1093,364,121,40,13,4,1]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A,sep='\n')
| p02262 |
import sys
n = int(input())
A=list(map(int,sys.stdin))
cnt = 0
G = [int((3**i-1)/2)for i in range(30,0,-1)]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A,sep='\n')
| import sys
n = int(input())
A=[int(e)for e in sys.stdin]
cnt = 0
G = [int((3**i-1)/2)for i in range(30,0,-1)]
G = [v for v in G if v <= n]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
for g in G:
insertionSort(A, n, g)
print(len(G))
print(*G)
print(cnt)
print(*A,sep='\n')
| p02262 |
def shellsort(a):
l = len(a)
intervals = [n for n in (40, 13, 4, 1) if n <= l]
count = 0
for interval in intervals:
for i in range(interval, l):
j = 0
while i-interval*(j+1) >= 0:
n, m = i-interval*j, i-interval*(j+1)
if a[n] < a[m]:
a[n], a[m] = a[m], a[n]
j += 1
count += 1
else:
break
print((len(intervals)))
print((" ".join([str(n) for n in intervals])))
print(count)
print(("\n".join([str(n) for n in a])))
shellsort([int(eval(input())) for _ in range(int(eval(input())))]) | def shellsort(a):
l = len(a)
intervals = [n for n in (40, 13, 4, 1) if n <= l]
count = 0
for interval in intervals:
for i in range(interval, l):
v = a[i]
j = i-interval
while j >= 0 and v < a[j]:
a[j+interval] = a[j]
j -= interval
count += 1
a[j+interval] = v
print((len(intervals)))
print((" ".join([str(n) for n in intervals])))
print(count)
print(("\n".join([str(n) for n in a])))
shellsort([int(eval(input())) for _ in range(int(eval(input())))]) | p02262 |
def insertion_sort(a, n, g):
count = 0
for i in range(g, n):
for j in range(i, g-1, -g):
if a[j-g] > a[j]:
a[j-g], a[j] = a[j], a[j-g]
count += 1
return a, count
if __name__ == "__main__":
import sys
n = int(input())
a = list(map(int, sys.stdin))
count = 0
G = [1]
while n > 3*G[-1] + 1:
G.append(3*G[-1] + 1)
for g in G[::-1]:
a, cnt = insertion_sort(a, n, g)
count += cnt
print(len(G))
print(*G[::-1])
print(count)
print(*a, sep="\n")
| def insertion_sort(a, n, g):
count = 0
for i in range(g, n):
j = i
while j >= g and a[j-g] > a[j]:
a[j-g], a[j] = a[j], a[j-g]
j -= g
count += 1
return a, count
if __name__ == "__main__":
import sys
n = int(input())
a = list(map(int, sys.stdin))
count = 0
G = [1]
while n >= 3*G[-1] + 1:
G.append(3*G[-1] + 1)
for g in G[::-1]:
a, cnt = insertion_sort(a, n, g)
count += cnt
print(len(G))
print(*G[::-1])
print(count)
print(*a, sep="\n")
| p02262 |
def insertion_sort(A, N, gap):
cnt = 0
for i in range(gap, N):
tmp = A[i]
j = i - gap
while j>=0 and A[j] > tmp:
A[j+gap] = A[j]
j = j - gap
cnt = cnt + 1
A[j+gap] = tmp
return cnt
def shell_sort(A, N):
cnt = 0
gaps = [int((3**item-1)/2) for item in range(1, 100) if int((3**item-1)/2) <= N][::-1]
m = len(gaps)
for gap in gaps:
cnt = cnt + insertion_sort(A, N, gap)
print(m)
print((' '.join([str(gap) for gap in gaps])))
print(cnt)
for i in range(0, N):
print((A[i]))
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
shell_sort(A, N) | def insertion_sort(A, N, gap):
global cnt
for i in range(gap, N):
tmp = A[i]
j = i - gap
while j>=0 and A[j] > tmp:
A[j+gap] = A[j]
j = j - gap
cnt += 1
A[j+gap] = tmp
def shell_sort(A, N):
gaps = [int((3**item-1)/2) for item in range(1, 100) if int((3**item-1)/2) <= N][::-1]
m = len(gaps)
for gap in gaps:
insertion_sort(A, N, gap)
print(m)
print((' '.join([str(gap) for gap in gaps])))
print(cnt)
print(('\n'.join([str(item) for item in A])))
cnt = 0
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
shell_sort(A, N) | p02262 |
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
n = int(input())
A = [int(input()) for i in range(n)]
cnt = 0
G = []
for i in range(100):
if n < 1 + 3*i:
break
G.append(1 + 3*i)
m = len(G)
G.reverse()
for i in range(m):
insertionSort(A, n, G[i])
print(m)
print(*G)
print(cnt)
print(*A, sep='\n')
| def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
n = int(input())
A = [int(input()) for i in range(n)]
cnt = 0
G = [1]
for i in range(99):
if n < 1 + 3*G[-1]:
break
G.append(1 + 3*G[-1])
m = len(G)
G.reverse()
for i in range(m):
insertionSort(A, n, G[i])
print(m)
print(*G)
print(cnt)
print(*A, sep='\n')
| p02262 |
import sys
def print_arr(arr):
for i in range(len(arr)):
sys.stdout.write(str(arr[i]))
if i != len(arr) - 1:
sys.stdout.write(' ')
print()
def insertion_sort(arr, n, g):
cnt = 0
for i in range(g, n):
v = arr[i]
j = i - g
while j >= 0 and arr[j] > v:
arr[j + g] = arr[j]
j = j - g
cnt += 1
arr[j + g] = v
return cnt
def shell_sort(arr, g):
cnt = 0
for i in range(len(g)):
cnt += insertion_sort(arr, len(arr), g[i])
return cnt
def get_gap(n):
lst = []
v = 1
cnt = 1
while v <= n:
lst.append(v)
v += 3**cnt
cnt += 1
if len(lst) == 0: lst.append(1)
return list(reversed(lst))
n = int(eval(input()))
arr = [0] * n
for i in range(n):
arr[i] = int(eval(input()))
g = get_gap(n)
m = len(g)
cnt = shell_sort(arr, g)
print(m)
print_arr(g)
print(cnt)
for i in range(n):
print((arr[i]))
| import sys
def print_A(A):
for i in range(len(A)):
sys.stdout.write(str(A[i]))
if i!= len(A) -1:
sys.stdout.write(' ')
print()
def insertionSort(A,n,g):
cnt = 0
for i in range(g,n):
v = A[i]
j = i - g
while (j>=0) and (A[j] > v):
A[j + g] = A[j]
j -= g
cnt +=1
A[j + g] = v
return cnt
def shellSort(A,n,G):
cnt = 0
for i in range(len(G)):
cnt += insertionSort(A,n,G[i])
return cnt
def get_gap(n):
G = []
h = 1
cnt = 1
while h <= n:
G.append(h)
h = 3*h + 1
cnt +=1
if len(G) == 0: G.append(1)
return list(reversed(G))
n = int(eval(input()))
A = [0] * n
for i in range(n):
A[i] = int(eval(input()))
G = get_gap(n)
m = len(G)
cnt = shellSort(A,n,G)
print(m)
print_A(G)
print(cnt)
for i in range(n):
print((A[i]))
| p02262 |
import sys
readline = sys.stdin.readline
def insertionSort(A, n, g, cnt):
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j -= g
cnt += 1
A[j + g] = v
return cnt
def shellSort(A, n):
cnt = 0
h = 4
G = [1]
while h < n:
G += [h]
h = 3 * h + 1
m = len(G)
for i in range(m - 1, -1, -1):
cnt = insertionSort(A, n, G[i], cnt)
print(m)
print(*G[::-1])
print(cnt)
print(*A, sep="\n")
n = int(input())
# A = [int(readline()) for _ in range(n)]
A = list(map(int, sys.stdin.readlines()))
shellSort(A, n)
| import sys
readline = sys.stdin.readline
def insertionSort(A, n, g, cnt):
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j -= g
cnt += 1
A[j + g] = v
return cnt
def shellSort(A, n):
cnt = 0
h = 4
G = [1]
while h < n:
G += [h]
h = 3 * h + 1
m = len(G)
for i in range(m - 1, -1, -1):
cnt = insertionSort(A, n, G[i], cnt)
print(m)
print(*G[::-1])
print(cnt)
print(*A, sep="\n")
n = int(input())
# A = [int(readline()) for _ in range(n)]
A = list(map(int, sys.stdin))
shellSort(A, n)
| p02262 |
def isort(a, n, g):
global cnt
for i in range(g, n):
v = a[i]
j = i - g
while j >= 0 and a[j] > v:
a[j + g] = a[j]
j -= g
cnt += 1
a[j + g] = v
# input data
n = int(eval(input()))
a = []
for i in range(n):
a.append(int(eval(input())))
# determine m, g
g = [1]
m = 1
while True:
x = 3 * g[m - 1] + 1
if x > n: break
g.append(x)
m += 1
g = g[::-1]
# 1 output m
print(m)
# 2 output g
print((' '.join(map(str, g))))
# sort it
cnt = 0
for i in range(m):
isort(a, n, g[i])
# 3 output cnt
print(cnt)
# 4 output sorted a
for i in range(n):
print((a[i])) | import sys
def isort(a, n, g):
global cnt
for i in range(g, n):
v = a[i]
j = i - g
while j >= 0 and a[j] > v:
a[j + g] = a[j]
j -= g
cnt += 1
a[j + g] = v
# input data
n = int(sys.stdin.readline())
a = []
for i in range(n):
a.append(int(sys.stdin.readline()))
# determine m, g
g = [1]
m = 1
while True:
x = 3 * g[m - 1] + 1
if x >= n: break
g.append(x)
m += 1
g = g[::-1]
# 1 output m
print(m)
# 2 output g
print((' '.join(map(str, g))))
# sort it
cnt = 0
for i in range(m):
isort(a, n, g[i])
# 3 output cnt
print(cnt)
# 4 output sorted a
for i in range(n):
print((a[i])) | p02262 |
import sys
def isort(a, n, g):
global cnt
for i in range(g, n):
v = a[i]
j = i - g
while j >= 0 and a[j] > v:
a[j + g] = a[j]
j -= g
cnt += 1
a[j + g] = v
# input data
n = int(sys.stdin.readline())
a = []
for i in range(n):
a.append(int(sys.stdin.readline()))
# determine m, g
g = [1]
m = 1
while True:
x = 3 * g[m - 1] + 1
if x >= n: break
g.append(x)
m += 1
g = g[::-1]
# 1 output m
print(m)
# 2 output g
print((' '.join(map(str, g))))
# sort it
cnt = 0
for i in range(m):
isort(a, n, g[i])
# 3 output cnt
print(cnt)
# 4 output sorted a
print(('\n'.join(map(str, a)))) | def isort(a, n, g):
global cnt
for i in range(g, n):
v = a[i]
j = i - g
while j >= 0 and a[j] > v:
a[j + g] = a[j]
j -= g
cnt += 1
a[j + g] = v
# input data
n = int(input())
a = []
for i in range(n):
a.append(int(input()))
# determine m, g
g = [1]
m = 1
while True:
x = 3 * g[m - 1] + 1
if x >= n: break
g.append(x)
m += 1
g = g[::-1]
# 1 output m
print(m)
# 2 output g
print((' '.join(map(str, g))))
# sort it
cnt = 0
for i in range(m):
isort(a, n, g[i])
# 3 output cnt
print(cnt)
# 4 output sorted a
print(('\n'.join(map(str, a)))) | p02262 |
swap_count = 0
def main():
num = int(eval(input()))
elements = []
for i in range(0, num):
elements.append(int(eval(input())))
# Get intervals
interval = 1
intervals = [interval]
while True:
interval = int_f(interval)
if interval > num:
break
intervals.append(interval)
intervals.reverse()
for interval in intervals:
insertion_sort(elements, num, interval)
print((len(intervals)))
print((' '.join([str(interval) for interval in intervals])))
print(swap_count)
for val in elements:
print(val)
def int_f(x):
return 3 * x + 1
def insertion_sort(elements, num, interval=1):
global swap_count
i = interval
while i < num:
j = i
while interval <= j:
if elements[j - interval] <= elements[j]:
break
elements[j - interval], elements[j] = elements[j], elements[j - interval]
swap_count += 1
j -= interval
i += 1
if __name__ == '__main__':
main() | swap_count = 0
def main():
num = int(eval(input()))
elements = []
for i in range(0, num):
elements.append(int(eval(input())))
# Get intervals
interval = 1
intervals = [interval]
while True:
interval = int_f(interval)
if interval > num:
break
intervals.insert(0, interval)
# intervals.reverse()
for interval in intervals:
insertion_sort(elements, num, interval)
print((len(intervals)))
print((' '.join([str(interval) for interval in intervals])))
print(swap_count)
for val in elements:
print(val)
def int_f(x):
return 3 * x + 1
def insertion_sort(elements, num, interval=1):
global swap_count
i = interval
while i < num:
j = i
while interval <= j:
if elements[j - interval] <= elements[j]:
break
elements[j - interval], elements[j] = elements[j], elements[j - interval]
swap_count += 1
j -= interval
i += 1
if __name__ == '__main__':
main() | p02262 |
import sys
import math
from collections import deque
def insertion_sort(a, n, g):
ct = 0
for i in range(g,n):
v = a[i]
j = i-g
while j >= 0 and a[j] > v:
a[j+g] = a[j]
j = j-g
ct += 1
a[j+g] = v
return ct
n = int(input())
a = list(map(int, sys.stdin.readlines()))
b = 701
ct= 0
g = deque([x for x in [701,301,132,57,23,10,4,1] if x <= n])
while True:
b = math.floor(2.25*b)
if b > n:
break
g.appendleft(b)
for i in g:
ct += insertion_sort(a, n, i)
print(len(g))
print(*g, sep=" ")
print(ct)
print(*a, sep="\n")
| import sys
import math
def insertion_sort(a, n, g):
ct = 0
for i in range(g,n):
v = a[i]
j = i-g
while j >= 0 and a[j] > v:
a[j+g] = a[j]
j = j-g
ct += 1
a[j+g] = v
return ct
n = int(input())
a = list(map(int, sys.stdin.readlines()))
b = 701
ct= 0
g = [x for x in [1,4,10,23,57,132,301,701] if x <= n]
while True:
b = math.floor(2.25*b)
if b > n:
break
g.append(b)
g = g[::-1]
for i in g:
ct += insertion_sort(a, n, i)
print(len(g))
print(*g, sep=" ")
print(ct)
print(*a, sep="\n")
| p02262 |
import sys
import math
def insertion_sort(a, n, g):
ct = 0
for j in range(0,n-g):
v = a[j+g]
while j >= 0 and a[j] > v:
a[j+g] = a[j]
j = j-g
ct += 1
a[j+g] = v
return ct
n = int(input())
a = list(map(int, sys.stdin.readlines()))
b = 701
ct= 0
g = [x for x in [1,4,10,23,57,132,301,701] if x <= n]
while True:
b = math.floor(2.25*b)
if b > n:
break
g.append(b)
g = g[::-1]
for i in g:
ct += insertion_sort(a, n, i)
print(len(g))
print(*g, sep=" ")
print(ct)
print(*a, sep="\n")
| import sys
import math
ct= 0
def insertion_sort(a, n, g):
global ct
for j in range(0,n-g):
v = a[j+g]
while j >= 0 and a[j] > v:
a[j+g] = a[j]
j = j-g
ct += 1
a[j+g] = v
n = int(input())
a = list(map(int, sys.stdin.readlines()))
b = 701
g = [x for x in [1,4,10,23,57,132,301,701] if x <= n]
while True:
b = math.floor(2.25*b)
if b > n:
break
g.append(b)
g = g[::-1]
for i in g:
insertion_sort(a, n, i)
print(len(g))
print(*g, sep=" ")
print(ct)
print(*a, sep="\n")
| p02262 |
def insertion_sort(num_list,gap):
global cnt
for i in range(gap,len(num_list)):
evc = num_list[i]
j = i-gap
while j >= 0 and num_list[j] > evc:
num_list[j+gap] = num_list[j]
j = j-gap
cnt += 1
num_list[j+gap] = evc
def shell_sort(num_list):
global cnt
cnt = 0
m_list = []
h = 1
while h <= len(num_list):
m_list.append(h)
h = 3*h+1
m_list.reverse()
m = len(m_list)
print(m)
print((' '.join([str(i) for i in m_list])))
for i in range(m):
insertion_sort(num_list,m_list[i])
n = int(eval(input()))
num_list = [int(eval(input())) for _ in range(n)]
shell_sort(num_list)
print(cnt)
for num in num_list:
print(num)
| def insertion_sort(num_list,gap):
global cnt
for i in range(gap,len(num_list)):
swap_num = num_list[i]
j = i-gap
while j >= 0 and num_list[j] > swap_num:
num_list[j+gap] = num_list[j]
j -= gap
cnt += 1
num_list[j+gap] = swap_num
def shell_sort(num_list):
global cnt
cnt = 0
m = 1
m_list = []
while len(num_list) >= m:
m_list.append(m)
m = 3*m+1
m_list.reverse()
print((len(m_list)))
print((' '.join([str(i) for i in m_list])))
for i in range(len(m_list)):
insertion_sort(num_list,m_list[i])
print(cnt)
n = int(eval(input()))
num_list = [int(eval(input())) for _ in range(n)]
shell_sort(num_list)
for num in num_list:
print(num)
| p02262 |
n = int(eval(input()))
A = [int(eval(input())) for i in range(n)]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j -= g
cnt +=1
A[j + g] = v
def shellSort(A, n, m, G):
A1 = A[:]
global cnt
cnt = 0
for i in range(m):
insertionSort(A1, n, G[i])
return A1
def Gmake(n):
G=[]
k = 1
while k <= n and len(G) < 100:
G.append(k)
k += 3
G.reverse()
return G
G = Gmake(n)
A2 = shellSort(A, n, len(G), G)
print((str(len(G))))
print((" ".join(map(str, G))))
print((str(cnt)))
for i in A2:
print((str(i))) | n = int(eval(input()))
A = [int(eval(input())) for i in range(n)]
def insertionSort(A, n, g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j + g] = A[j]
j -= g
cnt +=1
A[j + g] = v
def shellSort(A, n, m, G):
A1 = A[:]
global cnt
cnt = 0
for i in range(m):
insertionSort(A1, n, G[i])
return A1
def Gmake(n):
G=[]
k = 1
while k <= n and len(G) < 100:
G.append(k)
k = 3 * k + 1
G.reverse()
return G
G = Gmake(n)
A2 = shellSort(A, n, len(G), G)
print((str(len(G))))
print((" ".join(map(str, G))))
print((str(cnt)))
for i in A2:
print((str(i))) | p02262 |
def insertionSort( nums, n, g ):
cnt = 0
i = g
while i < len( nums ):
v = nums[i]
j = i - g
while 0 <= j and v < nums[j]:
nums[ j+g ] = nums[j]
j -= g
cnt += 1
nums[ j+g ] = v
i += 1
return cnt
def shellSort( nums, n ):
cnt = 0
g = []
val =0
for i in range( 0, n ):
val = 3*val+1
if n < val:
break
g.append( val )
g.reverse( )
m = len( g )
print( m )
print(( " ".join( map( str, g ) ) ))
for i in range( 0, m ):
cnt += insertionSort( nums, n, g[i] )
print( cnt )
n = int( input( ) )
nums = []
for i in range( 0, n ):
nums.append( int( input( ) ) )
shellSort( nums, n )
for val in nums:
print( val ) | def insertionSort( nums, g ):
cnt = 0
i = g
n = len( nums )
while i < n:
v = nums[i]
j = i - g
while 0 <= j and v < nums[j]:
nums[ j+g ] = nums[j]
j -= g
cnt += 1
nums[ j+g ] = v
i += 1
return cnt
def shellSort( nums, n ):
cnt = 0
g = []
val =0
for i in range( 0, n ):
val = 3*val+1
if n < val:
break
g.append( val )
g.reverse( )
m = len( g )
print( m )
print(( " ".join( map( str, g ) ) ))
for i in range( 0, m ):
cnt += insertionSort( nums, g[i] )
print( cnt )
n = int( input( ) )
nums = []
for i in range( 0, n ):
nums.append( int( input( ) ) )
shellSort( nums, n )
for val in nums:
print( val ) | p02262 |
def insertionSort( nums, g ):
cnt = 0
i = g
n = len( nums )
while i < n:
v = nums[i]
j = i - g
while 0 <= j and v < nums[j]:
nums[ j+g ] = nums[j]
j -= g
cnt += 1
nums[ j+g ] = v
i += 1
return cnt
def shellSort( nums, n ):
cnt = 0
g = []
val =0
for i in range( 0, n ):
val = 3*val+1
if n < val:
break
g.append( val )
g.reverse( )
m = len( g )
print( m )
print(( " ".join( map( str, g ) ) ))
for i in range( 0, m ):
cnt += insertionSort( nums, g[i] )
print( cnt )
n = int( input( ) )
nums = []
for i in range( 0, n ):
nums.append( int( input( ) ) )
shellSort( nums, n )
for val in nums:
print( val ) | import sys
def insertionSort( nums, n, g ):
cnt = 0
i = g
while i < n:
v = nums[i]
j = i - g
while 0 <= j and v < nums[j]:
nums[ j+g ] = nums[j]
j -= g
cnt += 1
nums[ j+g ] = v
i += 1
return cnt
def shellSort( nums, n ):
g = []
val =0
for i in range( n ):
val = 3*val+1
if n < val:
break
g.append( val )
g.reverse( )
m = len( g )
print( m )
print(( " ".join( map( str, g ) ) ))
cnt = 0
for i in range( m ):
cnt += insertionSort( nums, n, g[i] )
print( cnt )
n = int( sys.stdin.readline( ) )
nums = []
for i in range( n ):
nums.append( int( sys.stdin.readline( ) ) )
cnt = 0
shellSort( nums, n )
print(( "\n".join( map( str, nums ) ) )) | p02262 |
def insertionSort( nums, n, g ):
cnt = 0
for i in range( g, n ):
v = nums[i]
j = i - g
while j >= 0 and nums[j] > v:
nums[ j+g ] = nums[j]
j -= g
cnt += 1
nums[ j+g ] = v
return cnt
def shellSort( nums, n ):
g = []
v = 1
while v <= n:
g.append( v )
v = 3*v+1
g.reverse( )
m = len( g )
print( m )
print(( " ".join( map( str, g ) ) ))
cnt = 0
for i in range( m ):
cnt += insertionSort( nums, n, g[i] )
print( cnt )
n = int( eval(input( )) )
nums = [ int( eval(input( )) ) for i in range( n ) ]
nums.append( 0 )
shellSort( nums, n )
nums.pop( )
for v in nums:
print( v ) | import sys
def insertionSort( nums, n, g ):
cnt = 0
i = g
while i < n:
v = nums[i]
j = i - g
while 0 <= j and v < nums[j]:
nums[ j+g ] = nums[j]
j -= g
cnt += 1
nums[ j+g ] = v
i += 1
return cnt
def shellSort( nums, n ):
g = []
val = 1
while val <= n:
g.append( val )
val = 3*val+1
g.reverse( )
m = len( g )
print( m )
print(( " ".join( map( str, g ) ) ))
cnt = 0
for i in range( m ):
cnt += insertionSort( nums, n, g[i] )
print( cnt )
n = int( sys.stdin.readline( ) )
nums = []
for i in range( n ):
nums.append( int( sys.stdin.readline( ) ) )
shellSort( nums, n )
print(( "\n".join( map( str, nums ) ) )) | p02262 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import math
def generate_intervals(n):
if n > 1:
l = math.ceil(math.log(2 * n + 1, 3))
return [(3 ** i - 1) // 2 for i in range(l - 1, 0, -1)]
else:
return [1]
class Sort(object):
def __init__(self, array, num):
self.a = array
self.n = num
self.cnt = 0
self.gs = generate_intervals(self.n)
self.m = len(self.gs)
def insertionsort(self, g):
for i in range(g, self.n):
v = self.a[i]
j = i - g
while j >= 0 and self.a[j] > v:
self.a[j + g] = self.a[j]
j = j - g
self.cnt += 1
self.a[j + g] = v
def shellsort(self):
for i in range(0, self.m):
self.insertionsort(self.gs[i])
def main():
n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
s = Sort(a, n)
s.shellsort()
print((s.m))
print((" ".join(map(str, s.gs))))
print((s.cnt))
for i in range(n):
print((s.a[i]))
if __name__ == "__main__":
main() | #!/usr/bin/env python3
def construct_gs(n):
gs = []
g = 1
while g <= n:
gs.append(g)
g = 3 * g + 1
return gs[::-1]
def shell_sort(xs, n):
global cnt
cnt = 0
gs = construct_gs(n)
m = len(gs)
def insertion_sort(g):
global cnt
for i in range(g, n):
v = xs[i]
j = i - g
while j >= 0 and xs[j] > v:
xs[j + g] = xs[j]
j = j - g
cnt += 1
xs[j + g] = v
for g in gs:
insertion_sort(g)
return m, gs, cnt, xs
def main():
n = int(eval(input()))
xs = [int(eval(input())) for _ in range(n)]
m, gs, cnt, xs = shell_sort(xs, n)
print(m)
print((" ".join(map(str, gs))))
print(cnt)
for x in xs:
print(x)
if __name__ == '__main__':
main() | p02262 |
n = int(eval(input()))
A = list()
for i in range(0, n):
A.append(int(eval(input())))
G = [1]
cnt = 0
for l in range(1, 100):
h = 3 * G[l - 1] + 1
if(h > n):
m = l
break
else:
G.append(3*G[l-1] + 1)
for g in reversed(G):
for t in range(g, n):
v = A[t]
j = t - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
print(m)
print((" ".join(str(x) for x in reversed(G))))
print(cnt)
print(("\n".join(str(x) for x in A))) | n = int(eval(input()))
A = list()
for i in range(0, n):
A.append(int(eval(input())))
G = [1] # G[0]????????¨?????????
cnt = 0
# G[i] = 3*Gi-1 + 1
for i in range(1, 100):
h = 3 * G[i - 1] + 1
if(h > n): # h???n?¶???????????????§??????
m = i
break
else:
G.append(h)
for g in reversed(G):
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
print(m)
print((" ".join(str(x) for x in reversed(G))))
print(cnt)
print(("\n".join(str(x) for x in A))) | p02262 |
cnt = 0
n = int(input())
A = [int(input()) for _ in range(n)]
G = [1] if n < 5 else [1, 4]
while G[-1]*3+1 <= n/5: G.append(G[-1]*3+1)
G.reverse()
def insersionSort(g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
def shellSort():
for g in G:
insersionSort(g)
shellSort()
print(len(G))
print(" ".join(map(str, G)))
print(cnt)
print("\n".join(map(str, A))) | cnt = 0
n = int(input())
A = [int(input()) for _ in range(n)]
G = [1] if n < 5 else [1, 4]
while G[-1]*3+1 <= n/3: G.append(G[-1]*3+1)
G.reverse()
def insersionSort(g):
global cnt
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
cnt += 1
A[j+g] = v
def shellSort():
for g in G:
insersionSort(g)
shellSort()
print(len(G))
print(" ".join(map(str, G)))
print(cnt)
print("\n".join(map(str, A))) | p02262 |
N, M, K = list(map(int,input().split()))
MOD = 10**9+7
def cmb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
# 0~N*M-1までの1次元上と考える
ans = 0
def f(x):
return x*(x+1)//2
c = cmb(N*M-2,K-2)
for i in range(N*M):
tate, yoko = i//M, i%M
migi = f(M-1-yoko)
hidari = f(yoko)
sita = (hidari+migi)*(N-1-tate) + M*f(N-1-tate)
coef = migi + sita
ans += coef*c
ans %= MOD
print(ans)
| N, M, K = list(map(int,input().split()))
MOD = 10**9+7
def framod(n, mod, a=1):
for i in range(1,n+1):
a=a * i % mod
return a
def power(n, r, mod):
if r == 0: return 1
if r%2 == 0:
return power(n*n % mod, r//2, mod) % mod
if r%2 == 1:
return n * power(n, r-1, mod) % mod
def comb(n, k, mod):
a=framod(n, mod)
b=framod(k, mod)
c=framod(n-k, mod)
return (a * power(b, mod-2, mod) * power(c, mod-2, mod)) % mod
# 0~N*M-1までの1次元上と考える
ans = 0
def f(x):
return x*(x+1)//2
c = comb(N*M-2,K-2,MOD)
for i in range(N*M):
tate, yoko = i//M, i%M
migi = f(M-1-yoko)
hidari = f(yoko)
sita = (hidari+migi)*(N-1-tate) + M*f(N-1-tate)
coef = migi + sita
ans += coef*c
ans %= MOD
print(ans)
| p03039 |
from functools import reduce
from operator import mul
MOD = 1000000007
def combination(n, r):
r = min(n - r, r)
if r == 0:
return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1, r + 1)))
return over // under
def main():
N, M, K = [int(i) for i in input().strip().split(' ')]
c = combination(N * M - 2, K - 2) % MOD
X = sum([(M - i) * i for i in range(M)])
Y = sum([(N - i) * i for i in range(N)])
total = X * (N ** 2) + Y * (M ** 2) % MOD
total = total * c % MOD
print(total)
main() | def mfactorial(n: int, mod: int) -> int:
cache = mfactorial.__cache if hasattr(mfactorial, '__cache') else [1, 1]
n_len = len(cache)
n_new = n - n_len + 1
if n_new > 0:
cache = cache + ([0] * n_new)
for i in range(n_len, n + 1):
cache[i] = cache[i - 1] * i % mod
mfactorial.__cache = cache
return mfactorial.__cache[n]
def cmb(n, r, mod):
result = mfactorial(n, mod)
result *= pow(mfactorial(r, mod), mod - 2, mod) % mod
result %= mod
result *= pow(mfactorial(n - r, mod), mod - 2, mod) % mod
result %= mod
return result
def main():
MOD = 10 ** 9 + 7
N, M, K = [int(i) for i in input().strip().split(' ')]
c = cmb(N * M - 2, K - 2, MOD)
X = 0
Y = 0
for i in range(M):
X += (M - i) * i
for i in range(N):
Y += (N - i) * i
total = (X * (N ** 2) + Y * (M ** 2)) % MOD * c % MOD
print(total)
main() | p03039 |
def mfactorial(n: int, mod: int) -> int:
cache = mfactorial.__cache if hasattr(mfactorial, '__cache') else [1, 1]
n_len = len(cache)
n_new = n - n_len + 1
if n_new > 0:
cache = cache + ([0] * n_new)
for i in range(n_len, n + 1):
cache[i] = cache[i - 1] * i % mod
mfactorial.__cache = cache
return mfactorial.__cache[n]
def cmb(n, r, mod):
result = mfactorial(n, mod)
result *= pow(mfactorial(r, mod), mod - 2, mod) % mod
result %= mod
result *= pow(mfactorial(n - r, mod), mod - 2, mod) % mod
result %= mod
return result
def main():
MOD = 10 ** 9 + 7
N, M, K = [int(i) for i in input().strip().split(' ')]
c = cmb(N * M - 2, K - 2, MOD)
X = 0
Y = 0
for i in range(M):
X += (M - i) * i
for i in range(N):
Y += (N - i) * i
total = (X * (N ** 2) + Y * (M ** 2)) % MOD * c % MOD
print(total)
main() | def mod_combination(mod: int, n: int, r: int) -> int:
a, b, c = mod_factorials(mod, [n, r, n - r])
return a * pow(b, mod - 2, mod) % mod * pow(c, mod - 2, mod) % mod
def mod_factorials(mod: int, N: [int]) -> [int]:
result = [1] * len(N)
tuples = sorted([(i, n) for i, n in enumerate(N)], key=lambda t: t[1])
fact = 1
i = 1
for t in tuples:
for j in range(i, t[1] + 1):
fact = fact * j % mod
i = i + 1
result[t[0]] = fact
return result
def main():
MOD = 10 ** 9 + 7
N, M, K = [int(i) for i in input().strip().split(' ')]
c = mod_combination(MOD, N * M - 2, K - 2)
X = 0
Y = 0
for i in range(M):
X += (M - i) * i
for i in range(N):
Y += (N - i) * i
total = (X * (N ** 2) + Y * (M ** 2)) % MOD * c % MOD
print(total)
main() | p03039 |
N, M, K = [int(item) for item in input().split()]
MOD = 10**9 + 7
n = 5 * 10**5
fac = [1] + [0] * n
fac_inv = [1] + [0] * n
for i in range(1, n+1):
fac[i] = fac[i-1] * (i) % MOD
# Fermat's little theorem says
# a**(p-1) mod p == 1
# then, a * a**(p-2) mod p == 1
# it means a**(p-2) is inverse element
fac_inv[i] = fac_inv[i-1] * pow(i, MOD-2, MOD) % MOD
def mod_nCr(n, r):
if n == 0 and r == 0:
return 1
if n < r or n < 0:
return 0
tmp = fac_inv[n-r] * fac_inv[r] % MOD
return tmp * fac[n] % MOD
total = 0
for i in range(M):
total += (M - i) * N * N * mod_nCr(M * N - 2, K - 2) * i
total %= MOD
for i in range(N):
total += (N - i) * M * M * mod_nCr(M * N - 2, K - 2) * i
total %= MOD
print(total) | N, M, K = [int(item) for item in input().split()]
MOD = 10**9 + 7
n = 2 * 10**5 + 10
fac = [1] + [0] * n
fac_inv = [1] + [0] * n
for i in range(1, n+1):
fac[i] = fac[i-1] * (i) % MOD
# Fermat's little theorem says
# a**(p-1) mod p == 1
# then, a * a**(p-2) mod p == 1
# it means a**(p-2) is inverse element
fac_inv[i] = fac_inv[i-1] * pow(i, MOD-2, MOD) % MOD
def mod_nCr(n, r):
if n == 0 and r == 0:
return 1
if n < r or n < 0:
return 0
tmp = fac_inv[n-r] * fac_inv[r] % MOD
return tmp * fac[n] % MOD
total = 0
for i in range(M):
total += (M - i) * N * N * mod_nCr(M * N - 2, K - 2) * i
total %= MOD
for i in range(N):
total += (N - i) * M * M * mod_nCr(M * N - 2, K - 2) * i
total %= MOD
print(total) | p03039 |
N, M, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def comb(n, k):
ret = 1
for i in range(1, k + 1):
ret = ret * (n - i + 1) % MOD
ret = ret * pow(i, MOD - 2, MOD) % MOD
return ret
ans = 0
for d in range(N):
ans += d * comb(N * M - 2, K - 2) * (N - d) * M ** 2
ans %= MOD
for d in range(M):
ans += d * comb(N * M - 2, K - 2) * (M - d) * N ** 2
ans %= MOD
print(ans)
| N, M, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
def comb(n, k):
ret = 1
for i in range(1, k + 1):
ret = ret * (n - i + 1) % MOD
ret = ret * pow(i, MOD - 2, MOD) % MOD
return ret
ans = 0
for d in range(N):
ans += d * (N - d) * M ** 2
ans %= MOD
for d in range(M):
ans += d * (M - d) * N ** 2
ans %= MOD
print((ans * comb(N * M - 2, K - 2) % MOD))
| p03039 |
# -*- coding: utf-8 -*-
"""
Created on Sat May 25 21:24:29 2019
@author: Yamazaki Kenichi
"""
N, M, K = list(map(int,input().split()))
mod = 10**9+7
def cmb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N*M+1):
g1.append((g1[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inv[-1]) % mod)
def a(N,M):
return N*(N+1)//2*(M+1) + M*(M+1)//2*(N+1)
def b(N):
return N*(N+1)//2
ans = 0
for i in range(N):
for j in range(M):
ans += a(i,j) + a(N-i-1,j) + a(i,M-j-1) + a(N-i-1,M-j-1)
ans -= b(i) + b(j) + b(N-i-1) + b(M-j-1)
ans %= mod
# print(i,j,a(i,j),a(N-i-1,j),a(i,M-j-1),a(N-i-1,M-j-1),b(i),b(j),ans)
ans *= g2[2]
ans *= cmb(N*M-2,K-2,mod)
ans %= mod
print(ans)
| # -*- coding: utf-8 -*-
"""
Created on Wed May 29 22:49:19 2019
@author: Yamazaki Kenichi
"""
# -*- coding: utf-8 -*-
"""
Created on Sat May 25 21:24:29 2019
@author: Yamazaki Kenichi
"""
N, M, K = list(map(int,input().split()))
mod = 10**9+7
def cmb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N*M+1):
g1.append((g1[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inv[-1]) % mod)
ans1 = 0
def c(N,M):
res = 0
for i in range(1,N):
res += i*(N-i)*M*M
return res
ans1 += c(N,M) + c(M,N)
ans1 %= mod
ans1 *= cmb(N*M-2,K-2,mod)
ans1 %= mod
print(ans1)
| p03039 |
from math import factorial
n,m,K=list(map(int,input().split()))
ans=0
def comb(n,r):
return factorial(n)//factorial(n-r)//factorial(r)
for i in range(3,n+m+1):
t=0
for j in range(max(1,i-n),i):
if(j>m):
ans+=t*(i-2)
break
k=i-j
if(j==1 or k==1):
t+=(m-j+1)*(n-k+1)
else:
t+=(m-j+1)*(n-k+1)*2
else:
ans+=t*(i-2)
print(((ans*comb(n*m-2,K-2))%(10**9+7))) | n,m,k=list(map(int,input().split()))
mod=10**9+7
x=1
y=1
for i in range(1,k-1):
y*=i
y%=mod
for i in range(k-2):
x*=n*m-2-i
x%=mod
x*=pow(y,mod-2,mod)
x%=mod
def f(n,m):
s=0
for i in range(1,n):
s+=i*(n-i)
s%=mod
return s*m*m%mod
print(((f(n,m)+f(m,n))*x%mod)) | p03039 |
N, M, K = list(map(int, input().split()))
import math
from operator import mul
from functools import reduce
def combinations_count(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
ans_x = 0
c = combinations_count(N*M-2, K-2)
#for i in range(1, N+1):
# ans_x += N*(N+1)//2-i*(i+1)//2-i*(N-i)
#for j in range(i+1, N+1):
# ans_x += j-i
ans_x = (N*N*(N+1) + N*(N+1)*(2*N+1)//6 - (2*N+1)*N*(N+1)//2)//2
ans_x = M*M*ans_x*c
ans_y = 0
c = combinations_count(N*M-2, K-2)
#for i in range(1, M+1):
# ans_y += M*(M+1)//2-i*(i+1)//2-i*(M-i)
#for j in range(i+1, M+1):
# ans_y += j-i
ans_y = (M*M*(M+1) + M*(M+1)*(2*M+1)//6 - (2*M+1)*M*(M+1)//2)//2
ans_y = N*N*ans_y*c
ans = (ans_x+ans_y)%(10**9+7)
print(ans) | N, M, K = list(map(int, input().split()))
import math
from operator import mul
from functools import reduce
def combinations_count(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
ans_x = 0
c = combinations_count(N*M-2, K-2)
#for i in range(1, N+1):
# ans_x += N*(N+1)//2-i*(i+1)//2-i*(N-i)
#for j in range(i+1, N+1):
# ans_x += j-i
ans_x = (N*N*(N+1) + N*(N+1)*(2*N+1)//6 - (2*N+1)*N*(N+1)//2)//2
ans_x = M*M*ans_x*c
ans_y = 0
c = combinations_count(N*M-2, K-2)
#for i in range(1, M+1):
# ans_y += M*(M+1)//2-i*(i+1)//2-i*(M-i)
#for j in range(i+1, M+1):
# ans_y += j-i
ans_y = (M*M*(M+1) + M*(M+1)*(2*M+1)//6 - (2*M+1)*M*(M+1)//2)//2
ans_y = N*N*ans_y*c
ans = (ans_x+ans_y)%(10**9+7)
print(ans) | p03039 |
H, W, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
Hd = sum([d * (H - d) * (W ** 2) for d in range(H)])
Wd = sum([d * (W - d) * (H ** 2) for d in range(W)])
# 階乗 & 逆元計算
factorial = [1]
inverse = [1]
for i in range(1, H * W + 2):
factorial.append(factorial[-1] * i % MOD)
inverse.append(pow(factorial[-1], MOD - 2, MOD))
ans = (Hd + Wd) * factorial[H * W - 2] * inverse[K - 2] * inverse[H * W - K] % MOD
print(ans)
| H, W, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
factorial = [1, 1] # 元テーブル
inverse = [1, 1] # 逆元テーブル
inverse_from = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, H * W + 1):
factorial.append((factorial[-1] * i) % MOD)
inverse_from.append((-inverse_from[MOD % i] * (MOD // i)) % MOD)
inverse.append((inverse[-1] * inverse_from[-1]) % 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
ans = 0
# Hについて
for d in range(1, H):
ans += d * (H - d) * pow(W, 2, MOD) * nCr(H * W - 2, K - 2) % MOD
ans %= MOD
# Wについて
for d in range(1, W):
ans += d * (W - d) * pow(H, 2, MOD) * nCr(H * W - 2, K - 2) % MOD
ans %= MOD
print((ans % MOD))
| p03039 |
H, W, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
factorial = [1, 1] # 元テーブル
inverse = [1, 1] # 逆元テーブル
inverse_from = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, H * W + 1):
factorial.append((factorial[-1] * i) % MOD)
inverse_from.append((-inverse_from[MOD % i] * (MOD // i)) % MOD)
inverse.append((inverse[-1] * inverse_from[-1]) % 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
ans = 0
# Hについて
for d in range(1, H):
ans += d * (H - d) * pow(W, 2, MOD) * nCr(H * W - 2, K - 2) % MOD
ans %= MOD
# Wについて
for d in range(1, W):
ans += d * (W - d) * pow(H, 2, MOD) * nCr(H * W - 2, K - 2) % MOD
ans %= MOD
print((ans % MOD))
| H, W, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
factorial = [1, 1]
inverse = [1, 1]
invere_base = [0, 1]
for i in range(2, H * W + 2):
factorial.append((factorial[-1] * i) % MOD)
invere_base.append((-invere_base[MOD % i] * (MOD // i)) % MOD)
inverse.append((inverse[-1] * invere_base[-1]) % MOD)
def nCr(n, r):
if not 0 <= r <= n:
return 0
return factorial[n] * inverse[r] * inverse[n - r] % MOD
ans = 0
for dh in range(1, H):
ans += dh * (H - dh) * pow(W, 2, MOD) * nCr(H * W - 2, K - 2) % MOD
ans %= MOD
for dw in range(1, W):
ans += dw * (W - dw) * pow(H, 2, MOD) * nCr(H * W - 2, K - 2) % MOD
ans %= MOD
print(ans)
| p03039 |
n, m, k = list(map(int, input().split()))
MOD = 1000000007
def pow_mod(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
mod_inv = lambda x: pow_mod(x, MOD - 2)
a = 0
for i in range(1, n):
a += (i * (n - i)) % MOD
a %= MOD
a *= (m * m) % MOD
a %= MOD
b = 0
for i in range(1, m):
b += (i * (m - i)) % MOD
b %= MOD
b *= (n * n) % MOD
b %= MOD
w = (m * n - 2) % MOD
wCx = {0: 1}
for i in range(1, k+1):
wCx[i] = wCx[i - 1]
wCx[i] *= (w - i + 1) % MOD
wCx[i] %= MOD
wCx[i] *= mod_inv(i)
wCx[i] %= MOD
ans = ((a + b) % MOD)
ans *= wCx[k-2]
ans %= MOD
print(ans) | n, m, k = list(map(int, input().split()))
MOD = 1000000007
def pow_mod(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
mod_inv = lambda x: pow_mod(x, MOD - 2)
a = 0
for i in range(1, n):
a += (i * (n - i)) % MOD
a %= MOD
a *= (m * m) % MOD
a %= MOD
b = 0
for i in range(1, m):
b += (i * (m - i)) % MOD
b %= MOD
b *= (n * n) % MOD
b %= MOD
w = (m * n - 2) % MOD
u = 1
v = 1
for i in range(1, k-1):
u *= (w - i + 1)
u %= MOD
v *= i
v %= MOD
ans = ((a + b) % MOD)
ans *= u
ans %= MOD
ans *= mod_inv(v)
ans %= MOD
print(ans) | p03039 |
MOD=10**9+7
UPPERLIMIT=3*10**5
MODMUL=[1, 1]+[0]*(UPPERLIMIT-1)
for i in range(2, UPPERLIMIT+1):
MODMUL[i]=MODMUL[i-1]*i%MOD
MODDIV=[1]*UPPERLIMIT+[pow(MODMUL[-1], MOD-2, MOD)]
for i in range(UPPERLIMIT, 0, -1):
MODDIV[i-1]=MODDIV[i]*i%MOD
def MODCOMB(n, r):
if n<r or n<1:
return 0
else:
return (((MODMUL[n]*MODDIV[r])%MOD)*MODDIV[n-r])%MOD
N, M, K=list(map(int, input().split()))
ans=0
k=MODCOMB(N*M-2, K-2)
for x1 in range(N-1):
for x2 in range(x1+1, N):
ans=(ans+abs(x1-x2)*M*M*k)%MOD
for y1 in range(M-1):
for y2 in range(y1+1, M):
ans=(ans+abs(y1-y2)*N*N*k)%MOD
print(ans) | MOD=10**9+7
UPPERLIMIT=3*10**5
MODMUL=[1, 1]+[0]*(UPPERLIMIT-1)
for i in range(2, UPPERLIMIT+1):
MODMUL[i]=MODMUL[i-1]*i%MOD
MODDIV=[1]*UPPERLIMIT+[pow(MODMUL[-1], MOD-2, MOD)]
for i in range(UPPERLIMIT, 0, -1):
MODDIV[i-1]=MODDIV[i]*i%MOD
def MODCOMB(n, r):
if n<r or n<1:
return 0
else:
return (((MODMUL[n]*MODDIV[r])%MOD)*MODDIV[n-r])%MOD
N, M, K=list(map(int, input().split()))
ans=0
k=MODCOMB(N*M-2, K-2)
for sa in range(1, N):
ans=(ans+sa*(N-sa)*M*M*k)%MOD
for sa in range(1, M):
ans=(ans+sa*(M-sa)*N*N*k)%MOD
print(ans) | p03039 |
import math
N, M, K = list(map(int, input().split()))
sosu = 10 ** 9 + 7
def P(n, r):
return math.factorial(n)//math.factorial(n-r)
def C(n, r):
return P(n, r)//math.factorial(r)
dis = M * M * N * N * (N+1) // 2 % sosu
dis = dis - M * M * N * (N+1) * ( 2* N + 1) // 6 % sosu
dis = dis + N * N * M * M * (M+1) //2 % sosu
dis = dis - N * N * M * (M+1) * (2*M + 1) // 6 % sosu
if K >= 3:
dis = dis * C(N*M-2, K-2) % sosu
if dis >= 0:
print(dis)
else:
print((dis + sosu)) | import math
N, M, K = list(map(int, input().split()))
sosu = 10 ** 9 + 7
def P(n, r):
return math.factorial(n)//math.factorial(n-r)
def C(n, r):
return P(n, r)//math.factorial(r)
dis = M * M * N * N * (N+1) // 2 % sosu
dis = dis - M * M * N * (N+1) * ( 2* N + 1) // 6 % sosu
dis = dis + N * N * M * M * (M+1) //2 % sosu
dis = dis - N * N * M * (M+1) * (2*M + 1) // 6 % sosu
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 = sosu #出力の制限
N = N * M
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
if K >= 3:
dis = dis * cmb(N-2, K-2, mod) % sosu
if dis >= 0:
print(dis)
else:
print((dis + sosu)) | p03039 |
import math
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
n, m, k = list(map(int, input().split()))
cmb = combinations_count(n * m - 2, k - 2)
ans = 0
for i in range(1, n):
ans += i * cmb * m * m * (n - i)
ans %= 10 ** 9 + 7
for i in range(m):
ans += i * cmb * n * n * (m - i)
ans %= 10 ** 9 + 7
print((ans % (10 ** 9 + 7))) | import math
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
n, m, k = list(map(int, input().split()))
cmb = combinations_count(n * m - 2, k - 2)
cmb %= 10 ** 9 + 7
ans = 0
for i in range(1, n):
ans += i * cmb * m * m * (n - i)
ans %= 10 ** 9 + 7
for i in range(1, m):
ans += i * cmb * n * n * (m - i)
ans %= 10 ** 9 + 7
print((ans % (10 ** 9 + 7))) | p03039 |
LARGE = 10**9 + 7
def p_inv(k, p):
return pow(k, p-2, p)
def nck_mod(n, k, m):
res = 1
for i in range(n, n-k, -1):
res = res * i % m
for i in range(1, k+1):
res = res * p_inv(i, m) % m
return res
def solve(n, m, k):
res_1 = 0
for i in range(n):
for j in range(n):
res_1 += abs(i - j)
res_2 = 0
for i in range(m):
for j in range(m):
res_2 += abs(i - j)
res = (res_1 * m * m + res_2 * n * n) % LARGE
weight = nck_mod(n * m - 1, k - 1, LARGE) * p_inv(n * m - 1, LARGE) * (k - 1) * p_inv(2, LARGE) % LARGE
return res * weight % LARGE
if __name__ == "__main__":
N, M, K = list(map(int, input().split()))
print((solve(N, M, K)))
# print(solve(2, 2, 2))
# print(solve(4, 5, 4))
# print(solve(100, 100, 5000))
| LARGE = 10**9 + 7
def p_inv(k, p):
return pow(k, p-2, p)
def nck_mod(n, k, m):
res = 1
for i in range(n, n-k, -1):
res = res * i % m
for i in range(1, k+1):
res = res * p_inv(i, m) % m
return res
def solve(n, m, k):
res_1 = 0
r = n * (n - 1) // 2
res_1 += r
for i in range(1, n):
r += i
r -= n - i
res_1 += r
res_2 = 0
r = m * (m - 1) // 2
res_2 += r
for i in range(1, m):
r += i
r -= m - i
res_2 += r
res = (res_1 * m * m + res_2 * n * n) % LARGE
weight = nck_mod(n * m - 1, k - 1, LARGE) * p_inv(n * m - 1, LARGE) * (k - 1) * p_inv(2, LARGE) % LARGE
return res * weight % LARGE
if __name__ == "__main__":
N, M, K = list(map(int, input().split()))
print((solve(N, M, K)))
# print(solve(2, 2, 2))
# print(solve(4, 5, 4))
# print(solve(100, 100, 5000))
| p03039 |
from math import factorial as f
N, M, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
def combi(n, r):
return f(n) // f(n - r) // f(r) % mod
res = 0
c = combi(N * M - 2, K - 2)
cn = c * M ** 2 % mod
cm = c * N ** 2 % mod
temp = ((N - 1 + 1) * (N - 1) // 2) * cn % mod
for i in range(1, N):
res += temp % mod
res %= mod
temp -= (N - i) * cn % mod
#print(res)
temp = ((M - 1 + 1) * (M - 1) // 2) * cm % mod
for i in range(1, M):
res += temp % mod
res %= mod
temp -= (M - i) * cm % mod
print((res % mod)) | from math import factorial as f
N, M, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
def combi(n, r):
return f(n) // (f(n - r) * f(r)) % mod
res = 0
c = combi(N * M - 2, K - 2)
for i in range(1, N):
res += ((N - i + 1) * (N - i) // 2) * c * M * M % mod
res %= mod
for i in range(1, M):
res += ((M - i + 1) * (M - i) // 2) * c * N * N % mod
res %= mod
print((res % mod))
| p03039 |
from math import factorial as f
N, M, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
def combi(n, r):
return f(n) // (f(n - r) * f(r)) % mod
res = 0
c = combi(N * M - 2, K - 2)
for i in range(1, N):
res += ((N - i + 1) * (N - i) // 2) * c * M * M % mod
res %= mod
for i in range(1, M):
res += ((M - i + 1) * (M - i) // 2) * c * N * N % mod
res %= mod
print((res % mod))
| import sys
input = sys.stdin.readline
N, M, K = list(map(int, input().split()))
mod = 10 ** 9 + 7
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 * M, mod)
t = f.combi(N * M - 2, K - 2)
res = 0
for d in range(1, M):
x = N ** 2 % mod * (M - d) % mod
res += x * d % mod
res %= mod
#print(x)
for d in range(1, N):
y = M ** 2 % mod * (N - d) % mod
res += y * d % mod
res %= mod
#print(res, t)
print((res * t % mod)) | p03039 |
import math
N,M,k = list(map(int,input().split()))
p = N*M
PP = 1
for i in range(p-k+1,p-1):
PP *= i
P = PP//math.factorial(k-2)
Q = N*(N-1)*(N+1)*M*M//6
R = M*(M-1)*(M+1)*N*N//6
print(((P*(Q+R))%(10**9+7))) | import math
N,M,k = list(map(int,input().split()))
p = N*M
def cmb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
P = cmb(p-2,k-2)
Q = N*(N-1)*(N+1)*M*M//6
R = M*(M-1)*(M+1)*N*N//6
print(((P*(Q+R))%(10**9+7))) | p03039 |
from collections import deque
from heapq import heappush,heappop
import re
def int_raw():
return int(eval(input()))
def ss_raw():
return input().split()
def ints_raw():
return list(map(int, ss_raw()))
INF = 1<<29
DIV = 10**9+7
def mod_inv(a,mod = DIV):
return pow(a,mod-2,mod)
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 * pow(i, mod-2, mod) % mod
return ret
def main():
N, M,K = ints_raw()
ans = 0
for d in range(1,N):
ans =(ans+d*(N-d)*M*M)%DIV
for d in range(1,M):
ans =(ans+d*(M-d)*N*N)%DIV
return (ans*ncr(N*M-2,K-2))%DIV
print((main()))
| from collections import deque
from heapq import heappush,heappop
import re
def int_raw():
return int(eval(input()))
def ss_raw():
return input().split()
def ints_raw():
return list(map(int, ss_raw()))
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 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, M,K = ints_raw()
ans = 0
for d in range(1,N):
ans =(ans+d*(N-d)*M*M)%DIV
for d in range(1,M):
ans =(ans+d*(M-d)*N*N)%DIV
return (ans*ncr(N*M-2,K-2))%DIV
if __name__ =="__main__":
print((main()))
| p03039 |
n, m, k = list(map(int, input().split()))
# 二項係数を 10^9+7 で割った余りを求める
# https://qiita.com/drken/items/3b4fdf0a78e7a138cd9a#5-%E4%BA%8C%E9%A0%85%E4%BF%82%E6%95%B0-ncr
# https://qiita.com/Yaruki00/items/fd1fc269ff7fe40d09a6
# https://www.hamayanhamayan.com/entry/2018/06/06/210256
mod = 10**9 + 7
# x ** a をmodで割った余りを、O(log(a))時間で求める。
def power(x, a):
if a == 0:
return 1
elif a == 1:
return x
elif a % 2 == 0:
return power(x, a//2) **2 % mod
else:
return power(x, a//2) **2 * x % mod
# xの逆元を求める。フェルマーの小定理より、 x の逆元は x ^ (mod - 2) に等しい。計算時間はO(log(mod))程度。
# https://qiita.com/Yaruki00/items/fd1fc269ff7fe40d09a6
def modinv(x):
return power(x, mod-2)
# 二項係数の左側の数字の最大値を max_len とする。nとかだと他の変数と被りそうなので。
# factori_table = [1, 1, 2, 6, 24, 120, ...] 要は factori_table[n] = n!
# 計算時間はO(max_len * log(mod))
max_len = n * m #適宜変更する
factori_table = [1] * (max_len + 1)
factori_inv_table = [1] * (max_len + 1)
for i in range(1, max_len + 1):
factori_table[i] = factori_table[i-1] * (i) % mod
factori_inv_table[i] = modinv(factori_table[i])
def binomial_coefficients(n, k):
# n! / (k! * (n-k)! )
return factori_table[n] * factori_inv_table[k] * factori_inv_table[n-k]
ans_1 = 0
for i in range(n):
ans_1 += i * m**2 * (n-i)
for i in range(m):
ans_1 += i * n**2 * (m-i)
print((binomial_coefficients(n*m-2, k-2) * ans_1 % mod))
| n, m, k = list(map(int, input().split()))
# 二項係数を 10^9+7 で割った余りを求める
# https://qiita.com/drken/items/3b4fdf0a78e7a138cd9a#5-%E4%BA%8C%E9%A0%85%E4%BF%82%E6%95%B0-ncr
# https://qiita.com/Yaruki00/items/fd1fc269ff7fe40d09a6
# https://www.hamayanhamayan.com/entry/2018/06/06/210256
mod = 10**9 + 7
# x ** a をmodで割った余りを、O(log(a))時間で求める。
def power(x, a):
if a == 0:
return 1
elif a == 1:
return x
elif a % 2 == 0:
return power(x, a//2) **2 % mod
else:
return power(x, a//2) **2 * x % mod
# xの逆元を求める。フェルマーの小定理より、 x の逆元は x ^ (mod - 2) に等しい。計算時間はO(log(mod))程度。
# https://qiita.com/Yaruki00/items/fd1fc269ff7fe40d09a6
def modinv(x):
return power(x, mod-2)
# 二項係数の左側の数字の最大値を max_len とする。nとかだと他の変数と被りそうなので。
# factori_table = [1, 1, 2, 6, 24, 120, ...] 要は factori_table[n] = n!
# 計算時間はO(max_len * log(mod))
max_len = n * m #適宜変更する
factori_table = [1] * (max_len + 1)
factori_inv_table = [1] * (max_len + 1)
for i in range(1, max_len + 1):
factori_table[i] = factori_table[i-1] * (i) % mod
# factori_inv_table[i] = modinv(factori_table[i])
# ↑が遅いので、使うところだけ逆元を計算する↓
for i in [k-2, n*m-k]:
factori_inv_table[i] = modinv(factori_table[i])
def binomial_coefficients(n, k):
# n! / (k! * (n-k)! )
return factori_table[n] * factori_inv_table[k] * factori_inv_table[n-k]
ans_1 = 0
for i in range(n):
ans_1 += i * m**2 * (n-i) % mod
for i in range(m):
ans_1 += i * n**2 * (m-i) % mod
print((binomial_coefficients(n*m-2, k-2) * ans_1 % mod))
| p03039 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.