input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
def main():
A = int(eval(input()))
B = int(eval(input()))
if A > B:
print("GREATER")
elif A < B:
print("LESS")
else:
print("EQUAL")
if __name__ == "__main__":
main() | a=int(eval(input()));b=int(eval(input()))
print((["GREATER","EQUAL","LESS"][(a<b)+(a<=b)])) | p03738 |
import math
A = int(eval(input()))
B = int(eval(input()))
A = math.log10(A)
B = math.log10(B)
if A > B:
print('GREATER')
elif A < B:
print('LESS')
else:
print('EQUAL')
| import math
A = int(eval(input()))
B = int(eval(input()))
#A = math.log10(A)
#B = math.log10(B)
if A > B:
print('GREATER')
elif A < B:
print('LESS')
else:
print('EQUAL')
| p03738 |
#-*-coding:utf-8-*-
import sys
input=sys.stdin.readline
def main():
a = int(eval(input()))
b = int(eval(input()))
if a == b:
print("EQUAL")
elif a > b:
print("GREATER")
else:
print("LESS")
if __name__=="__main__":
main() | #-*-coding:utf-8-*-
import sys
input=sys.stdin.readline
def main():
a = int(eval(input()))
b = int(eval(input()))
if a > b :
print("GREATER")
elif a < b :
print("LESS")
elif a == b :
print("EQUAL")
if __name__=="__main__":
main() | p03738 |
import math
a = int(eval(input()))
b = int(eval(input()))
a = math.log10(a)
b = math.log10(b)
if a > b :
print("GREATER")
elif a == b :
print("EQUAL")
else :
print("LESS")
| import math
a = int(eval(input()))
b = int(eval(input()))
if a > b :
print("GREATER")
elif a == b :
print("EQUAL")
else :
print("LESS")
| p03738 |
a=int(eval(input()))-int(eval(input()));print((a>0 and'GREATER'or a<0 and'LESS'or'EQUAL')) | a=eval(input());b=eval(input());print(a<b and'LESS'or a>b and'GREATER'or'EQUAL') | p03738 |
a=int(eval(input()))-int(eval(input()));print((a>0and'GREATER'or a<0and'LESS'or'EQUAL')) | a=int(eval(input()))-int(eval(input()));print((a>0and'GREATER'or a and'LESS'or'EQUAL')) | p03738 |
a=int(eval(input()))
b=int(eval(input()))
print(("GREATER" if a>b else "LESS" if a<b else "EQUAL")) | A = int(eval(input()))
B = int(eval(input()))
print(("GREATER" if A > B else "LESS" if A < B else "EQUAL")) | p03738 |
import sys
import os
MOD = 10 ** 9 + 7
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
A = int(sys.stdin.buffer.readline().rstrip())
B = int(sys.stdin.buffer.readline().rstrip())
print(('GREATER' if A > B else 'LESS' if A < B else 'EQUAL'))
if __name__ == '__main__':
main()
| import sys
import os
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
A = ii()
B = ii()
print(('GREATER' if A > B else 'LESS' if A < B else 'EQUAL'))
if __name__ == '__main__':
main()
| p03738 |
A = int(eval(input()))
B = int(eval(input()))
if A>B:
print("GREATER")
elif A<B:
print("LESS")
else:
print("EQUAL") | A = input().strip()
B = input().strip()
if len(A)>len(B):
print("GREATER")
elif len(A)<len(B):
print("LESS")
else:
if A<B:
print("LESS")
elif A>B:
print("GREATER")
else:
print("EQUAL") | p03738 |
a=input()
b=input()
if len(a)<len(b):
print("LESS")
elif len(a)>len(b):
print("GREATER")
else:
p=0
flag=True
while flag:
if a[p]<b[p]:
print("LESS")
flag=False
elif a[p]>b[p]:
print("GREATER")
flag=False
else:
pass
| a=int(input())
b=int(input())
if a<b:
print("LESS")
elif a>b:
print("GREATER")
else:
print("EQUAL") | p03738 |
#abc59 b
a=int(eval(input()))
b=int(eval(input()))
if a>b:
print("GREATER")
elif a<b:
print("LESS")
else:
print("EQUAL") | a=int(eval(input()))
b=int(eval(input()))
if a==b:
print("EQUAL")
elif a>b:
print("GREATER")
else:
print("LESS") | p03738 |
A,B = int(eval(input())),int(eval(input()))
if A > B:
print('GREATER')
elif A < B:
print('LESS')
else:
print('EQUAL')
| A = int(eval(input()))
B = int(eval(input()))
if A>B:
print('GREATER')
elif A==B:
print('EQUAL')
else:
print('LESS') | p03738 |
A=int(eval(input()))
B=int(eval(input()))
if A>B:
print('GREATER')
elif A<B:
print('LESS')
else:
print('EQUAL') | A=int(eval(input()))
B=int(eval(input()))
print(('GREATER'if A>B else'LESS'if A<B else'EQUAL')) | p03738 |
a=int(eval(input()))
b=int(eval(input()))
print(("GREATER" if a>b else "LESS" if b>a else "EQUAL"))
| a=int(eval(input()))
b=int(eval(input()))
if a>b:
print("GREATER")
elif b>a:
print("LESS")
else:
print("EQUAL") | p03738 |
# seishin.py
N = int(eval(input()))
*P, = list(map(int, input().split()))
MOD = 10**9 + 7
G = [[] for i in range(N+1)]
for i, p in enumerate(P):
G[p].append(i+1)
Q = [None]*(N+1)
for i in range(N, -1, -1):
# 子ノードのqueを集める
R = None
for j in G[i]:
S = Q[j]
if not R:
R = S
continue
# |R| > |S|
if len(R) < len(S):
R, S = S, R
# queの小さい方から大きい方へマージする処理
for s, r in zip(S, R):
a0, a1, a2, c0 = s
b0, b1, b2, c1 = r
r[:] = a0*b0 % MOD, (a0*b1 + a1*b0) % MOD, (a2*(b0 + b1 + b2) + (a0 + a1)*b2 + a1*b1) % MOD, c0+c1
if R:
# a0 <- a2
for e in R:
e[0] += e[2]
e[2] = 0
Q[i] = [[1, 1, 0, 1]] + R
else:
Q[i] = [[1, 1, 0, 1]]
ans = 0
for a0, a1, a2, c in Q[0]:
ans += pow(2, N+1-c, MOD) * a1 % MOD
print((ans % MOD))
| # seishin.py
import sys
sys.setrecursionlimit(10**6)
N = int(eval(input()))
*P, = list(map(int, input().split()))
MOD = 10**9 + 7
from itertools import tee
G = [[] for i in range(N+1)]
for i, p in enumerate(P):
G[p].append(i+1)
Q = [None]*(N+1)
E = [1, 1, 0, 1]
for i in range(N, -1, -1):
def gen(i):
*I, = list(map(Q.__getitem__, G[i]))
r = E
while r:
a,b,c,d=r
yield (a+c,b,0,d)
r = None
for it in I:
s = next(it, None)
if s:
if r:
a0, a1, a2, c0 = s
b0, b1, b2, c1 = r
r = a0*b0 % MOD, (a0*b1 + a1*b0) % MOD, ((a0 + a1)*b2 + a1*b1) % MOD, c0+c1
else:
r = s
Q[i] = gen(i)
ans = 0
for a0, a1, a2, c in Q[0]:
ans += pow(2, N+1-c, MOD) * a1 % MOD
print((ans % MOD)) | p03499 |
# seishin.py
from collections import deque
N = int(eval(input()))
*P, = list(map(int, input().split()))
MOD = 10**9 + 7
G = [[] for i in range(N+1)]
U = [0]*(N+1)
C = [0]*(N+1)
for i, p in enumerate(P):
G[p].append(i+1)
U[i+1] = u = U[p]+1
C[u] += 1
Q = [None]*(N+1)
PP = {}
def pp(k):
if k not in PP:
PP[k] = p = pow(2, k, MOD)
return p
return PP[k]
L = [0]*(N+1)
sz = L.__getitem__
for i in range(N, -1, -1):
g = G[i]
if not g:
continue
# 子ノードのdequeを集める
g.sort(key=sz, reverse=1)
k = len(g)
e = [pp(k) - k, k, 0]
g0 = g[0]
L[i] = L[g0] + 1
if L[g0] == 0:
Q[i] = deque([e])
continue
Q[i] = R = Q[g0]
for j in g[1:]:
S = Q[j]
if not S:
break
# dequeの小さい方から大きい方へマージする処理
for (a0, a1, a2), r in zip(S, R):
b0, b1, b2 = r
r[0] = a0*b0 % MOD
r[1] = (a0*b1 + a1*b0) % MOD
r[2] = ((a0+a1)*b2 + a1*b1) % MOD
# a0 <- a2
for r in R:
r[0] += r[2]
r[2] = 0
R.appendleft(e)
print(((pp(N) + sum(pp(N+1-c) * a1 % MOD for (a0, a1, a2), c in zip(Q[0], C[1:]))) % MOD)) | # seishin.py
from collections import deque
N = int(eval(input()))
*P, = list(map(int, input().split()))
MOD = 10**9 + 7
G = [[] for i in range(N+1)]
U = [0]*(N+1)
C = [0]*(N+1)
for i, p in enumerate(P):
G[p].append(i+1)
U[i+1] = u = U[p]+1
C[u] += 1
Q = [None]*(N+1)
PP = {}
def pp(k):
if k not in PP:
PP[k] = p = pow(2, k, MOD)
return p
return PP[k]
L = [0]*(N+1)
ept = []
sz = L.__getitem__
for i in range(N, -1, -1):
g = G[i]
if not g:
continue
# 子ノードのdequeを集める
g.sort(key=sz, reverse=1)
k = len(g)
e = [pp(k) - k, k, 0]
g0 = g[0]
L[i] = L[g0] + 1
if L[g0] == 0:
Q[i] = deque([e])
continue
Q[i] = R = Q[g0]
if k > 1:
# a0 <- a2
for s, r in zip(Q[g[1]] or ept, R):
r[0] += r[2]; r[2] = 0
for j in g[1:]:
S = Q[j]
if not S:
break
# dequeの小さい方から大きい方へマージする処理
for (a0, a1, a2), r in zip(S, R):
b0, b1, b2 = r; a0 += a2
r[0] = a0*b0 % MOD
r[1] = (a0*b1 + a1*b0) % MOD
r[2] = ((a0+a1)*b2 + a1*b1) % MOD
R.appendleft(e)
print(((pp(N) + sum(pp(N+1-c) * a1 % MOD for (a0, a1, a2), c in zip(Q[0], C[1:]))) % MOD))
| p03499 |
mod = 1000000007
def get_pow():
cache = {}
def func(x):
if x not in cache:
cache[x] = pow(2, x, mod)
return cache[x]
return func
n = int(eval(input()))
parents = list(map(int, input().split()))
children = [set() for _ in range(n + 1)]
for c, p in enumerate(parents):
children[p].add(c + 1)
levels = [{0}]
while True:
level = set()
for p in levels[-1]:
level.update(children[p])
if not level:
break
levels.append(level)
levels.reverse()
level_node_count = []
balls = [None] * (n + 1)
for i, level in enumerate(levels):
level_node_count.append(len(level))
for node in level:
if children[node]:
balls_from_children = [balls[c] for c in children[node]]
balls_from_children.sort(key=len)
for bs1, bs2 in zip(balls_from_children, balls_from_children[1:]):
for b1, b2 in zip(bs1, bs2):
b2[2] = (b1[1] + b1[2]) * b2[1] + b1[2] * b2[0]
b2[1] = b1[0] * b2[1] + b1[1] * b2[0]
b2[0] *= b1[0]
for b in balls_from_children[-1]:
b[0] += b[2]
b[2] = 0
balls[node] = [[1, 1, 0]] + balls_from_children[-1]
else:
balls[node] = [[1, 1, 0]]
level_node_count.reverse()
pow2 = get_pow()
print((sum(b[1] * pow2(n - l + 1) for l, b in zip(level_node_count, balls[0])) % mod))
| def get_pow():
cache = {}
def func(x):
if x not in cache:
cache[x] = pow(2, x, mod)
return cache[x]
return func
mod = 1000000007
n = int(eval(input()))
parents = list(map(int, input().split()))
children = [set() for _ in range(n + 1)]
for c, p in enumerate(parents):
children[p].add(c + 1)
levels = [{0}]
while True:
level = set()
for p in levels[-1]:
level.update(children[p])
if not level:
break
levels.append(level)
levels.reverse()
level_node_count = []
balls = [None] * (n + 1)
for i, level in enumerate(levels):
level_node_count.append(len(level))
for node in level:
balls[node] = [[1, 1, 0]]
if children[node]:
balls_from_children = [balls[c] for c in children[node]]
balls_from_children.sort(key=len)
for bs1, bs2 in zip(balls_from_children, balls_from_children[1:]):
for (b10, b11, b12), b2 in zip(bs1, bs2):
b2[2] = ((b11 + b12) * b2[1] + b12 * b2[0]) % mod
b2[1] = (b10 * b2[1] + b11 * b2[0]) % mod
b2[0] *= b10
for b in balls_from_children[-1]:
b[0] += b[2]
b[2] = 0
balls[node].extend(balls_from_children[-1])
level_node_count.reverse()
pow2 = get_pow()
print((sum(b[1] * pow2(n - l + 1) % mod for l, b in zip(level_node_count, balls[0])) % mod))
| p03499 |
import sys
from collections import *
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def main():
def dfs(u=0):
def merge(dpu, dpv):
vn = len(dpv)
for d in range(-1, -1 - vn, -1):
u0, u1, u2 = dpu[d]
v0, v1, v2 = dpv[d]
n0 = (u0 * v0) % md
n1 = (u0 * v1 + u1 * v0) % md
n2 = (u2 * (v0 + v1 + v2) + v2 * (u0 + u1) + u1 * v1) % md
dpu[d] = (n0, n1, n2)
dpu = deque()
start=(inv2, inv2, 0)
# 葉の場合
if len(to[u]) == 0:
dpu.append(start)
return dpu
# すべての子をマージ
for v in to[u]:
dpv = dfs(v)
#深さが2段以上あったらu2をu0に
if len(dpv) > 1:
for d, (u0, u1, u2) in enumerate(dpv):
dpv[d] = (u0 + u2, u1, 0)
if not dpu:
dpu = dpv
else:
if len(dpu) < len(dpv): dpu, dpv = dpv, dpu
merge(dpu, dpv)
dpu.append((inv2, inv2, 0))
return dpu
md = 10 ** 9 + 7
# 1/2のmod
inv2 = pow(2, md - 2, md)
to = defaultdict(list)
n = int(input())
pp = list(map(int, input().split()))
for i, p in enumerate(pp, 1):
to[p].append(i)
# print(to)
dp0 = dfs()
# print(dp0)
ans = sum(u1 for _, u1, _ in dp0)
print((ans * pow(2, n + 1, md)) % md)
main()
| import sys
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def main():
def dfs(u=0):
def merge(dpu, dpv):
vn = len(dpv)
for d in range(-1, -1 - vn, -1):
u0, u1, u2 = dpu[d]
v0, v1, v2 = dpv[d]
n0 = (u0 * v0) % md
n1 = (u0 * v1 + u1 * v0) % md
n2 = (u2 * (v0 + v1 + v2) + v2 * (u0 + u1) + u1 * v1) % md
dpu[d] = (n0, n1, n2)
# 葉の場合
if len(to[u]) == 0:
return [(inv2, inv2, 0)]
# すべての子をマージ
dpu = []
mxlen=0
for v in to[u]:
dpv = dfs(v)
#深さが2段以上あったらu2をu0に
if not dpu:
dpu = dpv
else:
if len(dpu) < len(dpv): dpu, dpv = dpv, dpu
mxlen=max(mxlen,len(dpv))
merge(dpu, dpv)
for d in range(-1,-1-mxlen,-1):
u0,u1,u2=dpu[d]
dpu[d] = (u0 + u2, u1, 0)
dpu.append((inv2, inv2, 0))
return dpu
md = 10 ** 9 + 7
# 1/2のmod
inv2 = pow(2, md - 2, md)
n = int(input())
to = [[] for _ in range(n+1)]
pp = list(map(int, input().split()))
for i, p in enumerate(pp, 1):
to[p].append(i)
# print(to)
dp0 = dfs()
# print(dp0)
ans = sum(u1 for _, u1, _ in dp0)
print((ans * pow(2, n + 1, md)) % md)
main()
| p03499 |
"""
https://atcoder.jp/contests/arc086/tasks/arc086_c
対消滅する可能性があるのは同じ深さの点に置かれたビー玉だけ
→1つも残らない or 1つだけ残るである
すなわち、ある深さに関して、そのうち1つ残るのがいくつあるかを数えればよい
1つだけ置く場合→絶対のこる
2つ置く場合→絶対消える
3つ置く場合→3つのLCAが等しくなければ残る
木dpみたいにする？
dp[0] = 一つも含んでいない場合の通り数
dp[1] = 1つ含んでいる場合の通り数
dp[0] = すべての場合 - dp[1]
dp[1] = 1つだけ1を持っている場合
で、子から親に伝播させていく…？
マージテクで計算量削減か？
3sだからそうっぽいな…
3つ以上のマージ書くのだるすぎん？
またはマージの順番をどっかにメモっておく
maxd-d = indexでやる
最長のやつにマージする
dp[maxd-d][1] = 1つだけ元深さdが残っている場合の数
c = 子の数
計算量は？
サイズは高々1しか増えないので可能っぽい
2倍処理がまずい
"""
import sys
mod = 10**9 + 7
sys.setrecursionlimit(200000)
from collections import deque
def NC_Dij(lis,start):
ret = [float("inf")] * len(lis)
ret[start] = 0
q = deque([start])
plis = [i for i in range(len(lis))]
while len(q) > 0:
now = q.popleft()
for nex in lis[now]:
if ret[nex] > ret[now] + 1:
ret[nex] = ret[now] + 1
plis[nex] = now
q.append(nex)
return ret,plis
def inverse(a): #aのmodを法にした逆元を返す
return pow(a,mod-2,mod)
def dfs(v):
if len(lis[v]) == 0:
ret = [ 0 for i in range(maxd-dlis[v]+1) ]
ret[maxd-dlis[v]] = 1
return 1,ret,0
else:
#ここがむずすぎる
#まずcとretを受け取るか
csum = 0 #cの合計
len_c_ret = []
for nex in lis[v]:
nc,nret,mmm = dfs(nex)
#print (nex,nc,nret,mmm)
len_c_ret.append( [len(nret) , nc , nret , mmm ] )
csum += nc
len_c_ret.sort()
#1つしかない場合マージしない
if len(len_c_ret) == 1:
len_c_ret[0][2].append(pow(2,len_c_ret[0][1],mod) * inverse(pow(2,len_c_ret[0][3] + 1,mod)))
return len_c_ret[0][1]+1 , len_c_ret[0][2] , len_c_ret[0][3] + 1
#2つ以上の場合最大のやつにマージする
for i in range(len(len_c_ret)):
xxxx = pow(2,len_c_ret[i][3],mod)
if xxxx > 1:
for j in range(len(len_c_ret[i][2])):
len_c_ret[i][2][j] *= xxxx
len_c_ret[i][2][j] %= mod
for revd in range(len(len_c_ret[-1][2])):
zmul = 1
otmp = csum
for i in range(len(len_c_ret)-1,-1,-1):
if revd < len(len_c_ret[i][2]):
zmul *= ( pow(2,len_c_ret[i][1],mod) - len_c_ret[i][2][revd] )
otmp -= len_c_ret[i][1]
else:
break
zmul *= pow(2,otmp,mod)
zmul %= mod
nsum = 0
for i in range(len(len_c_ret)-1,-1,-1):
if revd < len(len_c_ret[i][2]):
nsum += zmul * inverse(pow(2,len_c_ret[i][1],mod)-len_c_ret[i][2][revd])*len_c_ret[i][2][revd]
nsum %= mod
else:
break
len_c_ret[-1][2][revd] = nsum * 2 % mod
len_c_ret[-1][2].append(pow(2,csum,mod))
return csum+1 , len_c_ret[-1][2] , 0
N = int(eval(input()))
p = list(map(int,input().split()))
lis = [ [] for i in range(N+1) ]
for i in range(N):
#lis[i+1].append(p[i])
lis[p[i]].append(i+1)
dlis,plis = NC_Dij(lis,0)
maxd = max(dlis)
cc,ans,tmps = dfs(0)
#print (ans)
print((sum(ans) * pow(2,tmps,mod) % mod))
|
"""
https://atcoder.jp/contests/arc086/tasks/arc086_c
対消滅する可能性があるのは同じ深さの点に置かれたビー玉だけ
→1つも残らない or 1つだけ残るである
すなわち、ある深さに関して、そのうち1つ残るのがいくつあるかを数えればよい
1つだけ置く場合→絶対のこる
2つ置く場合→絶対消える
3つ置く場合→3つのLCAが等しくなければ残る
木dpみたいにする？
dp[0] = 一つも含んでいない場合の通り数
dp[1] = 1つ含んでいる場合の通り数
dp[0] = すべての場合 - dp[1]
dp[1] = 1つだけ1を持っている場合
で、子から親に伝播させていく…？
マージテクで計算量削減か？
3sだからそうっぽいな…
3つ以上のマージ書くのだるすぎん？
またはマージの順番をどっかにメモっておく
maxd-d = indexでやる
最長のやつにマージする
dp[maxd-d][1] = 1つだけ元深さdが残っている場合の数
c = 子の数
計算量は？
サイズは高々1しか増えないので可能っぽい
2倍処理がまずい
もっと簡潔に？
単一のdだけで考えよう
2倍処理なんてしない
最後に各dに関してかければいい
→するとマージの際に2番目の大きさだけでなんとかなる
必要のないマージをしない
両方に関係ないdは操作しない
むしろばらつきは深い部分にだけ存在するか
浅い部分は共通。よって-xで管理すればいいか
"""
import sys
mod = 10**9 + 7
sys.setrecursionlimit(200000)
from collections import deque
def NC_Dij(lis,start):
ret = [float("inf")] * len(lis)
ret[start] = 0
q = deque([start])
plis = [i for i in range(len(lis))]
while len(q) > 0:
now = q.popleft()
for nex in lis[now]:
if ret[nex] > ret[now] + 1:
ret[nex] = ret[now] + 1
plis[nex] = now
q.append(nex)
return ret,plis
def inverse(a): #aのmodを法にした逆元を返す
return pow(a,mod-2,mod)
def dfs(v):
if len(lis[v]) == 0:
ret = [ [1,1] ]
return ret
else:
retlis = []
for nex in lis[v]:
nret = dfs(nex)
retlis.append( [len(nret),nret] )
retlis.sort()
#1つしかない場合マージしない
if len(retlis) == 1:
retlis[-1][1].append([1,1])
return retlis[-1][1]
#2つ以上の場合最大のやつにマージする
for revd in range(retlis[-2][0]):
zmul = 1
amul = 1
for i in range(len(retlis)-1,-1,-1):
if revd < retlis[i][0]:
zmul *= retlis[i][1][-1-revd][0]
amul *= sum(retlis[i][1][-1-revd])
zmul %= mod
amul %= mod
else:
break
nsum = 0
for i in range(len(retlis)-1,-1,-1):
if revd < retlis[i][0]:
nsum += zmul * inverse(retlis[i][1][-1-revd][0]) * retlis[i][1][-1-revd][1]
nsum %= mod
else:
break
retlis[-1][1][-1-revd][1] = nsum
retlis[-1][1][-1-revd][0] = (amul-nsum) % mod
retlis[-1][1].append([1,1])
return retlis[-1][1]
N = int(eval(input()))
p = list(map(int,input().split()))
lis = [ [] for i in range(N+1) ]
for i in range(N):
#lis[i+1].append(p[i])
lis[p[i]].append(i+1)
dlis,plis = NC_Dij(lis,0)
maxd = max(dlis)
dn = [0] * (maxd+1)
for i in dlis:
dn[i] += 1
ans = dfs(0)
#print (dn,ans)
A = 0
for i in range(maxd+1):
A += ans[-1-i][1] * pow(2,N+1-dn[i],mod)
A %= mod
print (A)
| p03499 |
def merge(p1, p2):
inds = list(set(p1 + p2))
inds.sort(key=lambda i: a[i],reverse=True)
return inds[:2]
n = eval(input())
a = list(map(int, input().split()))
a.append(0) #default value used for a[-1]
best = a[0]
dp = [[i, -1] for i in range(1 << n)]
for mask in range(1, len(dp)):
for j in range(n):
if mask & (1 << j):
dp[mask] = merge(dp[mask], dp[mask ^ (1 << j)])
best = max(best, sum([a[x] for x in dp[mask]]))
print(best)
|
def merge(a, b):
if a[0] > b[0]:
if a[1] > b[0]:
return a
return a[0], b[0]
if b[1] > a[0]:
return b
return b[0], a[0]
n = eval(input())
a = list(map(int, input().split()))
dp = [(a[i], 0) for i in range(1 << n)]
for j in range(n):
for mask in range(1, len(dp)):
if mask & (1 << j):
dp[mask] = merge(dp[mask], dp[mask ^ (1 << j)])
best = a[0]
for i in range(1, len(dp)):
best = max(best, sum(dp[i]))
print(best)
| p03313 |
import sys
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
class Top2:
def __init__(self,x=-1,y=-1):
if x<y:x,y=y,x
self.val=[x,y]
self.s=x+y
def __add__(self, other):
self.val=sorted(self.val+other.val,reverse=True)[:2]
return self
n=II()
aa=LI()
dp=[Top2(a) for a in aa]
for i in range(n):
for j in range((1<<n)-1,-1,-1):
if j>>i&1:continue
dp[j|1<<i]+=dp[j]
mx=-1
for j in range(1,1<<n):
mx=max(mx,sum(dp[j].val))
print(mx)
| import sys
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
class Top2:
def __init__(self,x=-1,y=-1):
if x<y:x,y=y,x
self.val=[x,y]
def __add__(self, other):
self.val=sorted(self.val+other.val,reverse=True)[:2]
return self
n=II()
aa=LI()
dp=[Top2(a) for a in aa]
for i in range(n):
for j in range((1<<n)-1,-1,-1):
if j>>i&1:continue
dp[j|1<<i]+=dp[j]
mx=-1
for j in range(1,1<<n):
mx=max(mx,sum(dp[j].val))
print(mx)
| p03313 |
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
d = [None]*(2**n)
d[0] = [a[0], 0, -1, -1]
ans = 0
for i, t1 in enumerate(a[1:]):
i += 1
t2, t3, t4 = i, -1, -1
for j in range(len(bin(i))-2):
k = i & ~(1 << j)
if k == i:
continue
t5, t6, t7, t8 = d[k]
if t5 > t1:
t1, t2, t3, t4 = t5, t6, t1, t2
elif t5 > t3:
if t6 != t2:
t3, t4 = t5, t6
if t7 > t3:
t3, t4 = t7, t8
d[i] = [t1, t2, t3, t4]
ans = max(ans, t1+t3)
print(ans)
main() | def main():
n = int(eval(input()))
a = list(map(int, input().split()))
d = [[j, i, -1, -1] for i, j in enumerate(a)]
ans = 0
for i in range(1, 2**n):
t1, t2, t3, t4 = d[i]
for j in range(len(bin(i))-2):
t5, t6, t7, t8 = d[i & ~(1 << j)]
if t5 > t1:
t1, t2, t3, t4 = t5, t6, t1, t2
elif t5 > t3:
if t6 != t2:
t3, t4 = t5, t6
continue
if t7 > t3:
t3, t4 = t7, t8
d[i] = [t1, t2, t3, t4]
ans = max(ans, t1+t3)
print(ans)
main() | p03313 |
import sys
input = sys.stdin.readline
from operator import itemgetter
N = int(eval(input()))
A = list(map(int, input().split()))
Max = [[(0, A[0])]]
ans = 0
for bit in range(1, (1<<N)):
dic = {}
for i in range(N):
if bit&(1<<i) != 0:
for ind, val in Max[bit-(1<<i)]:
dic[ind] = val
com = [(bit, A[bit])]
for ind, val in list(dic.items()):
com.append((ind, val))
com.sort(reverse=True, key=itemgetter(1))
Max.append(com[:2])
tmp = com[0][1] + com[1][1]
if tmp > ans:
ans = tmp
print(ans) | import sys
input = sys.stdin.readline
N = int(eval(input()))
A = list(map(int, input().split()))
Max = [[(0, A[0])]]
ans = 0
for bit in range(1, (1<<N)):
dic = {bit: A[bit]}
for i in range(N):
if bit&(1<<i) != 0:
for ind, val in Max[bit-(1<<i)]:
dic[ind] = val
com = []
for ind, val in list(dic.items()):
if len(com) < 2:
com.append((ind, val))
else:
if com[0][1] < com[1][1]:
if com[0][1] < val:
com[0] = (ind, val)
elif com[1][1] < val:
com[1] = (ind, val)
else:
if com[1][1] < val:
com[1] = (ind, val)
elif com[0][1] < val:
com[0] = (ind, val)
Max.append(com)
tmp = com[0][1] + com[1][1]
if tmp > ans:
ans = tmp
print(ans) | p03313 |
import sys
input = sys.stdin.readline
from itertools import accumulate
def merge(x, y):
D = sorted([dp[x][0], dp[x][1], dp[y][0], dp[y][1]], reverse=True)
return (D[0], D[1])
n = int(input())
A = tuple(map(int, input().split()))
dp = [(a, 0) for a in A]
for j in range(n):
for i in range(1<<n):
if i & (1<<j):
dp[i] = merge(i, i & ~(1<<j))
L = tuple(accumulate((sum(d) for d in dp), max))
print(*L[1:], sep="\n")
| import sys
input = sys.stdin.readline
from itertools import accumulate
def merge(x, y):
a, b = dp[x]
c, d = dp[y]
if a >= c:
return (a, max(c, b))
return (c, max(a, d))
n = int(input())
A = tuple(map(int, input().split()))
dp = [(a, 0) for a in A]
for j in range(n):
for i in range(1<<n):
if i & (1<<j):
dp[i] = merge(i, i & ~(1<<j))
L = tuple(accumulate((sum(d) for d in dp), max))
print(*L[1:], sep="\n")
| p03313 |
n = int(input())
a = list(map(int, input().split()))
b = [[i, 1<<n] for i in range(len(a))]
a.append(-float("inf"))
def update(a1, a2):
a1.extend(a2)
return sorted(set(a1), key=lambda x: -a[x])[:2]
for j in range(n):
for i in range(1<<n):
if i & (1<<j):
b[i] = update(b[i], b[i & ~(1<<j)])
ans = []
tmp = 0
for i in range(1, 1<<n):
tmp = max(tmp, a[b[i][0]]+a[b[i][1]])
ans.append(tmp)
print(*ans, sep="\n")
| n = int(input())
a = list(map(int, input().split()))
b = [[i] for i in a]
for j in range(n):
for i in range(1<<n):
if i & (1<<j):
b[i] = sorted(b[i]+b[i^1<<j], reverse=True)[:2]
ans = []
tmp = 0
for i in range(1, 1<<n):
tmp = max(tmp, sum(b[i]))
ans.append(tmp)
print(*ans, sep="\n")
| p03313 |
#import numpy as np
N = int(eval(input()))
A = list(map(int, input().split()))
#dp[S] = A[S], -inf で初期化 Sの部分集合TのうちA[T]が(最大のもの, 次に大きいもの) を入れていく
dp = [[A[S], -float('inf') ] for S in range(1 << N)]
for i in range(N):
for T in range( 1 << N):
if (T >> i) & 1 == 1: # Tがiを含むとき
merge = dp[T] + dp[T ^ (1 << i)]
merge.sort(reverse = True)
dp[T] =merge[:2]
ans = -float('inf')
for S in range(1, 1 << N , 1):
ans = max(ans, sum(dp[S]))
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
#dp[S] = A[S], -inf で初期化 Sの部分集合TのうちA[T]が(最大のもの, 次に大きいもの) を入れていく
dp = [[A[S], -float('inf') ] for S in range(1 << N)]
for i in range(N):
for T in range( 1 << N):
if (T >> i) & 1 == 1: # Tがiを含むとき
merge = dp[T] + dp[T ^ (1 << i)]
merge.sort(reverse = True)
dp[T] =merge[:2]
ans = -float('inf')
for S in range(1, 1 << N , 1):
ans = max(ans, sum(dp[S]))
print(ans) | p03313 |
N = int(eval(input()))
A = [[(0, 0)] * (1<<N) for _ in range(N+1)]
A[0] = [(int(a), 0) for a in input().split()]
combine = lambda a, b: a if a[1] >= b[0] else b if b[1] >= a[0] else (a[0], b[0]) if a[0] > b[0] else (b[0], a[0])
for i in range(1, N+1):
ii = 1 << i - 1
for j in range(1<<N):
if j & ii:
A[i][j] = combine(A[i-1][j], A[i-1][j^ii])
else:
A[i][j] = A[i-1][j]
ANS = [0] * (1<<N)
for i in range(1, 1<<N):
ANS[i] = max(ANS[i-1], sum(A[-1][i]))
print(("\n".join(map(str, ANS[1:])))) | N = int(eval(input()))
A = [(int(a), 0) for a in input().split()]
combine = lambda a, b: a if a[1] >= b[0] else b if b[1] >= a[0] else (a[0], b[0]) if a[0] > b[0] else (b[0], a[0])
for i in range(N):
ii = 1 << i
for j in range(1<<N)[::-1]:
if j & ii:
A[j] = combine(A[j], A[j^ii])
ANS = [0] * (1<<N)
for i in range(1, 1<<N):
ANS[i] = max(ANS[i-1], sum(A[i]))
print(("\n".join(map(str, ANS[1:])))) | p03313 |
#!/usr/bin/env python
from collections import deque
import itertools as it
import sys
import math
def func():
N = int(eval(input()))
A = list(map(int, input().split()))
P = [[(A[0], 0), (0, 0)] for i in range(2 ** N)]
for i in range(1, 2 ** N):
if (A[i], i) > P[i][0]:
P[i][1] = P[i][0]
P[i][0] = (A[i], i)
elif (A[i], i) > P[i][1]:
P[i][1] = (A[i], i)
for j in range(N):
if (i & (1 << j)) == 0:
index = i + (1 << j)
for k in range(2):
if P[i][k] > P[index][0]:
P[index][1] = P[index][0]
P[index][0] = P[i][k]
elif P[i][k] > P[index][1] and P[i][k] != P[index][0]:
P[index][1] = P[i][k]
ans = 0
for i in range(1, 2 ** N):
ans = max(ans, P[i][0][0] + P[i][1][0])
print(ans)
#print(P)
func() | #!/usr/bin/env python
#from collections import deque
#import itertools as it
#import sys
#import math
def func():
N = int(eval(input()))
A = list(map(int, input().split()))
P = [[(A[0], 0), (0, 0)] for i in range(2 ** N)]
for i in range(1, 2 ** N):
if (A[i], i) > P[i][0]:
P[i][1] = P[i][0]
P[i][0] = (A[i], i)
elif (A[i], i) > P[i][1]:
P[i][1] = (A[i], i)
for j in range(N):
if (i & (1 << j)) == 0:
index = i + (1 << j)
for k in range(2):
if P[i][k] > P[index][0]:
P[index][1] = P[index][0]
P[index][0] = P[i][k]
elif P[i][k] > P[index][1] and P[i][k] != P[index][0]:
P[index][1] = P[i][k]
ans = 0
for i in range(1, 2 ** N):
ans = max(ans, P[i][0][0] + P[i][1][0])
print(ans)
#print(P)
func() | p03313 |
import sys
from pprint import pprint
def solve(s):
w = ["Sunny", "Cloudy", "Rainy"]
print((w[(w.index(s) + 1) % 3]))
if __name__ == '__main__':
s = sys.stdin.readline().strip()
solve(s) | import sys
S = sys.stdin.readline().strip()
weathers = ["Sunny", "Cloudy", "Rainy"]
print((weathers[(weathers.index(S) + 1) % 3])) | p02909 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
d = {'Sunny':'Cloudy','Cloudy':'Rainy','Rainy':'Sunny'}
print((d[S()]))
| import sys
def S(): return sys.stdin.readline().rstrip()
d = {'Sunny':'Cloudy','Cloudy':'Rainy','Rainy':'Sunny'}
print((d[S()]))
| p02909 |
import sys
import itertools
wether = input()
base = ['Sunny','Cloudy','Rainy']
if wether not in base: sys.exit()
print(base[base.index(wether)+1]) if wether != base[-1] else print(base[0])
| import sys
wether = input()
base = ['Sunny','Cloudy','Rainy']
if wether not in base: sys.exit()
print(base[base.index(wether)+1]) if wether != base[-1] else print(base[0])
| p02909 |
S = input().strip()
if S=="Sunny":
print("Cloudy")
elif S=="Cloudy":
print("Rainy")
elif S=="Rainy":
print("Sunny") | S = input().strip()
if S=="Sunny":
print("Cloudy")
elif S=="Cloudy":
print("Rainy")
else:
print("Sunny") | p02909 |
def slove():
import sys
input = sys.stdin.readline
d = {"Sunny": "Cloudy", "Cloudy": "Rainy", "Rainy": "Sunny"}
s = str(input().rstrip('\n'))
print((d[s]))
if __name__ == '__main__':
slove()
| import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
s = str(input().rstrip('\n'))
if s == "Sunny":
print("Cloudy")
elif s == "Cloudy":
print("Rainy")
elif s == "Rainy":
print("Sunny")
if __name__ == '__main__':
solve()
| p02909 |
# 日立コン
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
A, B, M = list(map(int, readline().split()))
Alist = list(map(int, readline().split()))
Blist = list(map(int, readline().split()))
answer = 10 ** 7
for a in Alist:
for b in Blist:
tmp = a + b
if tmp < answer:
answer = tmp
for _ in range(0, M):
x, y, c = list(map(int, readline().split()))
tmp = Alist[x-1] + Blist[y-1] - c
if tmp < answer:
answer = tmp
if answer > 0:
print(answer)
else:
print((0)) | # 日立コン
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
A, B, M = list(map(int, readline().split()))
Alist = list(map(int, readline().split()))
Blist = list(map(int, readline().split()))
min_a = min(Alist)
min_b = min(Blist)
answer = min_a + min_b
for _ in range(0, M):
x, y, c = list(map(int, readline().split()))
tmp = Alist[x-1] + Blist[y-1] - c
answer = min(answer, tmp)
if answer > 0:
print(answer)
else:
print((0)) | p02748 |
R = lambda: tuple(map(int, input().split()))
A, B, M = R()
a, b = R(), R()
d = (R() for _ in range(M))
print((min([min(a) + min(b)] + [a[x - 1] + b[y - 1] - c for x, y, c in d])))
| R = lambda: tuple(map(int, input().split()))
A, B, M = R()
a, b = R(), R()
d = (R() for _ in range(M))
print((min(min(a) + min(b), *(a[x - 1] + b[y - 1] - c for x, y, c in d))))
| p02748 |
A, B, M = list(map(int, input().split()))
As = list(map(int, input().split()))
Bs = list(map(int, input().split()))
coupons = []
for _ in range(M):
coupons.append(list(map(int, input().split())))
target = list(coupon[:2] for coupon in coupons)
best_sum = 10000
def my_index(l, x, default=-1):
if x in l:
return l.index(x)
else:
return default
def my_index_multi(l, x):
return [i for i, _x in enumerate(l) if _x == x]
for a in range(A):
for b in range(B):
index = my_index_multi(target, [a+1, b+1])
if len(index) > 0:
for i in index:
sum_value = As[a]+Bs[b]-coupons[i][2]
if best_sum > sum_value:
best_sum = sum_value
else:
sum_value = As[a]+Bs[b]
if best_sum > sum_value:
best_sum = sum_value
print(best_sum) | A, B, M = list(map(int, input().split()))
As = list(map(int, input().split()))
Bs = list(map(int, input().split()))
coupons = []
for _ in range(M):
coupons.append(list(map(int, input().split())))
a_min = min(As)
b_min = min(Bs)
best_sum = a_min+b_min
coupons_sums = []
for l in coupons:
coupons_sums.append(As[l[0]-1] + Bs[l[1]-1] - l[2])
for coupons_sum in coupons_sums:
if best_sum > coupons_sum:
best_sum = coupons_sum
print(best_sum) | p02748 |
A, B, M = [int(x) for x in input().split()]
A_price_list = [int(x) for x in input().split()]
B_price_list = [int(x) for x in input().split()]
discount_list = [[0 for j in range(B)] for i in range(A)]
for i in range(M):
x, y, c = ([int(x) for x in input().split()])
discount_list[x-1][y-1] = max(discount_list[x-1][y-1], c)
amount = 9999999999999999999999999
for i in range(A):
for j in range(B):
tmp_amount = A_price_list[i] + B_price_list[j] - discount_list[i][j]
amount = min(amount, tmp_amount)
print(amount) | A, B, M = [int(x) for x in input().split()]
A_price_list = [int(x) for x in input().split()]
B_price_list = [int(x) for x in input().split()]
discount_list = []
for i in range(M):
x, y, c = [int(x) for x in input().split()]
discount_list.append([x-1, y-1, c])
amount = min(A_price_list) + min(B_price_list)
for x, y, c in discount_list:
tmp_price = A_price_list[x] + B_price_list[y] - c
amount = min(tmp_price, amount)
print(amount) | p02748 |
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
mini = 2*10**5
for i in range(M):
num = list(map(int, input().split()))
tmp = a[num[0]-1] + b[num[1]-1] - num[2]
if tmp < mini:
mini = tmp
for i in range(A):
if a[i] > mini:
continue
for j in range(B):
if a[i]+b[j] < mini:
mini = a[i]+b[j]
print(mini) | A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
mini = 2*10**5
for i in range(M):
num = list(map(int, input().split()))
tmp = a[num[0]-1] + b[num[1]-1] - num[2]
if tmp < mini:
mini = tmp
mini = min(mini, min(a)+min(b))
print(mini)
| p02748 |
n_a,n_b,M=list(map(int,input().split()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
price=[]
for i in range(M):
X=list(map(int,input().split()))
price.append(A[X[0]-1]+B[X[1]-1]-X[2])
for i in range(n_a):
for j in range(n_b):
price.append(A[i]+B[j])
print((min(price))) | n_a,n_b,M=list(map(int,input().split()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
price=[]
for i in range(M):
X=list(map(int,input().split()))
price.append(A[X[0]-1]+B[X[1]-1]-X[2])
price.append(min(A)+min(B))
print((min(price))) | p02748 |
#入力処理
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
waribiki=[[0]*B]*A
for i in range(M):
x_input, y_input, c_input = list(map(int, input().split()))
if waribiki[x_input-1][y_input-1]<c_input:
waribiki[x_input-1][y_input-1]=c_input
#処理
inexpensive=200000
for i in range(A):
for j in range(B):
if (int(a[i])+int(b[j]))-waribiki[i][j] < inexpensive:
inexpensive = (int(a[i])+int(b[j]))-waribiki[i][j]
print(inexpensive) | #入力処理
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
kingaku=[]
for i in range(M):
x_input, y_input, c_input = list(map(int, input().split()))
kingaku.append(a[x_input-1]+b[y_input-1]-c_input)
kingaku.append(min(a)+min(b))
print((min(kingaku))) | p02748 |
# coding: utf-8
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
z = [list(map(int, input().split())) for _ in range(M)]
num1 = [a[i] + b[j] for i in range(A) for j in range(B)]
# print("num1:", num1)
for i in range(M):
x, y, c = z[i]
num = a[x - 1] + b[y - 1] - c
num1.append(num)
# print(num1)
print((min(num1))) | # coding: utf-8
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
z = [list(map(int, input().split())) for _ in range(M)]
num1 = {a[i] + b[j] for i in range(A) for j in range(B)}
# print("num1:", num1)
num1 = min(num1)
# print("num1:", num1)
for i in range(M):
x, y, c = z[i]
num = a[x - 1] + b[y - 1] - c
if num < num1:
num1 = num
print(num1) | p02748 |
# coding: utf-8
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
z = [list(map(int, input().split())) for _ in range(M)]
num1 = {a[i] + b[j] for i in range(A) for j in range(B)}
# print("num1:", num1)
num1 = min(num1)
# print("num1:", num1)
for i in range(M):
x, y, c = z[i]
num = a[x - 1] + b[y - 1] - c
if num < num1:
num1 = num
print(num1) | # coding: utf-8
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a1 = sorted(a)
b1 = sorted(b)
z = [list(map(int, input().split())) for _ in range(M)]
num1 = a1[0] + b1[0]
# print("num1:", num1)
for i in range(M):
x, y, c = z[i]
num = a[x - 1] + b[y - 1] - c
if num < num1:
num1 = num
print(num1)
| p02748 |
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
X = [list(map(int, input().split())) for i in range(M)]
ans = [min(a) + min(b)]
for x in X:
a_idx, b_index, c = x
ans.append(a[a_idx - 1] + b[b_index - 1] - c)
print((min(ans))) | a,b,m = list(map(int,input().split()))
a_li = list(map(int,input().split()))
b_li = list(map(int,input().split()))
cost = min(a_li) + min(b_li)
for i in range(m):
x,y,c = list(map(int,input().split()))
price = a_li[x-1] + b_li[y-1] - c
if price < cost:
cost = price
print(cost)
| p02748 |
a, b, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
bb = list(map(int, input().split()))
mm = list()
for ii in range(0,m):
mm.append(list(map(int, input().split())))
prices = list()
for ml in mm:
prices.append(aa[ml[0]-1] + bb[ml[1]-1] - ml[2])
for al in aa:
for bl in bb:
prices.append(al + bl)
print((min(prices)))
| a, b, m = list(map(int, input().split()))
aa = list(map(int, input().split()))
bb = list(map(int, input().split()))
mm = list()
for ii in range(0,m):
mm.append(list(map(int, input().split())))
prices = list()
prices.append(int(min(aa)) + int(min(bb)))
for ml in mm:
prices.append(aa[ml[0]-1] + bb[ml[1]-1] - ml[2])
print((min(prices)))
| p02748 |
f=lambda:list(map(int,input().split()))
_,_,n=f()
a,b=list(f()),list(f())
m=min(a)+min(b)
for _ in range(n): x,y,c=f(); m=min(m,a[x-1]+b[y-1]-c)
print(m) | import sys
f=lambda:list(map(int,sys.stdin.readline().split()))
_,_,n=f()
a,b=list(f()),list(f())
m=min(a)+min(b)
for _ in range(n): x,y,c=f(); m=min(m,a[x-1]+b[y-1]-c)
print(m) | p02748 |
a,b,m=list(map(int, input().split()))
A=list(map(int, input().split()))
B=list(map(int, input().split()))
tickets=list()
for i in range(m):
tickets.append(list(map(int,input().split())))
price_min=float("INF")
for ticket in tickets:
price = A[ticket[0]-1] + B[ticket[1]-1] - ticket[2]
price_min = price if price_min>price else price_min
# 割引券を使わない場合
for _a in A:
for _b in B:
price=_a + _b
price_min=price if price_min > price else price_min
if price <_a:
break
print(price_min) | a,b,m=list(map(int, input().split()))
A=list(map(int, input().split()))
B=list(map(int, input().split()))
tickets=list()
for i in range(m):
tickets.append(list(map(int,input().split())))
price_min=float("INF")
for ticket in tickets:
price = A[ticket[0]-1] + B[ticket[1]-1] - ticket[2]
price_min = price if price_min>price else price_min
# 割引券を使わない場合
no_ticket=min(A)+min(B)
if price_min > no_ticket: price_min=no_ticket
print(price_min) | p02748 |
a,b,m = list(map(int,input().split()))
alist = list(map(int,input().split()))
blist = list(map(int,input().split()))
mlist = [list(map(int,input().split())) for s in range(m)]
ans = []
for m in mlist:
tmp = alist[m[0]-1] + blist[m[1]-1] -m[2]
ans.append(tmp)
for a in alist:
for b in blist:
ans.append(a + b)
print((min(ans))) | a,b,m = list(map(int,input().split()))
alist = list(map(int,input().split()))
blist = list(map(int,input().split()))
mlist = [list(map(int,input().split())) for s in range(m)]
ans = []
for m in mlist:
tmp = alist[m[0]-1] + blist[m[1]-1] -m[2]
ans.append(tmp)
x = min(alist) + min(blist)
ans.append(x)
print((min(ans))) | p02748 |
import sys
A, B, M = list(map(int, input().split()))
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
# discounts = list(list(map(int, input().split())) for _ in )
discounts = dict()
for discount in sys.stdin:
x, y, c = discount.split()
c = int(c)
if x in discounts:
if y in discounts[x]:
if discounts[x][y] < c:
discounts[x][y] = c
else:
discounts[x][y] = c
else:
discounts[x] = {y: c}
min = -1
for i in range(len(a_list)):
b_line_prices = []
for j in range(len(b_list)):
price = a_list[i] + b_list[j]
x = str(i + 1)
y = str(j + 1)
if x in discounts:
if y in discounts[x]:
price -= discounts[x][y]
if min == -1 or price < min:
min = price
print(min) | import sys
A, B, M = list(map(int, input().split()))
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
ans = min(a_list) + min(b_list)
for discount in sys.stdin:
x, y, c = list(map(int, discount.split()))
ans = min(ans, a_list[x - 1] + b_list[y - 1] - c)
print(ans)
| p02748 |
A, B, M = [int(_) for _ in input().split()]
a = [int(_) for _ in input().split()]
b = [int(_) for _ in input().split()]
xyc = [[int(_) for _ in input().split()] for i in range(M)]
rets = []
for i in a:
for j in b:
rets += [i + j]
for x, y, c in xyc:
rets += [a[x-1] + b[y-1] - c]
print((min(rets))) | A, B, M = [int(_) for _ in input().split()]
a = [int(_) for _ in input().split()]
b = [int(_) for _ in input().split()]
xyc = [[int(_) for _ in input().split()] for i in range(M)]
rets = [min(a) + min(b)]
for x, y, c in xyc:
rets += [a[x-1] + b[y-1] - c]
print((min(rets))) | p02748 |
A, B, M = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
b = list(map(int, input().split(' ')))
discountDic = {}
for i in range(M):
x, y, c = list(map(int, input().split(' ')))
key = (x-1)*B+(y-1)
if key not in discountDic or discountDic[key] < c:
discountDic[key] = c
priceList = []
for i in range(A):
for j in range(B):
price = a[i] + b[j]
if i*B+j in discountDic:
price -= discountDic[i*B+j]
priceList.append(price)
print((min(priceList))) | A, B, M = list(map(int, input().split(' ')))
a = list(map(int, input().split(' ')))
b = list(map(int, input().split(' ')))
discountDic = {}
for i in range(M):
x, y, c = list(map(int, input().split(' ')))
key = (x-1)*B+(y-1)
if key not in discountDic or discountDic[key] > a[x-1] + b[y-1] - c:
discountDic[key] = a[x-1] + b[y-1] - c
discount_min_price = min(discountDic.values())
all_low_price = min(a) + min(b)
if discount_min_price < all_low_price:
print(discount_min_price)
else:
print(all_low_price) | p02748 |
A, B, M = list(map(int, input().split()))
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
xyc_list = []
for i in range(M):
xyc_list.append(list(map(int, input().split())))
total_min = min(a_list) + min(b_list)
for x,y,c in xyc_list:
if a_list[x-1] in a_list and b_list[y-1] in b_list:
total = a_list[x-1] + b_list[y-1] - c
if total_min > total:
total_min = total
print(total_min)
| A, B, M = list(map(int, input().split()))
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
xyc_list = []
for i in range(M):
xyc_list.append(list(map(int, input().split())))
total_min = min(a_list) + min(b_list)
for x,y,c in xyc_list:
total = a_list[x-1] + b_list[y-1] - c
if total_min > total:
total_min = total
print(total_min)
| p02748 |
a,b,m = [int(x) for x in input().split()]
an = [(int(x),i+1) for i,x in enumerate(input().split())]
bn = [(int(x),i+1) for i,x in enumerate(input().split())]
an = sorted(an)
bn = sorted(bn)
discounts = {}
discount_list = []
for i in range(m):
x,y,c = [int(x) for x in input().split()]
if (x,y) in discounts and discounts[(x,y)] > c:
continue
discounts[(x,y)] = c
discount_list.append(c)
discount_list = sorted(discount_list,reverse=True)
i = 0
j = 0
min = an[0][0]+bn[0][0]
max_discount = max(discount_list)
len_an = len(an)
len_bn = len(bn)
# print(an)
# print(bn)
# print(min)
# print(discounts)
for ai in an:
for bj in bn:
a_index = ai[1]
b_index = bj[1]
discount = 0
if (a_index, b_index) in discounts:
discount = discounts[(a_index, b_index)]
total = ai[0] + bj[0] - discount
if min > total:
min = total
if ai[0] + bj[0] - max_discount > min:
break
# while True:
# a_index = an[i][1]
# b_index = bn[j][1]
# discount = 0
# if (a_index, b_index) in discounts:
# discount = discounts[(a_index, b_index)]
# total = an[i][0] + bn[j][0] - discount
# if min > total:
# min = total
#
# if an[i][0] + bn[j][0] - max_discount > min:
# break
# elif i == len_an-1 and j == len_bn-1:
# break
# elif i == len_an-1:
# j += 1
# elif j == len_bn-1:
# i += 1
# else:
# a_diff = an[i+1][0] - an[i][0]
# b_diff = bn[j+1][0] - an[j][0]
# if a_diff < b_diff:
# i += 1
# else:
# j += 1
print(min)
|
a,b,m = [int(x) for x in input().split()]
an = [int(x) for x in input().split()]
bn = [int(x) for x in input().split()]
ans = min(an)+min(bn)
for i in range(m):
p, q, discount = [int(x) for x in input().split()]
a_cost = an[p-1]
b_cost = bn[q-1]
total = a_cost + b_cost - discount
ans = min(total, ans)
print(ans)
| p02748 |
import itertools
a, b, m = list(map(int, input().split()))
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
m_list = [list(map(int, input().split())) for _ in range(m)]
kumiawase_kingaku = float('inf')
for ab in itertools.product(a_list, b_list):
if ab[0] + ab[1] < kumiawase_kingaku:
kumiawase_kingaku = ab[0] + ab[1]
for x, y, c in m_list:
reizouko = a_list[x-1]
denshirenji = b_list[y-1]
kingaku = reizouko + denshirenji - c
if kingaku < kumiawase_kingaku:
kumiawase_kingaku = kingaku
print(kumiawase_kingaku)
| import itertools
a, b, m = list(map(int, input().split()))
a_list = list(map(int, input().split()))
b_list = list(map(int, input().split()))
m_list = [list(map(int, input().split())) for _ in range(m)]
kumiawase_kingaku = min(a_list) + min(b_list)
for x, y, c in m_list:
reizouko = a_list[x-1]
denshirenji = b_list[y-1]
kingaku = reizouko + denshirenji - c
if kingaku < kumiawase_kingaku:
kumiawase_kingaku = kingaku
print(kumiawase_kingaku) | p02748 |
A,B,m = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
x = [0 for _ in range(m)]
y = [0 for _ in range(m)]
c = [0 for _ in range(m)]
for i in range(m):
x[i],y[i],c[i] = list(map(int,input().split()))
ans = 10000000000
for i in range(A):
for j in range(B):
for k in range(m):
if(i+1 == x[k] and j+1 == y[k]):
price = a[i] + b[j] - c[k]
else:
price = a[i] + b[j]
ans = min(ans,price)
print(ans) | A,B,m = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
x = [0 for _ in range(m)]
y = [0 for _ in range(m)]
c = [0 for _ in range(m)]
for i in range(m):
x[i],y[i],c[i] = list(map(int,input().split()))
ans = min(a)+min(b)
for i in range(m):
ans = min(ans,(a[x[i]-1] + b[y[i]-1]) - c[i])
print(ans) | p02748 |
#読み込み
list_num = input().split(" ") #A,B,M
list_ref = input().split(" ") #冷蔵庫の値段
list_ren = input().split(" ") #レンジの値段
list2 = [] #割引できるやつの組み
for i in range(int(list_num[2])):
list_c = input().split(" ")
list2.append(list_c)
A = int(list_num[0])
B = int(list_num[1])
M = int(list_num[2])
#割引なしで総当たり
list_price = []
for i in range(A):
for j in range(B):
list_price.append(int(list_ref[i]) + int(list_ren[j]))
#割引きを総当たり
for k in range(M):
price = int(list_ref[int(list2[k][0])-1]) + int(list_ren[int(list2[k][1])-1]) - int(int(list2[k][2])-1) - 1
list_price.append(price)
print((min(list_price))) | #読み込み
list_num = input().split(" ") #A,B,M
list_ref = input().split(" ") #冷蔵庫の値段
list_ren = input().split(" ") #レンジの値段
list2 = [] #割引できるやつの組み
for i in range(int(list_num[2])):
list_c = input().split(" ")
list2.append(list_c)
A = int(list_num[0])
B = int(list_num[1])
M = int(list_num[2])
list_price = []
#一番安いのと一番安いの
list_ref_int = [int(s) for s in list_ref]
list_ren_int = [int(s) for s in list_ren]
cheap = min(list_ref_int) + min(list_ren_int)
list_price.append(cheap)
#割引きを総当たり
for k in range(M):
price = list_ref_int[int(list2[k][0])-1] + list_ren_int[int(list2[k][1])-1] - int(int(list2[k][2])-1) - 1
list_price.append(price)
print((min(list_price))) | p02748 |
a, b ,c = list(map(int,input().split(" ")))
ap =[]
ap = list(map(int,input().split(" ")))
bp =[]
bp = list(map(int,input().split(" ")))
lowest = 10000000
for i in ap:
for j in bp:
lowest = min(lowest,i+j)
for _ in range(c):
x, y ,z = list(map(int,input().split(" ")))
dis = ap[x-1] + bp[y-1] - z
lowest = min(lowest,dis)
print(lowest) | a, b ,c = list(map(int,input().split(" ")))
ap =[]
ap = list(map(int,input().split(" ")))
bp =[]
bp = list(map(int,input().split(" ")))
lowest = 10000000
ma = min(ap)
mb = min(bp)
lowest = ma +mb
for _ in range(c):
x, y ,z = list(map(int,input().split(" ")))
dis = ap[x-1] + bp[y-1] - z
lowest = min(lowest,dis)
print(lowest) | p02748 |
a,b,m=list(map(int, input().split()))
fridge=list(map(int, input().split()))
microwave=list(map(int, input().split()))
s=[list(map(int,list(input().split()))) for i in range(m)]
discount = [[0 for i in range(b)] for j in range(a)]
def mapDiscountByXY(m,discount,s):
for i in range(m):
if discount[s[i][0]-1][s[i][1]-1] < s[i][2]:
discount[s[i][0]-1][s[i][1]-1] = s[i][2]
return discount
def findMin(a,b,fridge,microwave,discount):
lowest = 100000
for i in range(a):
for j in range(b):
if lowest > fridge[i]+microwave[j]-discount[i][j]:
lowest = fridge[i]+microwave[j]-discount[i][j]
return lowest
discount = mapDiscountByXY(m,discount,s)
print((findMin(a,b,fridge,microwave,discount))) | _,a,b,*t = [list(map(int,i.split())) for i in open(0)]
n=min(a)+min(b)
for x,y,c in t:
n=min(n,a[x-1]+b[y-1]-c)
print(n) | p02748 |
na,nb,nm = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
TA = []
for i in range(nm):
m1, m2, m3 = list(map(int,input().split()))
T = a[m1-1]+b[m2-1]-m3
TA.append(T)
for i in range(na):
for j in range(nb):
T = a[i] + b[j]
TA.append(T)
print((min(TA))) | na,nb,nm = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
TA = []
for i in range(nm):
m1, m2, m3 = list(map(int,input().split()))
T = a[m1-1]+b[m2-1]-m3
TA.append(T)
T = min(a) + min(b)
TA.append(T)
print((min(TA))) | p02748 |
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
xyc = list(list(map(int, input().split())) for _ in range(M))
l1 = []
lx = []
ly = []
min_a = min(a)
min_b = min(b)
for k in range(M):
lx.append(list(x for x, y, c in xyc))
ly.append(list(y for x, y, c in xyc))
l1.append(list(c for x, y, c in xyc))
j = lx[0][k]
p = ly[0][k]
max_l1 = max(list(map(int, max(l1))))
ans = min((min_a + min_b), ((a[j - 1] + b[p - 1]) - max_l1))
print(ans) | A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = min(a) + min(b)
for k in range(M):
x, y, c = list(map(int, input().split()))
ans = min(ans, ((a[x - 1] + b[y - 1]) - c))
print(ans) | p02748 |
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = min(a) + min(b)
for k in range(M):
x, y, c = list(map(int, input().split()))
ans = min(ans, ((a[x - 1] + b[y - 1]) - c))
print(ans) | A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = min(a) + min(b)
for k in range(M):
x, y, c = list(map(int, input().split()))
ans = min((ans), ((a[x - 1] + b[y - 1]) - c))
print(ans) | p02748 |
A,B,M = list(map(int,input().split()))
Ai = list(map(int,input().split()))
Bi = list(map(int,input().split()))
amin = min(Ai)
bmin= min(Bi)
min = amin+bmin
for i in range(M):
xi,yi,ci = list(map(int,input().split()))
if Ai[xi-1] + Bi[yi-1] - ci < min:
min = Ai[xi-1] + Bi[yi-1] - ci
print(min)
| # hitachi2020_b.py
_, _, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
X = []
Y = []
C = []
amin = min(A)
bmin = min(B)
for i in range(M):
x, y, c = list(map(int, input().split()))
X.append(x)
Y.append(y)
C.append(c)
ans = amin+bmin
for i in range(M):
if ans >= A[X[i]-1]+B[Y[i]-1]-C[i]:
ans = A[X[i]-1]+B[Y[i]-1]-C[i]
print(ans)
| p02748 |
# hitachi2020_b.py
_, _, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
X = []
Y = []
C = []
amin = min(A)
bmin = min(B)
for i in range(M):
x, y, c = list(map(int, input().split()))
X.append(x)
Y.append(y)
C.append(c)
ans = amin+bmin
for i in range(M):
if ans >= A[X[i]-1]+B[Y[i]-1]-C[i]:
ans = A[X[i]-1]+B[Y[i]-1]-C[i]
print(ans)
| A,B,M = list(map(int,input().split()))
Ai = list(map(int,input().split()))
Bi = list(map(int,input().split()))
amin = min(Ai)
bmin= min(Bi)
min = amin+bmin
for i in range(M):
xi,yi,ci = list(map(int,input().split()))
if Ai[xi-1] + Bi[yi-1] - ci < min:
min = Ai[xi-1] + Bi[yi-1] - ci
print(min) | p02748 |
[A, B, M] = [int(i) for i in input().split()]
a_list = [int(i) for i in input().split()]
b_list = [int(i) for i in input().split()]
min_amount = 2*10**5
for a in range(A):
for b in range(B):
amount = a_list[a] + b_list[b]
min_amount = min(amount, min_amount)
for m in range(M):
[x, y, c] = [int(i) for i in input().split()]
amount = a_list[x-1] + b_list[y-1] - c
min_amount = min(amount, min_amount)
print(min_amount) | [A, B, M] = [int(i) for i in input().split()]
a_list = [int(i) for i in input().split()]
b_list = [int(i) for i in input().split()]
min_amount = min(a_list) + min(b_list)
for m in range(M):
[x, y, c] = [int(i) for i in input().split()]
amount = a_list[x-1] + b_list[y-1] - c
min_amount = min(amount, min_amount)
print(min_amount) | p02748 |
A,B,M=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
x=[0]*M
y=[0]*M
c=[0]*M
for i in range(M):
x[i],y[i],c[i]=list(map(int,input().split()))
min=a[0]+b[0]
min1=0
for i in range(A):
for j in range(B):
for t in range(M):
if i+1==x[t] and j+1==y[t]:
min1=a[i]+b[j]-c[t]
else:
min1=a[i]+b[j]
if min >= min1:
min = min1
print(min)
| A,B,M=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
price=[0]*(M+1)
price[0] = min(a)+min(b)
for i in range(M):
x, y, c = list(map(int,input().split()))
price[i + 1] = a[x-1] + b[y-1] - c
print((min(price))) | p02748 |
A, B, M = list(map(int, input().rstrip().split()))
a = list(map(int, input().rstrip().split()))
b = list(map(int, input().rstrip().split()))
cost_sale=[]
for _ in range(M):
x, y, c = list(map(int, input().rstrip().split()))
tot = a[x-1] + b[y-1] - c
cost_sale.append(tot)
cost_raw = [i + j for i in a for j in b]
print((min(cost_sale + cost_raw))) | A, B, M = list(map(int, input().rstrip().split()))
a = list(map(int, input().rstrip().split()))
b = list(map(int, input().rstrip().split()))
cost=[]
for _ in range(M):
x, y, c = list(map(int, input().rstrip().split()))
tot = a[x-1] + b[y-1] - c
cost.append(tot)
cost.append(min(a)+min(b))
print((min(cost)))
| p02748 |
A, B, M = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
x = list()
y = list()
c = list()
for i in range(M):
xi, yi, ci = list(map(int,input().split()))
x.append(xi)
y.append(yi)
c.append(ci)
p = list()
for i in range(A):
for j in range(B):
pij = a[i] + b[j]
p.append(pij)
for i in range(M):
pi = a[x[i]-1] + b[y[i]-1] - c[i]
p.append(pi)
print((min(p)))
| A, B, M = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
x = list()
y = list()
c = list()
for i in range(M):
xi, yi, ci = list(map(int,input().split()))
x.append(xi)
y.append(yi)
c.append(ci)
p = list()
amin = min(a)
bmin = min(b)
pab = amin + bmin
p.append(pab)
for i in range(M):
pi = a[x[i]-1] + b[y[i]-1] - c[i]
p.append(pi)
print((min(p)))
| p02748 |
A, B, M = list(map(int, input().split()))
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
data = [list(map(int, input().split())) for _ in range(M)]
MIN = a[0] + b[0]
for i in range(A):
for j in range(B):
for k in data:
if k[0]-1 == i and k[1]-1 == j:
MIN = min(a[i]+b[j]-k[2], MIN)
MIN = min(a[i]+b[j], MIN)
print(MIN) | A, B, M = list(map(int, input().split()))
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
data = [list(map(int, input().split())) for _ in range(M)]
aMIN = min(a)
bMIN = min(b)
MIN = aMIN + bMIN
for k in data:
MIN = min(MIN, a[k[0]-1]+b[k[1]-1]-k[2])
print(MIN) | p02748 |
#!/usr/bin/python
# coding: UTF-8
def main():
A,B,M = list(map(int, input().split(' ')))
a_list = list(map(int, input().split(' ')))
b_list = list(map(int, input().split(' ')))
dic = {}
for i in range(A):
dic[i]={}
for i in range(A):
for j in range(B):
dic[i][j] = 0
price_list = 2*10**5
for i in range(M):
temp = list(map(int, input().split(' ')))
if price_list > a_list[temp[0]-1] + b_list[temp[1]-1] - temp[2]:
price_list = a_list[temp[0]-1] + b_list[temp[1]-1] - temp[2]
lower = min(a_list) + min(b_list)
if lower < price_list:
print(lower)
else:
print(price_list)
if __name__=='__main__':
main()
| #!/usr/bin/python
# coding: UTF-8
def main():
A,B,M = list(map(int, input().split(' ')))
a_list = list(map(int, input().split(' ')))
b_list = list(map(int, input().split(' ')))
price_list = 2*10**5
for i in range(M):
temp = list(map(int, input().split(' ')))
if price_list > a_list[temp[0]-1] + b_list[temp[1]-1] - temp[2]:
price_list = a_list[temp[0]-1] + b_list[temp[1]-1] - temp[2]
lower = min(a_list) + min(b_list)
if lower < price_list:
print(lower)
else:
print(price_list)
if __name__=='__main__':
main()
| p02748 |
A,B,M = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
p = [i+j for i in a for j in b]
for _ in range(M):
x,y,c = list(map(int,input().split()))
p.append(a[x-1]+b[y-1]-c)
print((min(p))) | A,B,M = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
p = [min(a) + min(b)]
for _ in range(M):
x,y,c = list(map(int,input().split()))
p.append(a[x-1]+b[y-1]-c)
print((min(p))) | p02748 |
a_, b_, m = list(map(int, input().split()))
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
xyc = [[int(i) for i in input().split()] for _ in range(m)]
ans = 100000000
for x, y, c in xyc:
ans = min(a[x-1] + b[y-1] - c, ans)
ans = min(min(a) + min(b), ans)
print(ans) | _, _, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
mi = 10**6
for _ in range(m):
x, y, c = list(map(int, input().split()))
mi = min(mi, a[x-1] + b[y-1] - c)
print((min(mi, min(a)+min(b)))) | p02748 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from sys import stdin
def calc_ab_price_without_pricedown(a_list, b_list):
ab_price = [[a_list[j]+b_list[i] for i in range(len(b_list))] for j in range(len(a_list))]
return ab_price
def calc_pricedown(ab_price, pricedown_list):
"""値段表から値引きする"""
for i, j , price in pricedown_list:
for k, l, price2 in pricedown_list:
if (i, j) == (k, l) and price >= price2:
continue
elif (i, j) == (k, l) and price < price2:
price = 0
ab_price[i-1][j-1] -= price
return ab_price
def generate_table(a_list, b_list, pricedown_list):
ab_price = [[[] for i in range(len(b_list))] for j in range(len(a_list))]
max_price_down = 0
min_a = min(a_list)
min_b = min(b_list)
min_price = min_a + min_b
for i, j, price in pricedown_list:
min_price = min(min_price, a_list[i-1]+b_list[j-1]-price)
return min_price
def calc_min_price(a_list, b_list, ab_price):
min_price = float('inf')
for i in range(len(a_list)):
for j in range(len(b_list)):
min_price = min(ab_price[i][j], min_price)
return min_price
a, b, m = list(map(int, input().split()))
#a_list = list(map(int, input().split()))
a_list = [int(x) for x in stdin.readline().rstrip().split()]
b_list = [int(x) for x in stdin.readline().rstrip().split()]
pricedown_list = []
for i in range(m):
pricedown_list.append([int(x) for x in stdin.readline().rstrip().split()])
# pricedown_list.append((list(map(int, input().split()))))
# 割引せずに購入する場合の合計金額のうち、最低金額を算出
# ab_price = calc_ab_price_without_pricedown(a_list, b_list)
# 最低金額を算出
# min_price = calc_min_price(a_list, b_list, ab_price)
# 割引の値段を含めて考える
# pricedowned_ab = calc_pricedown( ab_price, pricedown_list)
min_price = generate_table(a_list, b_list, pricedown_list)
# 値引き後の最低金額を算出
# min_price = calc_min_price(a_list, b_list, price_table)
print(min_price)
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
from sys import stdin
def calc_ab_price_without_pricedown(a_list, b_list):
ab_price = [[a_list[j]+b_list[i] for i in range(len(b_list))] for j in range(len(a_list))]
return ab_price
def calc_pricedown(ab_price, pricedown_list):
"""値段表から値引きする"""
for i, j, price in pricedown_list:
for k, l, price2 in pricedown_list:
if (i, j) == (k, l) and price >= price2:
continue
elif (i, j) == (k, l) and price < price2:
price = 0
ab_price[i-1][j-1] -= price
return ab_price
def generate_table(a_list, b_list, pricedown_list):
min_a = min(a_list)
min_b = min(b_list)
min_price = min_a + min_b
for i, j, price in pricedown_list:
min_price = min(min_price, a_list[i-1]+b_list[j-1]-price)
return min_price
def calc_min_price(a_list, b_list, ab_price):
min_price = float('inf')
for i in range(len(a_list)):
for j in range(len(b_list)):
min_price = min(ab_price[i][j], min_price)
return min_price
a, b, m = list(map(int, input().split()))
a_list = [int(x) for x in stdin.readline().rstrip().split()]
b_list = [int(x) for x in stdin.readline().rstrip().split()]
pricedown_list = []
for i in range(m):
pricedown_list.append([int(x) for x in stdin.readline().rstrip().split()])
# pricedown_list.append((list(map(int, input().split()))))
# 割引せずに購入する場合の合計金額のうち、最低金額を算出
# ab_price = calc_ab_price_without_pricedown(a_list, b_list)
# 最低金額を算出
# min_price = calc_min_price(a_list, b_list, ab_price)
# 割引の値段を含めて考える
# pricedowned_ab = calc_pricedown( ab_price, pricedown_list)
min_price = generate_table(a_list, b_list, pricedown_list)
# 値引き後の最低金額を算出
# min_price = calc_min_price(a_list, b_list, price_table)
print(min_price)
| p02748 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from sys import stdin
def calc_ab_price_without_pricedown(a_list, b_list):
ab_price = [[a_list[j]+b_list[i] for i in range(len(b_list))] for j in range(len(a_list))]
return ab_price
def calc_pricedown(ab_price, pricedown_list):
"""値段表から値引きする"""
for i, j, price in pricedown_list:
for k, l, price2 in pricedown_list:
if (i, j) == (k, l) and price >= price2:
continue
elif (i, j) == (k, l) and price < price2:
price = 0
ab_price[i-1][j-1] -= price
return ab_price
def generate_table(a_list, b_list, pricedown_list):
min_a = min(a_list)
min_b = min(b_list)
min_price = min_a + min_b
for i, j, price in pricedown_list:
min_price = min(min_price, a_list[i-1]+b_list[j-1]-price)
return min_price
def calc_min_price(a_list, b_list, ab_price):
min_price = float('inf')
for i in range(len(a_list)):
for j in range(len(b_list)):
min_price = min(ab_price[i][j], min_price)
return min_price
a, b, m = list(map(int, input().split()))
a_list = [int(x) for x in stdin.readline().rstrip().split()]
b_list = [int(x) for x in stdin.readline().rstrip().split()]
pricedown_list = []
for i in range(m):
pricedown_list.append([int(x) for x in stdin.readline().rstrip().split()])
# pricedown_list.append((list(map(int, input().split()))))
# 割引せずに購入する場合の合計金額のうち、最低金額を算出
# ab_price = calc_ab_price_without_pricedown(a_list, b_list)
# 最低金額を算出
# min_price = calc_min_price(a_list, b_list, ab_price)
# 割引の値段を含めて考える
# pricedowned_ab = calc_pricedown( ab_price, pricedown_list)
min_price = generate_table(a_list, b_list, pricedown_list)
# 値引き後の最低金額を算出
# min_price = calc_min_price(a_list, b_list, price_table)
print(min_price)
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
from sys import stdin
def calc_min_price(a_list, b_list, pricedown_list):
# 割引しない場合の最安組み合わせを算出する
min_a = min(a_list)
min_b = min(b_list)
min_price = min_a + min_b
# 割引したものも含めて一番安い値段を算出する
for i, j, price in pricedown_list:
min_price = min(min_price, a_list[i-1]+b_list[j-1]-price)
return min_price
# 入力
a, b, m = list(map(int, input().split()))
# 商品値段リスト
a_list = [int(x) for x in stdin.readline().rstrip().split()]
b_list = [int(x) for x in stdin.readline().rstrip().split()]
# 値引きリスト
pricedown_list = []
for i in range(m):
pricedown_list.append([int(x) for x in stdin.readline().rstrip().split()])
# 最小金額を計算する
min_price = calc_min_price(a_list, b_list, pricedown_list)
# 出力
print(min_price)
| p02748 |
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
z = [list(map(int, input().split())) for _ in range(M)]
mem = []
for i in range(len(a)):
for j in range(len(b)):
mem.append(a[i] + b[j])
for x, y, c in z:
mem.append(a[x - 1] + b[y - 1] - c)
print((min(mem)))
| A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
L = [[int(x) for x in input().split()] for _ in range(M)]
reg = min(a) + min(b)
for x, y, c in L:
tmp = a[x-1] + b[y-1] - c
reg = min(reg, tmp)
print(reg) | p02748 |
A, B, M = list(map(int, input().split()))
lenzi=list(map(int,input().split()))
zouko=list(map(int,input().split()))
mPrice = 200000
for i in range(A):
for j in range(B):
if lenzi[i]+zouko[j]<mPrice:
mPrice=lenzi[i]+zouko[j]
for i in range(M):
x, y, c = list(map(int, input().split()))
if lenzi[x-1]+zouko[y-1]-c<mPrice:
mPrice=lenzi[x-1]+zouko[y-1]-c
print(mPrice) | A, B, M = list(map(int, input().split()))
lenzi=list(map(int,input().split()))
zouko=list(map(int,input().split()))
mlenzi=100000
mzouko=100000
mPrice = 200000
for i in range(A):
if lenzi[i]<mlenzi:
for j in range(B):
if zouko[j]<mzouko:
if lenzi[i]+zouko[j]<mPrice:
mPrice=lenzi[i]+zouko[j]
mzouko=zouko[j]
mlenzi=lenzi[i]
for i in range(M):
x, y, c = list(map(int, input().split()))
if lenzi[x-1]+zouko[y-1]-c<mPrice:
mPrice=lenzi[x-1]+zouko[y-1]-c
print(mPrice) | p02748 |
a,b,m = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
count = min(a)+min(b)
for i in range(m):
x,y,c = list(map(int,input().split()))
if count > a[x-1]+b[y-1]-c:
count = a[x-1]+b[y-1]-c
print(count) | a,b,m=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
ans=10**6
for i in range(m):
x,y,c=list(map(int,input().split()))
ans=min(ans,a[x-1]+b[y-1]-c)
print((min(ans,min(a)+min(b)))) | p02748 |
A , B , M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = [i+j for i in a for j in b]
for i in range(M):
q = list(map(int, input().split()))
x = a[q[0]-1] + b[q[1]-1] - q[2]
ans.append(x)
print((min(ans))) | A , B , M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = [min(a) + min(b)]
for i in range(M):
q = list(map(int, input().split()))
x = a[q[0]-1] + b[q[1]-1] - q[2]
ans.append(x)
print((min(ans))) | p02748 |
na, nb, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
min_a = min_b = 10**9
for i in range(na):
min_a = min(min_a, a[i])
for i in range(nb):
min_b = min(min_b, b[i])
ans = min_a + min_b
for i in range(m):
x, y, c = list(map(int, input().split()))
x -= 1
y -= 1
ans = min(ans, a[x] + b[y] - c)
print(ans)
| from sys import stdin
input = lambda: stdin.readline().rstrip()
na, nb, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = min(a) + min(b)
for i in range(m):
x, y, c = list(map(int, input().split()))
x -= 1
y -= 1
ans = min(ans, a[x] + b[y] - c)
print(ans)
| p02748 |
# -*- coding: utf-8 -*-
import math
import itertools
import sys
import copy
#import numpy as np
# 入力
#A, B, C, D = map(int, input().split())
#L = list(map(int, input().split()))
#S = list(str(input()))
#N = int(input())
#S = str(input())
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
#割引券を使う場合
ans = sys.maxsize
for _ in range(M) :
x, y, c = list(map(int, input().split()))
ans = min(ans, a[x-1]+b[y-1]-c)
#その他の組み合わせ
for i in range(A) :
for j in range(B) :
ans = min(ans, a[i] + b[j])
print (ans)
| # -*- coding: utf-8 -*-
import math
import itertools
import sys
import copy
#import numpy as np
# 入力
#A, B, C, D = map(int, input().split())
#L = list(map(int, input().split()))
#S = list(str(input()))
#N = int(input())
#S = str(input())
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
#割引券を使う場合
ans = sys.maxsize
for _ in range(M) :
x, y, c = list(map(int, input().split()))
ans = min(ans, a[x-1]+b[y-1]-c)
#その他の組み合わせ
ans = min(ans, min(a)+min(b))
print (ans)
| p02748 |
a,b,m=list(map(int,input().split()))
ai=list(map(int, input().split()))
bi=list(map(int, input().split()))
sm=[list(map(int, input().split())) for _ in range(m)]
ans=10**6
for i in range(a):
for j in range(b):
for x in range(m):
k=ai[i]+bi[j]
if sm[x][0]==i+1 and sm[x][1]==j+1:
k=k-sm[x][2]
if ans >=k:
ans=k
print(ans)
| a,b,m=list(map(int,input().split()))
ai=list(map(int, input().split()))
bi=list(map(int, input().split()))
sm=[list(map(int, input().split())) for _ in range(m)]
k=min(ai)+min(bi)
for x in range(m):
l=ai[sm[x][0]-1]+bi[sm[x][1]-1]-sm[x][2]
k=min(k,l)
print(k)
| p02748 |
s = list(map(int, input().split(" ")))
a = s[0]
b = s[1]
m = s[2]
a_l = list(map(int, input().split(" ")))
b_l = list(map(int, input().split(" ")))
ans = a_l[0] + b_l[0]
for i in range(m):
x = list(map(int, input().split(" ")))
if ans > (a_l[x[0] - 1] + b_l[x[1] -1] - x[2]):
ans = a_l[x[0] -1] + b_l[x[1] -1] - x[2]
while len(a_l) > 0:
a_ = a_l.pop(0)
for v in b_l:
if ans > (a_ + v):
ans = a_ + v
print(ans) | s = list(map(int, input().split(" ")))
a = s[0]
b = s[1]
m = s[2]
a_l = list(map(int, input().split(" ")))
b_l = list(map(int, input().split(" ")))
ans = min(a_l) + min(b_l)
for i in range(m):
x = list(map(int, input().split(" ")))
if ans > (a_l[x[0] - 1] + b_l[x[1] -1] - x[2]):
ans = a_l[x[0] -1] + b_l[x[1] -1] - x[2]
print(ans) | p02748 |
A, B, M = list(map(int, input().split()))
a = [int(s) for s in input().split()]
b = [int(s) for s in input().split()]
m = []
for n in range(M):
m.append([int(s) for s in input().split()])
min = a[0] + b[0]
for i in range( len(a)):
for j in range(len(b)):
price = a[i] + b[j]
discountPrice = price
for k in range(M):
if i + 1 in m[k] and j + 1 in m[k]:
discountPrice = price - m[k][2]
if min > discountPrice:
min = discountPrice
print(min)
| A, B, M = list(map(int, input().split()))
a = [int(s) for s in input().split()]
b = [int(s) for s in input().split()]
m = []
for n in range(M):
m.append([int(s) for s in input().split()])
minValue = min(a) + min(b)
for i in range(M):
discountPrice = a[m[i][0] - 1] + b[m[i][1] - 1] - m[i][2]
if discountPrice < minValue:
minValue = discountPrice
print(minValue)
| p02748 |
A,B,M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
m=[]
for i in range(M):
array = list(map(int, input().strip().split()))
m.append(array)
def hitachi02(a,b,m):
results=[]
for i in range(len(a)):
for j in range(len(b)):
for k in range(len(m)):
if i+1 == m[k][0] and j+1 == m[k][1]:
cal = a[i]+b[j]-m[k][2]
else:
cal = a[i]+b[j]
results.append(cal)
result=min(results)
return result
result=hitachi02(a,b,m)
print(result) | A,B,M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
m=[]
for i in range(M):
array = list(map(int, input().strip().split()))
m.append(array)
def hitachi02(a,b,m):
results=[]
cal01=min(a)+min(b)
for k in range(len(m)):
results.append(a[m[k][0]-1]+b[m[k][1]-1]-m[k][2])
cal02=min(results)
if cal01>=cal02:
return cal02
else:
return cal01
result=hitachi02(a,b,m)
print(result) | p02748 |
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
tickets = {}
for _ in range(M):
x, y, c = list(map(int, input().split()))
if (x, y) in tickets:
if tickets[(x, y)] < c:
tickets[(x, y)] = c
else:
tickets[(x, y)] = c
min_price = float("inf")
for i, price_a in enumerate(a, 1):
for j, price_b in enumerate(b, 1):
total_price = price_a + price_b
if (i, j) in tickets:
total_price -= tickets[(i, j)]
if min_price > total_price:
min_price = total_price
print(min_price) | A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
min_price = min(a) + min(b)
for _ in range(M):
x, y, c = list(map(int, input().split()))
discount_price = a[x-1] + b[y-1] - c
if min_price > discount_price:
min_price = discount_price
print(min_price)
| p02748 |
a, b, m = list(map(int,input().split()))
dr = list(map(int,input().split()))
wa = list(map(int,input().split()))
xyc = [list(map(int,input().split())) for i in range(m)]
low = 200001
for i in range(m):
f = xyc[i][0] - 1
d = xyc[i][1] - 1
if low >= dr[f]+wa[d]-xyc[i][2]:
low = dr[f]+wa[d]-xyc[i][2]
dr.sort()
wa.sort()
if low >= (dr[0] + wa[0]):
print((dr[0] + wa[0]))
else:
print(low) | a, b, m = list(map(int,input().split()))
al = list(map(int,input().split()))
bl = list(map(int,input().split()))
low = min(al)+min(bl)
x = [0] * m
y = [0] * m
c = [0] * m
for i in range(m):
x[i],y[i],c[i] = list(map(int, input().split()))
x[i] -= 1
y[i] -= 1
for i in range(m):
low = min(low,al[x[i]]+bl[y[i]]-c[i])
print(low) | p02748 |
A, B, M = list(map(int, input().split()))
a = list(input().split())
b = list(input().split())
l = []
n = []
for i in range(M):
x, y, c = list(map(int, input().split()))
l.append(int(a[x-1])+int(b[y-1])-c)
for k in range(A):
for m in range(B):
n.append(int(a[k])+int(b[m]))
print((min(min(l), min(n)))) | A, B, M = list(map(int, input().split()))
a = list(input().split())
b = list(input().split())
l = []
for i in range(M):
x, y, c = list(map(int, input().split()))
l.append(int(a[x-1])+int(b[y-1])-c)
l.sort()
n = int(min(a)) + int(min(b))
print((min(l[0], n))) | p02748 |
A, B, M = list(map(int,input().split()))
val_m = [[0] * 3 for i in range(M)]
val_a = list(map(int, input().split()))
val_b = list(map(int, input().split()))
for i in range(M):
val_m[i][0], val_m[i][1], val_m[i][2] = list(map(int, input().split()))
dis_val = []
for i in range(M):
dis_val.append(val_a[val_m[i][0]-1] + val_b[val_m[i][1]-1] - val_m[i][2])
val_a = list(set(val_a))
val_b = list(set(val_b))
sum_val = []
for i in range(len(val_a)):
for j in range(len(val_b)):
sum_val.append(val_a[i] + val_b[j])
sum_val.extend(dis_val)
sum_val.sort()
print((sum_val[0])) | A, B, M = list(map(int,input().split()))
val_m = [[0] * 3 for i in range(M)]
val_a = list(map(int, input().split()))
val_b = list(map(int, input().split()))
for i in range(M):
val_m[i][0], val_m[i][1], val_m[i][2] = list(map(int, input().split()))
dis_val = []
for i in range(M):
dis_val.append(val_a[val_m[i][0]-1] + val_b[val_m[i][1]-1] - val_m[i][2])
val_a = list(set(val_a))
val_b = list(set(val_b))
val_a.sort()
val_b.sort()
dis_val.sort()
sum_val = val_a[0] + val_b[0]
if(sum_val <= dis_val[0]):
print(sum_val)
else:
print((dis_val[0])) | p02748 |
import itertools
a,b,m = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
P = [list(map(int,input().split())) for i in range(m)]
x = []
y = []
#普通に足算する
p = itertools.product(A, B)
for v in p:
x.append(sum(v))
#min出す
xx = min(x)
#割引券使う
for i in range(m):
y.append(A[P[i][0]-1] + B[P[i][1]-1] - P[i][2])
#min出す
yy = min(y)
print((min(xx,yy)))
| import itertools
a,b,m = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
P = [list(map(int,input().split())) for i in range(m)]
y = []
#普通に足算する
aa = min(A)
bb = min(B)
xx =aa+bb
#割引券使う
for i in range(m):
y.append(A[P[i][0]-1] + B[P[i][1]-1] - P[i][2])
#min出す
yy = min(y)
print((min(xx,yy))) | p02748 |
import sys
def disscount(disscounts,x,y):
minDisscounts = 0
for i in disscounts:
if int(i[0]) == x and int(i[1]) == y:
if minDisscounts < int(i[2]):
minDisscounts = int(i[2])
return minDisscounts
counts = input().split()
colors = input().split()
hots = input().split()
disscounts = []
for i in range(int(counts[2])):
disscounts.append(input().split())
minPrice = sys.maxsize
for i in range(0, len(colors)):
for j in range(0, len(hots)):
colorPrice = int(colors[i])
hotPrice = int(hots[j])
price = colorPrice + hotPrice - disscount(disscounts, i + 1 , j + 1)
if price < minPrice:
minPrice = price
print((str(minPrice))) | import sys
counts = list(map(int,input().split()))
colors = list(map(int,input().split()))
hots = list(map(int,input().split()))
ticketCount = counts[2]
minPrice = sys.maxsize
# first. get disscount consider price
for i in range(ticketCount):
values = input().split()
x = int(values[0])
y = int(values[1])
dissPrice = int(values[2])
colorPrice = colors[x-1]
hotsPrice = hots[y-1]
validPrice = colorPrice + hotsPrice - dissPrice
if minPrice > validPrice:
minPrice = validPrice
max_color = min(colors)
max_color_idx = colors.index(max_color)
max_hots = min(hots)
max_hots_idx = hots.index(max_hots)
validPrice = max_color + max_hots
if minPrice > validPrice:
minPrice = validPrice
print((str(minPrice))) | p02748 |
A, B, M = [int(i) for i in input().split(" ")]
a = [int(i) for i in input().split(" ")]
b = [int(i) for i in input().split(" ")]
C = []
for i in range(M):
c = [int(i) for i in input().split(" ")]
C.append(c)
m = 1000000
for i in a:
for j in b:
cost = i + j
if m >= cost:
m = cost
for c in C:
cost = a[c[0] - 1] + b[c[1] - 1] - c[2]
if m >= cost:
m = cost
print(m) | A, B, M = [int(i) for i in input().split(" ")]
a = [int(i) for i in input().split(" ")]
b = [int(i) for i in input().split(" ")]
C = []
for i in range(M):
c = [int(i) for i in input().split(" ")]
C.append(c)
m = min(a) + min(b)
for c in C:
cost = a[c[0] - 1] + b[c[1] - 1] - c[2]
if m >= cost:
m = cost
print(m) | p02748 |
A,B,M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
z = []
x = []
y = []
c = []
for i in range(M):
z.append(list(map(int, input().split())))
x.append(z[i][0])
y.append(z[i][1])
c.append(z[i][2])
mi = min(a) + min(b)
for i in range(M):
if a[x[i]-1] + b[y[i]-1] - c[i] < mi:
mi = a[x[i]-1] + b[y[i]-1] - c[i]
print(mi) | a,b,m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
x = []
for i in range(m):
x.append(list(map(int, input().split())))
min_a = min(a)
min_b = min(b)
money = min_a + min_b
for i in range(m):
kingaku = a[x[i][0]-1] + b[x[i][1]-1] - x[i][2]
if kingaku < money:
money = kingaku
print(money) | p02748 |
a, b, m = list(map(int, input().split()))
ref = list(map(int, input().split()))
micro = list(map(int, input().split()))
tk = [list(map(int, input().split())) for i in range(m)]
mini = 10 ** 6
for i in range(a):
for j in range(b):
s = ref[i] + micro[j]
if s < mini:
mini = s
amount = 10 ** 6
for i in tk:
if ref[i[0]-1] + micro[i[1]-1] - i[2] < amount:
amount = ref[i[0]-1] + micro[i[1]-1] - i[2]
print((min(mini, amount)))
| a, b, m = list(map(int, input().split()))
ref = list(map(int, input().split()))
micro = list(map(int, input().split()))
tk = [list(map(int, input().split())) for i in range(m)]
mini = min(ref) + min(micro)
amount = 10 ** 6
for i in tk:
if ref[i[0]-1] + micro[i[1]-1] - i[2] < amount:
amount = ref[i[0]-1] + micro[i[1]-1] - i[2]
print((min(mini, amount))) | p02748 |
As, Bs, Ms = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mm = [[0 for i in range(Bs)] for j in range(As)]
for i in range(Ms):
a, b, c = list(map(int, input().split()))
if c > mm[a-1][b-1]:
mm[a-1][b-1] = c
ans = 1000000
for i,a in enumerate(A):
for j,b in enumerate(B):
if ans > a+b-mm[i][j]:
ans = a+b-mm[i][j]
print(ans) | As, Bs, Ms = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
bas = min(A) + min(B)
ans = bas
for i in range(Ms):
a, b, c = list(map(int, input().split()))
if A[a-1]+B[b-1]-c < ans:
ans = A[a-1]+B[b-1]-c
print(ans) | p02748 |
import itertools
A, B, M = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
x = [0] * M
y = [0] * M
c = [0] * M
ans = []
for i in range(M):
x[i], y[i], c[i] = [int(k) for k in input().split()]
temp = list(itertools.product(a, b))
for i,j in temp:
ans.append(i+j)
for i in range(M):
ans.append(a[x[i]-1] + b[y[i]-1] - c[i])
print((min(ans))) | import itertools
A, B, M = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
x = [0] * M
y = [0] * M
c = [0] * M
ans = []
for i in range(M):
x[i], y[i], c[i] = [int(k) for k in input().split()]
for i in range(M):
ans.append(a[x[i]-1] + b[y[i]-1] - c[i])
a = set(a)
b = set(b)
temp = list(itertools.product(a, b))
for i,j in temp:
ans.append(i+j)
print((min(ans))) | p02748 |
import itertools
A, B, M = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
x = [0] * M
y = [0] * M
c = [0] * M
ans = []
for i in range(M):
x[i], y[i], c[i] = [int(k) for k in input().split()]
ans.append(a[x[i] - 1] + b[y[i] - 1] - c[i])
a = set(a)
b = set(b)
temp = list(itertools.product(a, b))
for i,j in temp:
ans.append(i+j)
print((min(ans))) | A, B, M = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
x = [0] * M
y = [0] * M
c = [0] * M
ans = []
ans.append(min(a) + min(b))
for i in range(M):
x[i], y[i], c[i] = [int(k) for k in input().split()]
for i in range(M):
ans.append(a[x[i] - 1] + b[y[i] - 1] - c[i])
print((min(ans))) | p02748 |
a,b,m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
xyc = [list(map(int,input().split())) for _ in range(m)]
yes_m = a[xyc[0][0]-1]+b[xyc[0][1]-1] - xyc[0][2]
for i in range(1,m):
if yes_m > a[xyc[i][0]-1]+b[xyc[i][1]-1] - xyc[i][2]:
yes_m = a[xyc[i][0]-1]+b[xyc[i][1]-1] - xyc[i][2]
no_m = min(a)+min(b)
print((min(no_m,yes_m)))
| a,b,m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = min(a)+min(b)
for i in range(m):
x,y,c = list(map(int, input().split()))
ans = min(ans, a[x-1]+b[y-1]-c)
print(ans)
| p02748 |
import itertools
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
m = {}
for _ in range(M):
x, y, z = list(map(int, input().split()))
key = str(x) + "&" + str(y)
if key in list(m.keys()):
if m[key] < z:
m[key] = z
else:
m[key] = z
A_B = list(itertools.product(list(range(1, A + 1)), list(range(1, B + 1))))
A_B_sum = list([x[0] + x[1] for x in (itertools.product(a, b))])
for i in range(len(A_B)):
# print(str(A_B[i][0]) + "&" + str(A_B[i][1]))
if str(A_B[i][0]) + "&" + str(A_B[i][1]) in list(m.keys()):
# print(str(A_B[i][0]) + "&" + str(A_B[i][1]))
A_B_sum[i] -= m[str(A_B[i][0]) + "&" + str(A_B[i][1])]
print((min(A_B_sum))) | A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
min_a = min(a)
min_b = min(b)
ans = min_a + min_b
for _ in range(M):
i, j, c = list(map(int, input().split()))
ans = min(ans, a[i - 1] + b[j - 1] - c)
print(ans) | p02748 |
A,B,M=list(map(int, input().split()))
As=list(map(int, input().split()))
Bs=list(map(int, input().split()))
List=[]
for i in range(M):
List.append(list(map(int, input().split())))
ans=10000000000
for i in As:
for j in Bs:
ans=min(ans, i+j)
for l in List:
candidate=As[l[0]-1]+Bs[l[1]-1]-l[2]
ans = min(ans, candidate)
print(ans) | A,B,M=list(map(int, input().split()))
As=list(map(int, input().split()))
Bs=list(map(int, input().split()))
List=[]
for i in range(M):
List.append(list(map(int, input().split())))
ans=min(As)+min(Bs)
for l in List:
candidate=As[l[0]-1]+Bs[l[1]-1]-l[2]
ans = min(ans, candidate)
print(ans)
| p02748 |
A, B, M = list(map(int, input().split()))
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
m = []
for i in range(M):
x, y, z = list(map(int, input().split()))
m.append([x, y, z])
m.sort(reverse = True, key=lambda x: x[2])
for j in m[:min(len(a),len(b)+1)]:
if a[j[0]-1] + b[j[1]-1] - j[2] >= 0 and a[j[0]-1] + b[j[1]-1] - j[2] < min(a) + min(b):
print((a[j[0]-1] + b[j[1]-1] - j[2]))
exit()
print((min(a) + min(b))) | A, B, M = list(map(int, input().split()))
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
m = []
am = min(a)
bm = min(b)
for i in range(M):
x, y, z = list(map(int, input().split()))
m.append(a[x-1] + b[y-1] - z )
if am + bm > min(m):
print((min(m)))
else:
print((am + bm)) | p02748 |
A, B, M = list(map(int, input().split()))
# items
a = list(map(int, input().split()))
b = list(map(int, input().split()))
# discount
d = [list(map(int,input().split())) for i in range(M)]
list = []
for i in range(M):
if min(a) + min(b) > a[d[i][0] - 1] + b[d[i][1] - 1] - d[i][2]:
list.append(a[d[i][0] - 1] + b[d[i][1] - 1] - d[i][2])
if len(list) != 0:
print((min(list)))
else:
print((min(a) + min(b))) | A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
min = min(a) + min(b)
for i in range(M):
x, y, c = list(map(int, input().split()))
tmp = a[x - 1] + b[y - 1] - c
if min > tmp:
min = tmp
print(min) | p02748 |
# input
A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
x, y, c = [0] * M, [0] * M, [0] * M
for i in range(M):
x[i], y[i], c[i] = list(map(int, input().split()))
ans = float("inf")
for i in range(M):
ans = min(ans, a[x[i]-1] + b[y[i]-1] - c[i])
for i in range(A):
for j in range(B):
ans = min(ans, a[i] + b[j])
print(ans)
| A, B, M = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
ans = min(a) + min(b)
for i in range(M):
x, y, c = list(map(int, input().split()))
ans = min(ans, a[x-1] + b[y-1] - c)
print(ans)
| p02748 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.