input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import time
import random
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
#sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
a=sorted([random.randint(0,5) for _ in range(n)])[::-1]
return n,a
show_flg=False
show_flg=True
h,w=LI()
ans=0
a=[[0]*(1+w)]
b=[[0]*(1+w)]
for i in range(h):
a.append([0]+LI())
for i in range(h):
b.append([0]+LI())
dp=[[set() for i in range(w+1)]for j in range(h+1)]
dp[0][1].add(0)
for i in range(1,h+1):
for j in range(1,w+1):
d=a[i][j]-b[i][j]
for x in dp[i-1][j]:
dp[i][j].add(x+d)
dp[i][j].add(x-d)
for x in dp[i][j-1]:
dp[i][j].add(x+d)
dp[i][j].add(x-d)
ans=min([abs(i) for i in dp[h][w]])
print(ans)
| from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import time
import random
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def GI(V,E,Directed=False,index=0):
org_inp=[]
g=[[] for i in range(n)]
for i in range(E):
inp=LI()
org_inp.append(inp)
if index==0:
inp[0]-=1
inp[1]-=1
if len(inp)==2:
a,b=inp
g[a].append(b)
if not Directed:
g[b].append(a)
elif len(inp)==3:
a,b,c=inp
aa=(inp[0],inp[2])
bb=(inp[1],inp[2])
g[a].append(bb)
if not Directed:
g[b].append(aa)
return g,org_inp
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
#sys.setrecursionlimit(10**5)
input=lambda: sys.stdin.readline().rstrip()
def ran_input():
import random
n=random.randint(4,16)
a=sorted([random.randint(0,5) for _ in range(n)])[::-1]
return n,a
show_flg=False
show_flg=True
h,w=LI()
ans=0
a=[[0]*(1+w)]
b=[[0]*(1+w)]
for i in range(h):
a.append([0]+LI())
for i in range(h):
b.append([0]+LI())
dp=[[set() for i in range(w+1)]for j in range(h+1)]
dp[0][1].add(0)
for i in range(1,h+1):
for j in range(1,w+1):
d=a[i][j]-b[i][j]
for x in dp[i-1][j]:
if -7000<=x+d<=7000:dp[i][j].add(x+d)
if -7000<=x-d<=7000:dp[i][j].add(x-d)
for x in dp[i][j-1]:
if -7000<=x+d<=7000:dp[i][j].add(x+d)
if -7000<=x-d<=7000:dp[i][j].add(x-d)
ans=min([abs(i) for i in dp[h][w]])
print(ans)
| p02839 |
from collections import deque
from copy import copy
row, column = list(map(int, input().split()))
map1 = [list(map(int, input().split())) for _ in range(row)]
map2 = [list(map(int, input().split())) for _ in range(row)]
map_ = [[n1 - n2 for n1, n2 in zip(row1, row2)] for row1, row2 in zip(map1, map2)]
n = map_[0][0]
queue = deque([(0, 0, n), (0, 0, -n)])
ansque = deque()
def bfs(queue):
while True:
nextqueue = deque()
while queue:
posr, posc, n = queue.popleft()
if (posr, posc) == (row - 1, column - 1):
ansque.append(abs(n))
for dr, dc in zip([1, 0], [0, 1]):
nextr = posr + dr
nextc = posc + dc
if 0 <= nextr < row and 0 <= nextc < column:
nextn = map_[nextr][nextc]
nextqueue.append((nextr, nextc, n + nextn))
nextqueue.append((nextr, nextc, n - nextn))
if nextqueue:
queue = copy(nextqueue)
else:
return ansque
print((min(bfs(queue))))
| R, C = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(R)]
B = [list(map(int, input().split())) for _ in range(R)]
dp = [0] * C
dp[0] = s = 1 << 6400
for row_a, row_b in zip(A, B):
for i, (a, b) in enumerate(zip(row_a, row_b)):
d = abs(a - b)
if i > 0:
dp[i] |= dp[i - 1]
dp[i] = (dp[i] << d) | (dp[i] >> d)
g = dp[-1]
for i in range(6401):
if g & (s << i) or g & (s >> i):
print(i)
quit()
| p02839 |
def examE():
H, W = LI()
A = [LI() for _ in range(H)]
B = [LI() for _ in range(H)]
Diff = [[0] * W for _ in range(H)]
M = 0
for i in range(H):
for j in range(W):
m = abs(A[i][j] - B[i][j])
Diff[i][j] = m
M += m
dp = [[0] * (W + 1) for _ in range(H + 1)]
dp[0][0] |= (1 << Diff[H-1][W-1])
for i in range(H):
for j in range(W):
here = dp[i][j]
s = Diff[i][j]
ni = (here << s) | (here >> s)
ex = 0
#溢れる分
for k in range(1, s + 1):
if (here >> k) & 1:
ex |= (1 << (s - k))
dp[i + 1][j] |= (ni | ex)
dp[i][j + 1] |= (ni | ex)
# print(s,ni,here,ex,dp[i+1][j])
a = dp[H - 1][W - 1]
ans = 0
for k in range(M + 1):
if (a >> k) & 1:
ans = k
break
print(dp)
print(ans)
return
def examE2():
H, W = LI()
A = [LI() for _ in range(H)]
B = [LI() for _ in range(H)]
loop = 80*80+1
dp = [[False]*(loop) for _ in range(H*W)]
cur = abs(A[0][0] - B[0][0])
dp[0][cur] = True
for i in range(H):
for j in range(W):
for k in range(loop):
if dp[i*W+j][k]:
if i<H-1:
cur = abs(A[i+1][j] - B[i+1][j])
dp[(i+1)*W +j][abs(k - cur)] = True
if k+cur<loop:
dp[(i + 1) * W + j][k + cur] = True
if j<W-1:
cur = abs(A[i][j+1] - B[i][j+1])
dp[i*W+(j+1)][abs(k-cur)] = True
if k+cur<loop:
dp[i * W + (j + 1)][k + cur] = True
#print(dp[-1])
ans = inf
for i,f in enumerate(dp[H*W-1]):
if f:
ans = i
break
print(ans)
return
import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
alphabet = [chr(ord('a') + i) for i in range(26)]
if __name__ == '__main__':
examE2()
| def examE():
H, W = LI()
A = [LI() for _ in range(H)]
B = [LI() for _ in range(H)]
Diff = [[0] * W for _ in range(H)]
M = 0
for i in range(H):
for j in range(W):
m = abs(A[i][j] - B[i][j])
Diff[i][j] = m
M += m
dp = [[0] * (W + 1) for _ in range(H + 1)]
dp[0][0] |= (1 << Diff[H-1][W-1])
for i in range(H):
for j in range(W):
here = dp[i][j]
s = Diff[i][j]
ni = (here << s) | (here >> s)
ex = 0
#溢れる分
for k in range(1, s + 1):
if (here >> k) & 1:
ex |= (1 << (s - k))
dp[i + 1][j] |= (ni | ex)
dp[i][j + 1] |= (ni | ex)
# print(s,ni,here,ex,dp[i+1][j])
a = dp[H - 1][W - 1]
ans = 0
for k in range(M + 1):
if (a >> k) & 1:
ans = k
break
print(dp)
print(ans)
return
def examE2():
H, W = LI()
A = [LI() for _ in range(H)]
B = [LI() for _ in range(H)]
dp = [0]*(H*W)
cur = abs(A[0][0] - B[0][0])
dp[0] |= (1 << cur)
for i in range(H):
for j in range(W):
now = dp[i*W + j]
if i < H - 1:
cur = abs(A[i + 1][j] - B[i + 1][j])
ni = (now << cur) | (now >> cur)
ex = 0
for k in range(1, cur + 1):
if (now >> k) & 1:
ex |= (1 << (cur - k))
dp[(i+1)*W +j] |= (ni | ex)
if j < W - 1:
cur = abs(A[i][j + 1] - B[i][j + 1])
ni = (now << cur) | (now >> cur)
ex = 0
for k in range(1, cur + 1):
if (now >> k) & 1:
ex |= (1 << (cur - k))
dp[i*W +j+1] |= (ni | ex)
#print(dp[-1])
ans = inf
for i,f in enumerate(str(bin(dp[-1]))[::-1]):
if f=="1":
ans = i
break
print(ans)
return
import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
alphabet = [chr(ord('a') + i) for i in range(26)]
if __name__ == '__main__':
examE2()
| p02839 |
import sys
input = sys.stdin.buffer.readline
from collections import deque
def main():
H,W = list(map(int,input().split()))
p = [[0 for _ in range(W)] for _ in range(H)]
point = [[[] for _ in range(W)] for _ in range(H)]
for i in range(H):
a = list(map(int,input().split()))
for j,num in enumerate(a):
p[i][j] += num
for i in range(H):
b = list(map(int,input().split()))
for j,num in enumerate(b):
p[i][j] -= num
point[0][0].append(p[0][0])
q = deque([(0,0)])
while q:
x,y = q.popleft()
dx,dy = [1,0],[0,1]
for i in range(2):
nx,ny = x+dx[i],y+dy[i]
if (0<=nx<H and 0<=ny<W):
for num in point[x][y]:
point[nx][ny].append(num+p[nx][ny])
point[nx][ny].append(num-p[nx][ny])
point[nx][ny] = list(set(point[nx][ny]))
q.append((nx,ny))
point[-1][-1].sort(key=lambda x:abs(x))
print((abs(point[-1][-1][0])))
if __name__ == "__main__":
main() | import sys
input = sys.stdin.buffer.readline
def main():
H,W = list(map(int,input().split()))
point = [[0]*W for _ in range(H)]
for i in range(H):
a = list(map(int,input().split()))
for j in range(W):
point[i][j] += a[j]
for i in range(H):
b = list(map(int,input().split()))
for j in range(W):
point[i][j] = abs(point[i][j]-b[j])
base = 3200
dp = [[0]*W for _ in range(H)]
dp[0][0] = (1 << (base+point[0][0])) | (1 << (base-point[0][0]))
for i in range(H):
for j in range(W):
if j < W-1:
dp[i][j+1] |= (dp[i][j] << point[i][j+1])
dp[i][j+1] |= (dp[i][j] >> point[i][j+1])
if i < H-1:
dp[i+1][j] |= (dp[i][j] << point[i+1][j])
dp[i+1][j] |= (dp[i][j] >> point[i+1][j])
ans = dp[-1][-1] >> base
for i in range(ans.bit_length()):
if (ans >> i)&1:
print(i)
exit()
if __name__ == "__main__":
main()
| p02839 |
import bisect
import copy
import heapq
import math
import sys
from collections import *
from functools import lru_cache
from itertools import accumulate, combinations, permutations, product
def input():
return sys.stdin.readline()[:-1]
def ruiseki(lst):
return [0]+list(accumulate(lst))
sys.setrecursionlimit(5000000)
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]
def main():
h,w=list(map(int,input().split()))
a=[list(map(int,input().split())) for i in range(h)]
b=[list(map(int,input().split())) for i in range(h)]
lst=[[0]*w for i in range(h)]
lst[0][0]={abs(a[0][0]-b[0][0]):1}
# print(lst)
d=deque([(0,0)])
while d:
now=d.popleft()
tmp=list(lst[now[0]][now[1]].keys())
if now[0]+1<h:
ab=abs(a[now[0]+1][now[1]]-b[now[0]+1][now[1]])
if lst[now[0]+1][now[1]]==0:
d.append((now[0]+1,now[1]))
lst[now[0]+1][now[1]]={}
for i in tmp:
if not i+ab in lst[now[0]+1][now[1]]:
lst[now[0]+1][now[1]][i+ab]=1
if not abs(i-ab) in lst[now[0]+1][now[1]]:
lst[now[0]+1][now[1]][abs(i-ab)]=1
# print(lst)
if now[1]+1<w:
ab=abs(a[now[0]][now[1]+1]-b[now[0]][now[1]+1])
if lst[now[0]][now[1]+1]==0:
d.append((now[0],now[1]+1))
lst[now[0]][now[1]+1]={}
for i in tmp:
if not i+ab in lst[now[0]][now[1]+1]:
lst[now[0]][now[1]+1][i+ab]=1
if not abs(i-ab) in lst[now[0]][now[1]+1]:
lst[now[0]][now[1]+1][abs(i-ab)]=1
# print(d)
# print(lst)
anslst=list(lst[-1][-1].keys())
for i in range(10**9):
if i in anslst:
print(i)
break
main() | import sys
input = sys.stdin.buffer.readline
h, w = list(map(int, input().split()))
AA = [list(map(int, input().split())) for _ in range(h)]
BB = [list(map(int, input().split())) for _ in range(h)]
kouho = [[0] * (w) for _ in range(h)]
delta = abs(AA[0][0] - BB[0][0])
kouho[0][0] |= 1 << delta
for y in range(h):
for x in range(w):
nx = x + 1
ny = y
if nx < w:
delta = abs(AA[ny][nx] - BB[ny][nx])
temp = 0
for i in range(1, delta + 1):
if (kouho[y][x] >> i) % 2:
temp |= 1 << (delta - i)
# print(x,y,kouho[y][x],temp,delta)
kouho[ny][nx] |= kouho[y][x] << delta
kouho[ny][nx] |= kouho[y][x] >> delta
kouho[ny][nx] |= temp
nx = x
ny = y + 1
if ny < h:
delta = abs(AA[ny][nx] - BB[ny][nx])
temp = 0
for i in range(1, delta + 1):
if (kouho[y][x] >> i) % 2:
temp |= 1 << (delta - i)
# print(x,y,kouho[y][x],temp,delta)
kouho[ny][nx] |= kouho[y][x] << delta
kouho[ny][nx] |= kouho[y][x] >> delta
kouho[ny][nx] |= temp
# print(kouho)
for i in range(81):
if (kouho[h - 1][w - 1] >> i) % 2:
print(i)
exit() | p02839 |
h,w = list(map(int,input().split()))
a = [list(map(int,input().split())) for i in range(h)]
b = [list(map(int,input().split())) for i in range(h)]
kanousei = [[[0] * (100 ** 3) for i in range(w)] for j in range(h)]
kanousei[0][0][abs(a[0][0]-b[0][0])] = 1
kanousei[0][0][abs(b[0][0]-a[0][0])] = 1
for RangeFromZero in range(1,h+w-1):
# print(RangeFromZero)
for x in range(RangeFromZero,-1,-1):
y = RangeFromZero-x
# print(x,y)
if x < w and y < h:
if 0 < x:
for i in range(100 ** 2):
if kanousei[y][x-1][i] == 1:
kanousei[y][x][i+abs(a[y][x]-b[y][x])] = 1
kanousei[y][x][abs(i-abs(a[y][x]-b[y][x]))] = 1
if 0 < y:
for i in range(100 ** 2):
if kanousei[y-1][x][i] == 1:
kanousei[y][x][i+abs(a[y][x]-b[y][x])] = 1
kanousei[y][x][abs(i-abs(a[y][x]-b[y][x]))] = 1
print((kanousei[h-1][w-1].index(1))) | h,w = list(map(int,input().split()))
a = [list(map(int,input().split())) for i in range(h)]
b = [list(map(int,input().split())) for i in range(h)]
kanousei = [[[0] * (100 ** 2) for i in range(w)] for j in range(h)]
kanousei[0][0][abs(a[0][0]-b[0][0])] = 1
kanousei[0][0][abs(b[0][0]-a[0][0])] = 1
for RangeFromZero in range(1,h+w-1):
# print(RangeFromZero)
for x in range(RangeFromZero,-1,-1):
y = RangeFromZero-x
# print(x,y)
if x < w and y < h:
if 0 < x:
for i in range(100 ** 2):
if kanousei[y][x-1][i] == 1:
kanousei[y][x][i+abs(a[y][x]-b[y][x])] = 1
kanousei[y][x][abs(i-abs(a[y][x]-b[y][x]))] = 1
if 0 < y:
for i in range(100 ** 2):
if kanousei[y-1][x][i] == 1:
kanousei[y][x][i+abs(a[y][x]-b[y][x])] = 1
kanousei[y][x][abs(i-abs(a[y][x]-b[y][x]))] = 1
print((kanousei[h-1][w-1].index(1))) | p02839 |
import sys
input = sys.stdin.buffer.readline
h, w = list(map(int, input().split()))
grid = [None for _ in range(h)]
poss = [[set() for x in range(w)] for y in range(h)]
tmp = [list(map(int, input().split())) for _ in range(h * 2)]
for i, (l1, l2) in enumerate(zip(tmp, tmp[h:])):
grid[i] = [abs(x - y) for x, y in zip(l1, l2)]
poss[0][0].add(-grid[0][0])
poss[0][0].add(grid[0][0])
for i in range(h):
for j in range(w - 1):
for c in poss[i][j]:
m = grid[i][j + 1]
poss[i][j + 1].add(c - m)
poss[i][j + 1].add(c + m)
if i == h - 1:
break
for j in range(w):
for c in poss[i][j]:
m = grid[i + 1][j]
poss[i + 1][j].add(c - m)
poss[i + 1][j].add(c + m)
print((min(abs(x) for x in poss[-1][-1]))) | import sys
input = sys.stdin.buffer.readline
h, w = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(h)]
b = [list(map(int, input().split())) for _ in range(h)]
g = [list(abs(x - y) for x, y in zip(l1, l2)) for l1, l2 in zip(a, b)]
poss = [[0] * w for _ in range(h)]
poss[0][0] |= 1 << 6400 + g[0][0]
poss[0][0] |= 1 << 6400 - g[0][0]
for i in range(h):
for j in range(w - 1):
poss[i][j + 1] |= poss[i][j] << g[i][j + 1]
poss[i][j + 1] |= poss[i][j] >> g[i][j + 1]
if i != h - 1:
for j in range(w):
poss[i + 1][j] |= poss[i][j] << g[i + 1][j]
poss[i + 1][j] |= poss[i][j] >> g[i + 1][j]
res = poss[-1][-1]
for i in range(6400):
if res & (1 << 6400 + i) or res & (1 << 6400 - i):
print(i)
exit()
| p02839 |
import sys
input = sys.stdin.buffer.readline
h, w = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(h)]
b = [list(map(int, input().split())) for _ in range(h)]
g = [list(abs(x - y) for x, y in zip(l1, l2)) for l1, l2 in zip(a, b)]
poss = [[0] * w for _ in range(h)]
poss[0][0] |= 1 << 6400 + g[0][0]
poss[0][0] |= 1 << 6400 - g[0][0]
for i in range(h):
for j in range(w - 1):
poss[i][j + 1] |= poss[i][j] << g[i][j + 1]
poss[i][j + 1] |= poss[i][j] >> g[i][j + 1]
if i != h - 1:
for j in range(w):
poss[i + 1][j] |= poss[i][j] << g[i + 1][j]
poss[i + 1][j] |= poss[i][j] >> g[i + 1][j]
res = poss[-1][-1]
for i in range(6400):
if res & (1 << 6400 + i) or res & (1 << 6400 - i):
print(i)
exit()
| import sys
input = sys.stdin.readline
def main():
h, w = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(h)]
b = [list(map(int, input().split())) for _ in range(h)]
g = [list(abs(x - y) for x, y in zip(l1, l2)) for l1, l2 in zip(a, b)]
poss = [0] * w
poss[0] |= 1 << 6400 + g[0][0]
poss[0] |= 1 << 6400 - g[0][0]
for i in range(h):
for j in range(w):
if j < w - 1:
d = g[i][j + 1]
poss[j + 1] |= poss[j] << d
poss[j + 1] |= poss[j] >> d
if i < h - 1:
d = g[i + 1][j]
poss[j] = poss[j] << d | poss[j] >> d
res = poss[-1]
for i in range(6400):
if res & (1 << 6400 + i) or res & (1 << 6400 - i):
print(i)
exit()
if __name__ == "__main__":
main() | p02839 |
import sys
input = sys.stdin.readline
def main():
H, W = list(map(int, input().split()))
P = W+1
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
L = 80*80
dp = [[False]*(L+1) for _ in range((W+1)*(H+1))]
for h in range(H+1):
dp[h*P][0] = True
for w in range(H+1):
dp[w][0] = True
for h in range(H):
for w in range(W):
c = abs(A[h][w] - B[h][w])
for l in range(L+1):
b1 = abs(l-c)
b2 = abs(l+c)
if b1 <= L:
dp[(h+1)*P+w+1][l] = dp[h*P+w+1][b1] or dp[(h+1)*P+w][b1]
if b2 <= L:
dp[(h+1)*P+w+1][l] = dp[(h+1)*P+w+1][l] or dp[h*P+w+1][b2] or dp[(h+1)*P+w][b2]
for l in range(L+1):
if dp[H*P+W][l]:
print(l)
break
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
def main():
H, W = list(map(int, input().split()))
P = W+1
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
L = 80*80
dp = [[False]*(L+1) for _ in range((W+1)*(H+1))]
dp[P+1][abs(A[0][0]-B[0][0])] = True
for h in range(H):
for w in range(W):
if h == 0 and w == 0: continue
c = abs(A[h][w] - B[h][w])
for l in range(L-c+1):
b1 = abs(l-c)
b2 = abs(l+c)
dp[(h+1)*P+w+1][l] = dp[h*P+w+1][b1] or dp[(h+1)*P+w][b1] or dp[h*P+w+1][b2] or dp[(h+1)*P+w][b2]
for l in range(L+1):
if dp[H*P+W][l]:
print(l)
break
if __name__ == "__main__":
main() | p02839 |
h,w = list(map(int,input().split()))
al = []
for _ in range(h):
a = list(map(int,input().split()))
al.append(a)
bl = []
for _ in range(h):
b = list(map(int,input().split()))
bl.append(b)
abl = [[0 for _ in range(w)] for _ in range(h)]
for i in range(h):
for j in range(w):
abl[i][j] = al[i][j] - bl[i][j]
from collections import defaultdict
dic = [[[0 for i in range(12801)] for _ in range(w)] for _ in range(h)]
dic[0][0][abl[i][j] + 6400] = 1
dic[0][0][-abl[i][j]+ 6400] = 1
for i in range(h):
for j in range(w):
for v, t in enumerate(dic[i][j]):
if t == 1:
if j + 1 < w:
if 0 <= v+abl[i][j+1] <= 12800:
dic[i][j+1][v+abl[i][j+1]] = 1
if 0 <= v-abl[i][j+1] <= 12800:
dic[i][j+1][v-abl[i][j+1]] = 1
if i + 1 < h:
if 0 <=v+abl[i+1][j] <= 12800:
dic[i+1][j][v+abl[i+1][j]] = 1
if 0 <= v-abl[i+1][j] <= 12800:
dic[i+1][j][v-abl[i+1][j]] = 1
ans = float("inf")
for idx,i in enumerate(dic[-1][-1]):
if i == 1:
ans = min(ans, abs(idx-6401))
print(ans)
| h,w = list(map(int,input().split()))
bitdp = [[0 for j in range(w)] for i in range(h)]
al = []
bl = []
for _ in range(h):
a = list(map(int,input().split()))
al.append(a)
for _ in range(h):
b = list(map(int,input().split()))
bl.append(b)
abl = [[] for i in range(h)]
for i in range(h):
for j in range(w):
abl[i].append(abs(al[i][j] - bl[i][j]))
bitdp[0][0] = 1 << h*w+abl[0][0]
for i in range(h):
for j in range(w):
if j != w-1:
bitdp[i][j+1] |= bitdp[i][j] << abl[i][j+1] | bitdp[i][j] >> abl[i][j+1]
if i != h-1:
bitdp[i+1][j] |= bitdp[i][j] << abl[i+1][j] | bitdp[i][j] >> abl[i+1][j]
ans = []
for i in range(h*w*2+1):
if (bitdp[-1][-1] >> i & 1):
ans.append(abs(h*w-i))
print((min(ans))) | p02839 |
import sys
input = sys.stdin.readline
H,W=list(map(int,input().split()))
A=[list(map(int,input().split())) for i in range(H)]
B=[list(map(int,input().split())) for i in range(H)]
SA=[[0]*W for i in range(H)]
for i in range(H):
for j in range(W):
SA[i][j]=abs(A[i][j]-B[i][j])
DP=[[0 for i in range(W)] for i in range(H)]
DP[0][0]=1<<SA[0][0]
def next(i,j):
RET=[]
if i+j<=6400:
RET.append(i+j)
if abs(i-j)<=6400:
RET.append(abs(i-j))
return RET
for i in range(H):
for j in range(W):
for k in range(6400):
if 1<<k & DP[i][j]==0:
continue
if i+1<H:
for r in next(k,SA[i+1][j]):
DP[i+1][j]|=1<<r
if j+1<W:
for r in next(k,SA[i][j+1]):
DP[i][j+1]|=1<<r
for i in range(6401):
if 1<<i & DP[-1][-1]!=0:
print(i)
break
| import sys
input = sys.stdin.readline
H,W=list(map(int,input().split()))
A=[list(map(int,input().split())) for i in range(H)]
B=[list(map(int,input().split())) for i in range(H)]
SA=[[0]*W for i in range(H)]
for i in range(H):
for j in range(W):
SA[i][j]=abs(A[i][j]-B[i][j])
DP=[[0 for i in range(W)] for j in range(H)]
DP[0][0]=1<<(H+W)*80+SA[0][0]
for i in range(H):
for j in range(W):
tempbit=DP[i][j]
if i+1<H:
DP[i+1][j]|=tempbit<<SA[i+1][j]
DP[i+1][j]|=tempbit>>SA[i+1][j]
if j+1<W:
DP[i][j+1]|=tempbit<<SA[i][j+1]
DP[i][j+1]|=tempbit>>SA[i][j+1]
ANS=1<<30
for i in range((H+W)*160+1):
if 1<<i & DP[-1][-1]!=0:
ANS=min(ANS,abs(i-(H+W)*80))
print(ANS)
| p02839 |
import sys
def main():
input = sys.stdin.readline
h, w = list(map(int, input().split()))
A = []
AB = []
for i in range(h):
row = list(map(int, input().split()))
A.append(row)
for i in range(h):
row = [abs(A[i][j] - int(b)) for j, b in enumerate(input().split())]
AB.append(row)
dp = [[set([]) for j in range(w+1)] for i in range(h+1)]
dp[0][0].add(AB[0][0])
for i in range(h):
for j in range(w):
dif1 = 0
dif2 = 0
if j < w - 1:
dif1 = AB[i][j+1]
if i < h - 1:
dif2 = AB[i+1][j]
for item in dp[i][j]:
if j < w - 1:
dp[i][j+1].add(item+dif1)
dp[i][j+1].add(abs(item-dif1))
if i < h - 1:
dp[i+1][j].add(item+dif2)
dp[i+1][j].add(abs(item-dif2))
print((min(dp[h-1][w-1])))
if __name__ == '__main__':
main()
| import sys
def main():
input = sys.stdin.readline
h, w = list(map(int, input().split()))
A = []
AB = []
A_append = A.append
AB_append = AB.append
for i in range(h):
row = list(map(int, input().split()))
A_append(row)
for i in range(h):
row = [abs(A[i][j] - int(b)) for j, b in enumerate(input().split())]
AB_append(row)
dp_cur = [set([]) for _ in range(w)]
dp_cur[0].add(AB[0][0])
for i in range(h):
dp_next = [set([]) for _ in range(w)]
for j in range(w):
if j < w - 1:
add1 = dp_cur[j+1].add
dif1 = AB[i][j+1]
if i < h - 1:
add2 = dp_next[j].add
dif2 = AB[i+1][j]
for item in dp_cur[j]:
if j < w - 1:
add1(item+dif1)
add1(abs(item-dif1))
if i < h - 1:
add2(item+dif2)
add2(abs(item-dif2))
if i == h - 1:
break
dp_cur = dp_next
print((min(dp_cur[w-1])))
if __name__ == '__main__':
main()
| p02839 |
import sys
sys.setrecursionlimit(10**9)
INF=10**18
def input():
return sys.stdin.readline().rstrip()
def main():
H,W=list(map(int,input().split()))
A=[[] for _ in range(H)]
B=[[] for _ in range(H)]
C=[[0]*W for _ in range(H)]
for i in range(H):
A[i]=list(map(int,input().split()))
for i in range(H):
B[i]=list(map(int,input().split()))
for i in range(H):
for j in range(W):
C[i][j]=abs(A[i][j]-B[i][j])
C_sum=sum([sum(C[i]) for i in range(H)])
dp=[[[False]*(C_sum*2+1) for _ in range(W)] for _ in range(H)]
dp[0][0][C[0][0]]=True
dp[0][0][-C[0][0]]=True
for i in range(1,H):
for k in range(C_sum*2+1):
if dp[i-1][0][k]==True:
dp[i][0][(k+C[i][0])%(C_sum*2+1)]=True
dp[i][0][k-C[i][0]]=True
for j in range(1,W):
for k in range(C_sum*2+1):
if dp[0][j-1][k]==True:
dp[0][j][(k+C[0][j])%(C_sum*2+1)]=True
dp[0][j][k-C[0][j]]=True
for i in range(1,H):
for j in range(1,W):
for k in range(C_sum*2+1):
if dp[i-1][j][k]==True:
dp[i][j][(k+C[i][j])%(C_sum*2+1)]=True
dp[i][j][k-C[i][j]]=True
if dp[i][j-1][k]==True:
dp[i][j][(k+C[i][j])%(C_sum*2+1)]=True
dp[i][j][k-C[i][j]]=True
for i in range(C_sum+1):
if dp[H-1][W-1][i]==True:
print(i)
exit()
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(10**9)
INF = 10**18
def input():
return sys.stdin.readline().rstrip()
def main():
H, W = list(map(int, input().split()))
A = [[] for _ in range(H)]
B = [[] for _ in range(H)]
C = [[0] * W for _ in range(H)]
minusdigit = 80 * 80 * 2
for i in range(H):
A[i] = list(map(int, input().split()))
for i in range(H):
B[i] = list(map(int, input().split()))
for i in range(H):
for j in range(W):
C[i][j] = abs(A[i][j] - B[i][j])
dp = [[0] * W for _ in range(H)]
dp[0][0] = ((1 << minusdigit) << C[0][0]) | ((1 << minusdigit) >> C[0][0])
for i in range(1, H):
dp[i][0] = (dp[i - 1][0] << C[i][0]) | (dp[i - 1][0] >> C[i][0])
for j in range(1, W):
dp[0][j] = (dp[0][j - 1] << C[0][j]) | (dp[0][j - 1] >> C[0][j])
for i in range(1, H):
for j in range(1, W):
dp[i][j] = (dp[i - 1][j] << C[i][j]) | (dp[i - 1][j] >> C[i][j]) | (dp[i][j - 1] << C[i][j]) | (dp[i][j - 1] >> C[i][j])
ans = dp[H - 1][W - 1]
for i in range(len(bin(ans)) - (2 + minusdigit)):
if (ans >> (i + minusdigit)) & 0b1 == 1 or (-i + minusdigit >= 0 and (ans >> (-i + minusdigit)) & 0b1 == 1):
print(i)
exit()
if __name__ == '__main__':
main()
| p02839 |
#!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect,copy
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**7)
inf = float('inf')
mod = 10**9+7
ans = inf ;count = 0 ;pro = 1
h,w=list(map(int,input().split()))
A=[list(map(int,input().split())) for i in range(h)]
B=[list(map(int,input().split())) for i in range(h)]
a=[set() for j in range(w)]
dp=[copy.deepcopy(a) for i in range(h)]
# for di in dp:
# print(*dp)
# dp[0][0]=set()
dp[0][0].add(abs(A[0][0]-B[0][0]))
# print(dp)
# for di in dp:
# print(*dp)
for i in range(h):
for j in range(w):
# dp[i][j]=set()
d=abs(A[i][j]-B[i][j])
if i-1>=0:
for si in dp[i-1][j]:
dp[i][j].add(si+d)
dp[i][j].add(abs(si-d))
# print(dp[i][j])
if j-1>=0:
for si in dp[i][j-1]:
dp[i][j].add(si+d)
dp[i][j].add(abs(si-d))
# print(dp[i][j])
ans=min(dp[h-1][w-1])
print(ans)
# for di in dp:
# print(di)
| #!/usr/bin/env python3
import sys, math, itertools, heapq, collections, bisect,copy
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
sys.setrecursionlimit(10**7)
inf = float('inf')
mod = 10**9+7
ans = inf ;count = 0 ;pro = 1
h,w=list(map(int,input().split()))
A=[tuple(map(int,input().split())) for i in range(h)]
B=[tuple(map(int,input().split())) for i in range(h)]
a=[[] for j in range(w)]
dp=[copy.deepcopy(a) for i in range(h)]
dp[0][0].append(abs(A[0][0]-B[0][0]))
for i in range(h):
for j in range(w):
d=abs(A[i][j]-B[i][j])
if i-1>=0:
for si in dp[i-1][j]:
dp[i][j].append(si+d)
dp[i][j].append(abs(si-d))
if j-1>=0:
for si in dp[i][j-1]:
dp[i][j].append(si+d)
dp[i][j].append(abs(si-d))
ans=min(dp[h-1][w-1])
print(ans)
# for di in dp:
# print(di)
| p02839 |
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
Diff = [[False] * (W + 1) for _ in range(H + 1)]
M = 0
for i in range(H):
for j in range(W):
m = abs(A[i][j] - B[i][j])
Diff[i][j] = m
M += m
dp = [[[0] * (M + 1) for _ in range(W + 1)] for _ in range(H + 1)]
dp[0][0][Diff[0][0]] = 1
for i in range(0, H):
for j in range(0, W):
for k in range(M + 1):
if dp[i][j][k]:
dp[i + 1][j][k + Diff[i + 1][j]] |= True
dp[i + 1][j][abs(k - Diff[i + 1][j])] |= True
dp[i][j + 1][k + Diff[i][j + 1]] |= True
dp[i][j + 1][abs(k - Diff[i][j + 1])] |= True
for k in range(M + 1):
if dp[H - 1][W - 1][k] == 1:
ans = k
break
print(ans)
| H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
Diff = [[0] * (W + 1) for _ in range(H + 1)]
M = 0
for i in range(H):
for j in range(W):
m = abs(A[i][j] - B[i][j])
Diff[i][j] = m
M += m
dp = [[0] * (W + 1) for _ in range(H + 1)]
dp[0][0] |= (1 << Diff[i][j])
for i in range(0, H):
for j in range(0, W):
here = dp[i][j]
s = Diff[i][j]
ni = 0
nj = 0
ni |= (here << s)
nj |= (here << s)
ni |= (here >> s)
nj |= (here >> s)
ex = 0
for k in range(1, s + 1):
if (here >> k) & 1:
ex |= (1 << (s - k))
ni |= ex
nj |= ex
dp[i + 1][j] |= ni
dp[i][j + 1] |= nj
a = dp[H - 1][W - 1]
ans = 0
for k in range(M + 1):
if (a >> k) & 1:
ans = k
break
print(k)
| p02839 |
def main():
# import sys
# readline = sys.stdin.readline
# readlines = sys.stdin.readlines
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
M = 0
grid = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
m = abs(A[i][j] - B[i][j])
grid[i][j] = m
M = max(M, m)
L = (H + W) * M
dp = [[[0] * (L + 1) for _ in range(W)] for _ in range(H)]
dp[0][0][grid[0][0]] = 1
for i in range(H):
for j in range(W):
for k in range(L + 1):
if dp[i][j][k] == 1:
if i < H - 1:
nk = grid[i + 1][j]
dp[i + 1][j][k + nk] |= 1
dp[i + 1][j][abs(k - nk)] |= 1
if j < W - 1:
nk = grid[i][j + 1]
dp[i][j + 1][k + nk] |= 1
dp[i][j + 1][abs(k - nk)] |= 1
for k in range(L + 1):
if dp[-1][-1][k] == 1:
print(k)
break
if __name__ == "__main__":
main()
| def main():
# import sys
# readline = sys.stdin.readline
# readlines = sys.stdin.readlines
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
M = 0
grid = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
m = abs(A[i][j] - B[i][j])
grid[i][j] = m
M = max(M, m)
dp = [[0] * W for _ in range(H)]
dp[0][0] = (1 << grid[0][0])
for i in range(H):
for j in range(W):
here = dp[i][j]
if i < H - 1:
nk = grid[i + 1][j]
dp[i + 1][j] |= (here << nk) | (here >> nk)
for k in range(1, nk + 1):
if (here >> k) & 1:
dp[i + 1][j] |= (1 << (nk - k))
if j < W - 1:
nk = grid[i][j + 1]
dp[i][j + 1] |= (here << nk) | (here >> nk)
for k in range(1, nk + 1):
if (here >> k) & 1:
dp[i][j + 1] |= (1 << (nk - k))
k = dp[-1][-1]
ans = 0
while k > 0:
if k & 1:
print(ans)
break
k >>= 1
ans += 1
if __name__ == "__main__":
main()
| p02839 |
def main():
# import sys
# readline = sys.stdin.readline
# readlines = sys.stdin.readlines
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
M = 0
grid = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
m = abs(A[i][j] - B[i][j])
grid[i][j] = m
M = max(M, m)
dp = [[0] * W for _ in range(H)]
dp[0][0] = (1 << grid[0][0])
for i in range(H):
for j in range(W):
here = dp[i][j]
if i < H - 1:
nk = grid[i + 1][j]
dp[i + 1][j] |= (here << nk) | (here >> nk)
for k in range(1, nk + 1):
if (here >> k) & 1:
dp[i + 1][j] |= (1 << (nk - k))
if j < W - 1:
nk = grid[i][j + 1]
dp[i][j + 1] |= (here << nk) | (here >> nk)
for k in range(1, nk + 1):
if (here >> k) & 1:
dp[i][j + 1] |= (1 << (nk - k))
k = dp[-1][-1]
ans = 0
while k > 0:
if k & 1:
print(ans)
break
k >>= 1
ans += 1
if __name__ == "__main__":
main()
| def main():
# import sys
# readline = sys.stdin.readline
# readlines = sys.stdin.readlines
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
M = 0
grid = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
m = abs(A[i][j] - B[i][j])
grid[i][j] = m
M = max(M, m)
dp = [[0] * W for _ in range(H)]
dp[0][0] = (1 << 0)
for i in range(H):
for j in range(W):
here = dp[i][j]
k = grid[i][j]
dp[i][j] = (here << k) | (here >> k)
for l in range(1, k + 1):
if (here >> l) & 1:
dp[i][j] |= (1 << (k - l))
if i < H - 1:
dp[i + 1][j] |= dp[i][j]
if j < W - 1:
dp[i][j + 1] |= dp[i][j]
V = dp[-1][-1]
ans = 0
while V > 0:
if V & 1:
print(ans)
break
V >>= 1
ans += 1
if __name__ == "__main__":
main()
| p02839 |
e=enumerate
(h,w),*a=[list(map(int,t.split()))for t in open(0)]
dp=[0]*w
c=12800
for i,a in e(list(zip(a,a[h:]))):
for j,(x,y)in e(list(zip(*a))):
x=abs(x-y)
t=0
if j:t|=dp[j-1]<<x|dp[j-1]>>x
if i:t|=dp[j]<<x|dp[j]>>x
dp[j]=t if i+j else 2**c<<x
*a,=list(map(int,(bin(dp[w-1])[2:]).zfill(c-~c)))
print((min(i for i,(f,g)in e(list(zip(a[c:],a[c::-1])))if f+g))) | def main():
e=enumerate
(h,w),*a=[list(map(int,t.split()))for t in open(0)]
dp=[0]*w
c=12800
for i,a in e(list(zip(a,a[h:]))):
for j,(x,y)in e(list(zip(*a))):
x=abs(x-y)
t=0
if j:t|=dp[j-1]<<x|dp[j-1]>>x
if i:t|=dp[j]<<x|dp[j]>>x
dp[j]=t if i+j else 2**c<<x
*a,=list(map(int,(bin(dp[w-1])[2:]).zfill(c-~c)))
print(([i for i,(f,g)in e(list(zip(a[c:],a[c::-1])))if f+g][0]))
main() | p02839 |
def p_e():
h, w = list(map(int, input().split()))
t = [list(map(int, input().split())) for _ in range(h)]
m = 0
for i in range(h):
*b, = list(map(int, input().split()))
for j, e in enumerate(b):
t[i][j] = abs(t[i][j] - e)
if m < abs(t[i][j] - e):
m = abs(t[i][j] - e)
# dp[i][j][k]: (i,j)でkになるかどうかbool値
bool_width = 6400
dp = [[[False] * bool_width for _ in range(w)] for _ in range(h)]
for i in range(h):
for j in range(w):
if i == j == 0:
dp[i][j][t[i][j]] = True
continue
for k in range(bool_width):
if i > 0:
if abs(k + t[i][j]) < bool_width:
dp[i][j][k] |= dp[i - 1][j][abs(k + t[i][j])]
if abs(k - t[i][j]) < bool_width:
dp[i][j][k] |= dp[i - 1][j][abs(k - t[i][j])]
if j > 0:
if abs(k + t[i][j]) < bool_width:
dp[i][j][k] |= dp[i][j - 1][abs(k + t[i][j])]
if abs(k - t[i][j]) < bool_width:
dp[i][j][k] |= dp[i][j - 1][abs(k - t[i][j])]
for i, e in enumerate(dp[-1][-1]):
if e:
print(i)
break
p_e() | def p_e():
from itertools import product
h, w = list(map(int, input().split()))
t1 = [list(map(int, input().split())) for _ in range(h)]
t2 = [list(map(int, input().split())) for _ in range(h)]
# pythonでbitsetを用いる->boolのDPで2進数の1をTrue, 0をFalseとして扱う
# 右にxシフト = その値にx足した値 (10001)<<4 -> (100010000)
m = 160 * 80
dp = [[0] * w for _ in range(h)]
dp[0][0] = 1 << m
for i, j in product(list(range(h)), list(range(w))):
v = abs(t1[i][j] - t2[i][j])
if i > 0:
dp[i][j] |= dp[i - 1][j]
if j > 0:
dp[i][j] |= dp[i][j - 1]
dp[i][j] = (dp[i][j] << v) | (dp[i][j] >> v)
ans = m
for i in range(m * 2):
if dp[h - 1][w - 1] & (1 << i) > 0:
ans = min(ans, abs(m - i))
print(ans)
p_e() | p02839 |
def p_e():
from itertools import product
h, w = list(map(int, input().split()))
t1 = [list(map(int, input().split())) for _ in range(h)]
t2 = [list(map(int, input().split())) for _ in range(h)]
# pythonでbitsetを用いる->boolのDPで2進数の1をTrue, 0をFalseとして扱う
# 右にxシフト = その値にx足した値 (10001)<<4 -> (100010000)
m = 160 * 80
dp = [[0] * w for _ in range(h)]
dp[0][0] = 1 << m
for i, j in product(list(range(h)), list(range(w))):
v = abs(t1[i][j] - t2[i][j])
if i > 0:
dp[i][j] |= dp[i - 1][j]
if j > 0:
dp[i][j] |= dp[i][j - 1]
dp[i][j] = (dp[i][j] << v) | (dp[i][j] >> v)
ans = m
for i in range(m * 2):
if dp[h - 1][w - 1] & (1 << i) > 0:
ans = min(ans, abs(m - i))
print(ans)
p_e() | def p_e():
h, w = list(map(int, input().split()))
t1 = [list(map(int, input().split())) for _ in range(h)]
t2 = [list(map(int, input().split())) for _ in range(h)]
# pythonでbitsetを用いる->boolのDPで2進数の1をTrue, 0をFalseとして扱う
# 右にxシフト = その値にx足した値 (10001)<<4 -> (100010000)
m = 160 * 80
dp = [[0] * w for _ in range(h)]
dp[0][0] = 1 << m
for i in range(h):
for j in range(w):
v = abs(t1[i][j] - t2[i][j])
if i > 0:
dp[i][j] |= dp[i - 1][j]
if j > 0:
dp[i][j] |= dp[i][j - 1]
dp[i][j] = (dp[i][j] << v) | (dp[i][j] >> v)
ans = m
for i in range(m * 2):
if dp[h - 1][w - 1] & (1 << i) > 0:
ans = min(ans, abs(m - i))
print(ans)
p_e() | p02839 |
H,W = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(H)]
B = [list(map(int,input().split())) for i in range(H)]
C = [[] for i in range(H)]
for i,(arow,brow) in enumerate(zip(A,B)):
for a,b in zip(arow,brow):
d = abs(a-b)
C[i].append(d)
dp = [set() for i in range(W)]
dp[0].add(0)
for i,crow in enumerate(C):
dp2 = [set() for j in range(W)]
for j,(c,dpr) in enumerate(zip(C[i],dp)):
for d in dpr:
dp2[j].add(d+c)
dp2[j].add(d-c)
for j,c in enumerate(C[i]):
if j==0: continue
for d in dp2[j-1]:
dp2[j].add(d+c)
dp2[j].add(d-c)
dp = dp2
print((min(abs(a) for a in dp[-1]))) | H,W = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(H)]
B = [list(map(int,input().split())) for i in range(H)]
C = [[] for i in range(H)]
for i,(arow,brow) in enumerate(zip(A,B)):
for a,b in zip(arow,brow):
d = abs(a-b)
C[i].append(d)
ofs = (H+W)*100
dp = [0] * W
dp[0] = (1<<ofs)
for i,crow in enumerate(C):
dp2 = [0] * W
for j,(c,d) in enumerate(zip(C[i],dp)):
dp2[j] |= (d<<c)
dp2[j] |= (d>>c)
for j,c in enumerate(C[i]):
if j==0: continue
dp2[j] |= (dp2[j-1]<<c)
dp2[j] |= (dp2[j-1]>>c)
dp = dp2
ans = ofs
l = len(bin(dp[-1]))
for i in range(l):
if dp[-1] & (1<<i):
ans = min(ans, abs(i-ofs))
print(ans) | p02839 |
H,W = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(H)]
B = [list(map(int,input().split())) for i in range(H)]
C = [[] for i in range(H)]
for i,(arow,brow) in enumerate(zip(A,B)):
for a,b in zip(arow,brow):
d = abs(a-b)
C[i].append(d)
ofs = (H+W)*100
dp = [0] * W
dp[0] = (1<<ofs)
for i,crow in enumerate(C):
dp2 = [0] * W
for j,(c,d) in enumerate(zip(C[i],dp)):
dp2[j] |= (d<<c)
dp2[j] |= (d>>c)
for j,c in enumerate(C[i]):
if j==0: continue
dp2[j] |= (dp2[j-1]<<c)
dp2[j] |= (dp2[j-1]>>c)
dp = dp2
ans = ofs
l = len(bin(dp[-1]))
for i in range(l):
if dp[-1] & (1<<i):
ans = min(ans, abs(i-ofs))
print(ans) | H,W = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(H)]
B = [list(map(int,input().split())) for i in range(H)]
C = [[abs(a-b) for a,b in zip(arow,brow)] for arow,brow in zip(A,B)]
ofs = 80*(H+W)
dp = [[0]*W for _ in range(H)]
dp[0][0] = (1<<(ofs+C[0][0])) | (1<<(ofs-C[0][0]))
for i,crow in enumerate(C):
for j,c in enumerate(crow):
if i:
dp[i][j] = (dp[i-1][j]<<c) | (dp[i-1][j]>>c)
if j:
dp[i][j] |= ((dp[i][j-1]<<c) | (dp[i][j-1]>>c))
ans = ofs*2
for i in range(ofs*2):
if dp[-1][-1]&(1<<i):
ans = min(ans, abs(i-ofs))
print(ans) | p02839 |
def main():
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
C = [[0] * W for _ in range(H)]
for h in range(H):
for w in range(W):
C[h][w] = abs(A[h][w] - B[h][w])
dp = [[[0] * (80 * 80) for _ in range(W)] for _ in range(H)]
dh = [1,0]
dw = [0,1]
dp[0][0][C[0][0]] = 1
for h in range(H):
for w in range(W):
for i in range(80*80):
for j in range(2):
nh = h - dh[j]
nw = w - dw[j]
if 0 <= nh < H and 0 <= nw < W:
if abs(C[h][w] + i) < 6400:
dp[h][w][abs(C[h][w] + i)] |= dp[nh][nw][i]
if abs(C[h][w] - i) < 6400:
dp[h][w][abs(C[h][w] - i)] |= dp[nh][nw][i]
ans = float('inf')
for i in range(80*80):
if dp[H-1][W-1][i]:
ans = min(i, ans)
print(ans)
if __name__ == "__main__":
main() | def main():
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
C = [[0] * W for _ in range(H)]
for h in range(H):
for w in range(W):
C[h][w] = abs(A[h][w] - B[h][w])
dp = [[0 for _ in range(6400)] for _ in range(H*W)]
dp[0][C[0][0]] = 1
for d in range(H*W):
h, w = divmod(d, W)
for k in range(6400):
if not dp[h*W+w][k]:
continue
nh, nw = h+1, w+1
if nh < H:
if k + C[nh][w] < 6400:
dp[nh*W+w][k+C[nh][w]] = 1
dp[nh*W+w][abs(k-C[nh][w])] = 1
if nw < W:
if k + C[h][nw] < 6400:
dp[h*W+nw][k+C[h][nw]] = 1
dp[h*W+nw][abs(k-C[h][nw])] = 1
for k in range(6400):
if dp[-1][k]:
print(k)
exit()
if __name__ == "__main__":
main() | p02839 |
import sys
input=sys.stdin.readline
h, w = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(h)]
b = [list(map(int, input().split())) for _ in range(h)]
dp = [[[False for i in range(80 * h + 80 * w + 1)] for _ in range(1 + w)] for j in range(1 + h)]
# dp[i][j][k]=マスの(i,j)において絶対値をkにすることができるかどうか
dp[0][0][0] = True
dp[1][0][0] = True
dp[0][1][0] = True
# 初期値の設定
for i in range(1, h + 1):
for j in range(1, w + 1):
a_num = a[i - 1][j - 1]
b_num = b[i - 1][j - 1]
dif = a_num - b_num
if i == 1:
for k in range(80 * i + 80 * j - 79):
if dp[1][j - 1][abs(k - dif)] or dp[1][j - 1][abs(k + dif)]:
dp[1][j][abs(k)] = True
elif j == 1:
for k in range(80 * i + 80 * j - 79):
if dp[i - 1][1][abs(k - dif)] or dp[i - 1][1][abs(k + dif)]:
dp[i][1][k] = True
else:
for k in range(80 * i + 80 * j - 79):
if dp[i - 1][j][abs(k - dif)] or dp[i - 1][j][abs(k + dif)] or dp[i][j - 1][abs(k - dif)] or dp[i][j - 1][abs(k + dif)]:
dp[i][j][k] = True
ans = 0
for i in range(80 * h + 80 * w + 1):
if dp[h][w][i]:
ans = i
break
print(ans)
| # Atcoder Problem Solving
H,W=list(map(int,input().split()))
c=[list(map(int,input().split())) for i in range(H)]
b=[list(map(int,input().split())) for i in range(H)]
a=[[0 for i in range(W)] for j in range(H)]
for i in range(H):
for j in range(W):
a[i][j]=abs(c[i][j]-b[i][j])
dp=[[0 for i in range(W)] for j in range(H)]
# Bitset演算
# 答えは絶対値が絶対-80から80以内に収まる
X=3200
dp[0][0]= (1<<(X+a[0][0])) | (1<<(X-a[0][0]))
# 初期化の条件
for i in range(H):
for j in range(W):
if 0<=i<H and 0<=j+1<W:
dp[i][j+1]|=(dp[i][j]<<a[i][j+1])
dp[i][j+1]|=(dp[i][j]>>a[i][j+1])
if 0<=i+1<H and 0<=j<W:
dp[i+1][j]|=(dp[i][j]<<a[i+1][j])
dp[i+1][j]|=(dp[i][j]>>a[i+1][j])
A=str(bin(dp[H-1][W-1]))[::-1]
L=len(A)
ans=3200
for i in range(L):
if A[i]=="1":
ans=min(ans,abs(i-X))
print(ans) | p02839 |
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
arr = [set() for _ in range(W)]
arr[0].add(A[0][0] - B[0][0])
for x in range(1, W):
s = arr[x]
d = A[0][x] - B[0][x]
for n in arr[x-1]:
s.add(abs(n+d))
s.add(abs(n-d))
for y in range(1, H):
nextarr = [set() for _ in range(W)]
Ay = A[y]
By = B[y]
dh = H - y - 1
for x in range(W):
nextset = nextarr[x]
d = Ay[x] - By[x]
dw = W - x - 1
lim = (dh + dw + 1) * 160
#lim = 1280
if x >= 1:
arr[x] |= nextarr[x-1]
for n in arr[x]:
if abs(n+d) <= lim:
nextset.add(abs(n+d))
if abs(n-d) <= lim:
nextset.add(abs(n-d))
arr = nextarr
print((min([abs(d) for d in arr[-1]]))) | H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
arr = [set() for _ in range(W)]
arr[0].add(0)
for y in range(H):
nextarr = [set() for _ in range(W)]
Ay = A[y]
By = B[y]
dh = H - y - 1
for x in range(W):
nextset = nextarr[x]
d = Ay[x] - By[x]
dw = W - x - 1
lim = (dh + dw + 1) * 160
if x >= 1:
arr[x] |= nextarr[x-1]
for n in arr[x]:
if abs(n+d) <= lim:
nextset.add(abs(n+d))
if abs(n-d) <= lim:
nextset.add(abs(n-d))
arr = nextarr
print((min([abs(d) for d in arr[-1]]))) | p02839 |
h,w = list(map(int,input().split()))
A = []
for _ in range(h):
a = list(map(int,input().split()))
A.append(a)
B = []
for _ in range(h):
b = list(map(int,input().split()))
B.append(b)
g = [[0]*(w+1) for _ in range(h+1)]
m = 0
for i in range(1,h+1):
for j in range(1,w+1):
g[i][j] = abs(A[i-1][j-1]-B[i-1][j-1])
m = 80*(h+w-1)//2
dp = [[[False for _ in range(m+1)] for _ in range(w+1)] for _ in range(h+1)]
dp[1][1][g[1][1]] = True
for i in range(1,h+1):
for j in range(1,w+1):
for k in range(m+1):
if k + g[i][j]<m:
dp[i][j][k] = dp[i][j][k] or dp[i-1][j][abs(k-g[i][j])] or dp[i-1][j][k+g[i][j]] or dp[i][j-1][abs(k-g[i][j])] or dp[i][j-1][k+g[i][j]]
else:
dp[i][j][k] = dp[i][j][k] or dp[i-1][j][abs(k-g[i][j])] or dp[i][j-1][abs(k-g[i][j])]
for k in range(m+1):
if dp[-1][-1][k]:
print(k);exit()
| H, W = list(map(int, input().split()))
A = [None]*H
for i in range(H):
A[i] = list(map(int, input().split()))
B = [None]*H
for i in range(H):
B[i] = list(map(int, input().split()))
C = [[None]*W for _ in range(H)]
for i in range(H):
for j in range(W):
C[i][j] = abs(A[i][j]-B[i][j])
K = 80*(H+W-1)//2 + 1
dp = [[[0]*(K+1) for _ in range(W)] for _ in range(H)]# 答えから80*(H+W-1)を引く
dp[0][0][C[0][0]] = 1
for i in range(H):
for j in range(W):
for k in range(K+1):
if i and dp[i-1][j][k]:
if k+C[i][j] < K:
dp[i][j][k+C[i][j]] = 1
dp[i][j][abs(k-C[i][j])] = 1
if j and dp[i][j-1][k]:
if k+C[i][j] < K:
dp[i][j][k+C[i][j]] = 1
dp[i][j][abs(k-C[i][j])] = 1
for k in range(K+1):
res = dp[H-1][W-1][k]
if res:
print(k)
break
| p02839 |
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
h,w = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(h)]
b = [list(map(int, input().split())) for i in range(h)]
ma = 80*2*80
DP = [[[0]*ma for i in range(w)] for i in range(h)]
for i in range(h):
for j in range(w):
k = abs(a[i][j]-b[i][j])
if i==0 and j==0:
DP[i][j][k] = 1
else:
for l in range(ma-k):
DP[i][j][l] = DP[i][j-1][abs(l-k)] | DP[i][j-1][l+k] | DP[i-1][j][abs(l-k)] | DP[i-1][j][l+k]
for i in range(ma):
if DP[-1][-1][i]:
print(i)
exit() | import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
h,w = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(h)]
b = [list(map(int, input().split())) for i in range(h)]
ma = 80*2*80
DP = [[[0]*ma for i in range(w)] for i in range(h)]
for i in range(h):
for j in range(w):
k = abs(a[i][j]-b[i][j])
if i==0 and j==0:
DP[i][j][k] = 1
continue
elif i == 0:
up = min((i+j+1)*80+1, ma-k)
for l in range(up):
DP[i][j][l] = DP[i][j-1][abs(l-k)] | DP[i][j-1][l+k]
elif j == 0:
for l in range(up):
DP[i][j][l] = DP[i-1][j][abs(l-k)] | DP[i-1][j][l+k]
else:
for l in range(up):
DP[i][j][l] = DP[i][j-1][abs(l-k)] | DP[i][j-1][l+k] | DP[i-1][j][abs(l-k)] | DP[i-1][j][l+k]
for i in range(ma):
if DP[-1][-1][i]:
print(i)
exit()
| p02839 |
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
h,w = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(h)]
b = [list(map(int, input().split())) for i in range(h)]
ma = 80*2*80
DP = [[[0]*ma for i in range(w)] for i in range(h)]
for i in range(h):
for j in range(w):
k = abs(a[i][j]-b[i][j])
up = (i+j+1)*80+1
if i==0 and j==0:
DP[i][j][k] = 1
continue
elif i == 0:
for l in range(up):
DP[i][j][l] = DP[i][j-1][abs(l-k)] | DP[i][j-1][l+k]
elif j == 0:
for l in range(up):
DP[i][j][l] = DP[i-1][j][abs(l-k)] | DP[i-1][j][l+k]
else:
for l in range(up):
DP[i][j][l] = DP[i][j-1][abs(l-k)] | DP[i][j-1][l+k] | DP[i-1][j][abs(l-k)] | DP[i-1][j][l+k]
for i in range(ma):
if DP[-1][-1][i]:
print(i)
exit() | import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
h,w = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(h)]
b = [list(map(int, input().split())) for i in range(h)]
ma = 80*80+2
DP = [[[0]*ma for i in range(w)] for i in range(h)]
for i in range(h):
for j in range(w):
k = abs(a[i][j]-b[i][j])
if i==0 and j==0:
DP[i][j][k] = 1
continue
else:
up = min((i+j+1)*80+1, ma-k)
for l in range(up):
DP[i][j][l] = DP[i][j-1][abs(l-k)] | DP[i][j-1][l+k] | DP[i-1][j][abs(l-k)] | DP[i-1][j][l+k]
for i in range(ma):
if DP[-1][-1][i]:
print(i)
exit() | p02839 |
def x():
return list(map(int,input().split()))
v=list
c=abs
r=range
h,w=x()
p=v(r(h))
a=[v(x())for i in p]
b=[v(x())for i in p]
m=13120
D=[[[0]*m for i in r(w)]for i in p]
for i in p:
for j in r(w):
k=c(a[i][j]-b[i][j])
if i|j:
for l in r((i+j+1)*80+1):
e=c(l-k)
D[i][j][l]=D[i][j-1][e]|D[i][j-1][l+k]|D[i-1][j][e]|D[i-1][j][l+k]
else:
D[i][j][k]=1
print((D[-1][-1].index(1))) | h,w = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(h)]
b = [list(map(int, input().split())) for i in range(h)]
# zeroは真ん中にする
ma = 80*2*80
DP = [[0]*w for i in range(h)]
for i in range(h):
for j in range(w):
k = abs(a[i][j]-b[i][j])
if i|j:
m = DP[i-1][j]|DP[i][j-1]
else:
m = 1<<ma
DP[i][j] = (m<<k)|(m>>k)
k = 1<<ma
for i in range(ma):
if DP[-1][-1]&(k>>i) or DP[-1][-1]&(k<<i):
print(i)
exit() | p02839 |
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return list(map(int,input().split()))
def onem(): #Nとかの取得
return int(eval(input()))
def s(x): #圧縮
a = []
if len(x) == 0:
return []
aa = x[0]
su = 1
for i in range(len(x)-1):
if aa != x[i+1]:
a.append([aa,su])
aa = x[i+1]
su = 1
else:
su += 1
a.append([aa,su])
return a
def jo(x): #listをスペースごとに分ける
return " ".join(map(str,x))
def max2(x): #他のときもどうように作成可能
return max(list(map(max,x)))
def In(x,a): #aがリスト(sorted)
k = bs.bisect_left(a,x)
if k != len(a) and a[k] == x:
return True
else:
return False
mod = 10**9+7 #出力の制限
# a = cmb(n,r)
"""
def nibu(x,n,r):
ll = 0
rr = r
while True:
mid = (ll+rr)//2
if rr == mid:
return ll
if (ここに評価入れる):
rr = mid
else:
ll = mid+1
"""
def ans():
H,W = m()
a = []
for i in range(H):
a.append(l())
ma = 0
b = []
for i in range(H):
b.append(l())
for j in range(W):
ma = max(ma,abs(a[i][j]-b[i][j]))
ma += 1
dp = [[[0 for i in range(ma*(min(H,W)))]for j in range(W)] for k in range(H)]
for i in range(H):
for j in range(W):
po = abs(a[i][j] - b[i][j])
if i == 0 and j == 0:
dp[0][0][po] = 1
elif i == 0:
for k in range(ma*(min(H,W))):
if abs(k + po) < ma*min(H,W):
dp[i][j][abs(k + po)] = max(dp[i][j-1][k],dp[i][j][abs(k + po)])
if abs(k - po) < ma*min(H,W):
dp[i][j][abs(k - po)] = max(dp[i][j-1][k],dp[i][j][abs(k - po)])
elif j == 0:
for k in range(ma*(min(H,W))):
if abs(k + po) < ma*min(H,W):
dp[i][j][abs(k + po)] = max(dp[i-1][j][k],dp[i][j][abs(k + po)])
if abs(k - po) < ma*min(H,W):
dp[i][j][abs(k - po)] = max(dp[i-1][j][k],dp[i][j][abs(k - po)])
else:
for k in range(ma*(min(H,W))):
if abs(k + po) < ma*min(H,W):
dp[i][j][abs(k + po)] = max(dp[i][j-1][k],dp[i-1][j][k],dp[i][j][abs(k + po)])
if abs(k - po) < ma*min(H,W):
dp[i][j][abs(k - po)] = max(dp[i][j-1][k],dp[i-1][j][k],dp[i][j][abs(k - po)])
for i in range(ma*min(H,W)):
if dp[-1][-1][i] == 1:
print(i)
exit()
if __name__ == "__main__":
ans()
| import sys
input = sys.stdin.readline
h, w = list(map(int, input().split()))
inf = float('INF')
A = []
B = []
for i in range(h):
line = list(map(int, input().split()))
A.append(line)
for i in range(h):
line = list(map(int, input().split()))
B.append(line)
D = [[0]*w for i in range(h)]
for i in range(h):
for j in range(w):
D[i][j] = abs(A[i][j] - B[i][j])
def slide_down(y, x, possible):
new = set()
delta = D[y+1][x]
limit = (h+w) * 80
for num in possible:
if num + delta <= limit - (y+x)*80:
new.add(num+delta)
if abs(num-delta) <= limit - (y+x)*80:
new.add(abs(num-delta))
return new
def slide_right(y, x, possible):
new = set()
delta = D[y][x+1]
limit = (h+w) * 80
for num in possible:
if num + delta <= limit - (y+x)*80:
new.add(num+delta)
if abs(num-delta) <= limit - (y+x)*80:
new.add(abs(num-delta))
return new
DP = [[set() for j in range(w)] for i in range(h)]
DP[0][0] = {D[0][0]}
for row in range(h):
for col in range(w):
possible = DP[row][col]
if col < w-1:
new = slide_right(row, col, possible)
DP[row][col+1] |= new
if row < h-1:
new = slide_down(row, col, possible)
DP[row+1][col] |= new
ans = min(DP[h-1][w-1])
print(ans)
| p02839 |
import bisect
import collections
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(H)]
B = [list(map(int, input().split())) for i in range(H)]
q = collections.deque()
C = [[abs(A[i][j] - B[i][j]) for j in range(W)] for i in range(H)]
M = 0
for i in range(H):
for j in range(W):
M = max(C[i][j], M)
dp = [[[False]*((M*H*W) + 1) for j in range(W)] for i in range(H)]
for i in range(H):
for j in range(W):
if i == 0:
if j == 0:
dp[i][j][C[i][j]] = True
else:
for m in range(M+1):
if dp[i][j-1][m]:
dp[i][j][abs(m - C[i][j])] = True
dp[i][j][m+C[i][j]] = True
else:
if j != 0:
for m in range(M+1):
if dp[i][j-1][m]:
dp[i][j][abs(m - C[i][j])] = True
dp[i][j][m+C[i][j]] = True
for m in range(M+1):
if dp[i-1][j][m]:
dp[i][j][abs(m - C[i][j])] = True
dp[i][j][m+C[i][j]] = True
for i in range((M*H*W)+1):
if dp[H-1][W-1][i]:
print(i)
break
| import bisect
import collections
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(H)]
B = [list(map(int, input().split())) for i in range(H)]
q = collections.deque()
C = [[abs(A[i][j] - B[i][j]) for j in range(W)] for i in range(H)]
M = 0
for i in range(H):
for j in range(W):
M = max(C[i][j], M)
dp = [[[False]*((M*(H+W)) + 1) for j in range(W)] for i in range(H)]
for i in range(H):
for j in range(W):
if i == 0:
if j == 0:
dp[i][j][C[i][j]] = True
else:
for m in range((H+W)*M+1):
if dp[i][j-1][m]:
dp[i][j][abs(m - C[i][j])] = True
dp[i][j][m+C[i][j]] = True
else:
if j != 0:
for m in range((H+W)*M+1):
if dp[i][j-1][m]:
dp[i][j][abs(m - C[i][j])] = True
dp[i][j][m+C[i][j]] = True
for m in range((H+W)*M+1):
if dp[i-1][j][m]:
dp[i][j][abs(m - C[i][j])] = True
dp[i][j][m+C[i][j]] = True
for i in range((M*(H+W))+1):
if dp[H-1][W-1][i]:
print(i)
break
| p02839 |
import bisect
import collections
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(H)]
B = [list(map(int, input().split())) for i in range(H)]
q = collections.deque()
C = [[abs(A[i][j] - B[i][j]) for j in range(W)] for i in range(H)]
M = 0
for i in range(H):
for j in range(W):
M = max(C[i][j], M)
dp = [[[False]*((M*(H+W)) + 1) for j in range(W)] for i in range(H)]
for i in range(H):
for j in range(W):
if i == 0:
if j == 0:
dp[i][j][C[i][j]] = True
else:
for m in range((H+W)*M+1):
if dp[i][j-1][m]:
dp[i][j][abs(m - C[i][j])] = True
dp[i][j][m+C[i][j]] = True
else:
if j != 0:
for m in range((H+W)*M+1):
if dp[i][j-1][m]:
dp[i][j][abs(m - C[i][j])] = True
dp[i][j][m+C[i][j]] = True
for m in range((H+W)*M+1):
if dp[i-1][j][m]:
dp[i][j][abs(m - C[i][j])] = True
dp[i][j][m+C[i][j]] = True
for i in range((M*(H+W))+1):
if dp[H-1][W-1][i]:
print(i)
break
| import bisect
import collections
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(H)]
B = [list(map(int, input().split())) for i in range(H)]
q = collections.deque()
C = [[abs(A[i][j] - B[i][j]) for j in range(W)] for i in range(H)]
M = 0
for i in range(H):
for j in range(W):
M = max(C[i][j], M)
dp = [[set() for j in range(W)] for i in range(H)]
for i in range(H):
for j in range(W):
if i == 0:
if j == 0:
dp[i][j].add(C[i][j])
else:
for x in dp[i][j-1]:
dp[i][j].add(abs(x-C[i][j]))
dp[i][j].add(x+C[i][j])
else:
if j != 0:
for x in dp[i][j-1]:
dp[i][j].add(abs(x-C[i][j]))
dp[i][j].add(x+C[i][j])
for x in dp[i-1][j]:
dp[i][j].add(abs(x-C[i][j]))
dp[i][j].add(x+C[i][j])
print((min(dp[H-1][W-1])))
| p02839 |
import bisect
import collections
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(H)]
B = [list(map(int, input().split())) for i in range(H)]
q = collections.deque()
C = [[abs(A[i][j] - B[i][j]) for j in range(W)] for i in range(H)]
M = 0
for i in range(H):
for j in range(W):
M = max(C[i][j], M)
dp = [[set() for j in range(W)] for i in range(H)]
for i in range(H):
for j in range(W):
if i == 0:
if j == 0:
dp[i][j].add(C[i][j])
else:
for x in dp[i][j-1]:
dp[i][j].add(abs(x-C[i][j]))
dp[i][j].add(x+C[i][j])
else:
if j != 0:
for x in dp[i][j-1]:
dp[i][j].add(abs(x-C[i][j]))
dp[i][j].add(x+C[i][j])
for x in dp[i-1][j]:
dp[i][j].add(abs(x-C[i][j]))
dp[i][j].add(x+C[i][j])
print((min(dp[H-1][W-1])))
|
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(H)]
B = [list(map(int, input().split())) for i in range(H)]
C = [[abs(A[i][j] - B[i][j]) for j in range(W)] for i in range(H)]
M = (H+W)*80
dp = [[0 for j in range(W)] for i in range(H)]
for i in range(H):
for j in range(W):
if i == 0:
if j == 0:
dp[i][j] = (1 << M) << C[i][j]
else:
dp[i][j] |= dp[i][j-1] >> C[i][j]
dp[i][j] |= dp[i][j-1] << C[i][j]
else:
if j != 0:
dp[i][j] |= dp[i][j-1] >> C[i][j]
dp[i][j] |= dp[i][j-1] << C[i][j]
dp[i][j] |= dp[i-1][j] >> C[i][j]
dp[i][j] |= dp[i-1][j] << C[i][j]
dp = bin(dp[i][j])[2:]
dp = dp[::-1]
ans = M
for i, x in enumerate(dp):
if x == "1":
ans = min(ans, abs(i - M))
print(ans)
| p02839 |
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
h, w = list(map(int, input().split()))
A = [list(map(int, input().split()))for i in range(h)]
B = [list(map(int, input().split()))for i in range(h)]
abss = [[abs(A[i][j]-B[i][j])for j in range(w)] for i in range(h)]
kmax = 6400
dp = [[[0]*kmax for j in range(w)]for i in range(h)]
dp[0][0][abss[0][0]] = 1
for i in range(h):
for j in range(w):
for k in range(kmax):
if dp[i][j][k] == 1:
if i != h-1:
dp[i+1][j][abs(k-abss[i+1][j])] = 1
if k+abss[i+1][j] < kmax:
dp[i+1][j][k+abss[i+1][j]] = 1
if j != w-1:
dp[i][j+1][abs(k-abss[i][j+1])] = 1
if k+abss[i][j+1] < kmax:
dp[i][j+1][k+abss[i][j+1]] = 1
for k in range(kmax):
if dp[-1][-1][k] == 1:
print(k)
break
if __name__ == '__main__':
main() | import sys
def input(): return sys.stdin.readline().rstrip()
def main():
h, w = list(map(int, input().split()))
A = [list(map(int, input().split()))for i in range(h)]
B = [list(map(int, input().split()))for i in range(h)]
abss = [[abs(A[i][j]-B[i][j])for j in range(w)] for i in range(h)]
dp = [[0]*w for i in range(h)]
dp[0][0] = 1 << (abss[0][0]+13000)
for i in range(h):
for j in range(w):
if i != h-1:
dp[i+1][j] = dp[i+1][j] | dp[i][j] << abss[i +
1][j] | dp[i][j] >> abss[i+1][j]
if j != w-1:
dp[i][j+1] = dp[i][j+1] | dp[i][j] << abss[i][j +
1] | dp[i][j] >> abss[i][j+1]
a = 0
ans = dp[-1][-1]
while True:
if (ans & (1 << (13000-a))):
print(a)
break
elif (ans & (1 << (13000+a))):
print(a)
break
a += 1
if __name__ == '__main__':
main() | p02839 |
import sys
input = sys.stdin.readline
I=lambda:int(eval(input()))
MI=lambda:list(map(int,input().split()))
LI=lambda:list(map(int,input().split()))
H,W=MI()
A=[LI() for _ in [0]*H]
B=[LI() for _ in [0]*H]
M=80*(H+W)
dp=[[[False]*(M+1) for _ in [0]*W] for _ in [0]*H]
dp[0][0][0]=True
m=M
for h in range(H):
for w in range(W):
d=A[h][w]-B[h][w]
for a in range(M+1):
if dp[h][w][a]:
#配る
if h!=H-1:
if 0<=abs(a+d)<=M:
dp[h+1][w][abs(a+d)]=True
if (h+1)*w==(H-1)*(W-1):
m=min(abs(a+d),m)
if 0<=abs(a-d)<=M:
dp[h+1][w][abs(a-d)]=True
if (h+1)*w==(H-1)*(W-1):
m=min(abs(a-d),m)
if w!=W-1:
if 0<=abs(a+d)<=M:
dp[h][w+1][abs(a+d)]=True
if h*(w+1)==(H-1)*(W-1):
m=min(abs(a+d),m)
if 0<=abs(a-d)<=M:
dp[h][w+1][abs(a-d)]=True
if h*(w+1)==(H-1)*(W-1):
m=min(abs(a-d),m)
res=dp[H-1][W-1][:]
for a in range(M+1):
if dp[H-1][W-1][a]:
d=A[H-1][W-1]-B[H-1][W-1]
if 0<=abs(a+d)<=M:
res[abs(a+d)]=True
m=min(abs(a+d),m)
if 0<=abs(a-d)<=M:
res[abs(a-d)]=True
m=min(abs(a-d),m)
print(m) | import sys
input = sys.stdin.readline
MI=lambda:list(map(int,input().split()))
LI=lambda:list(map(int,input().split()))
H,W=MI()
A=[LI() for _ in [0]*H]
B=[LI() for _ in [0]*H]
G=[[set() for i in range(W)] for j in range(H)]
G[0][0].add(0)
for h in range(H):
for w in range(W):
d=A[h][w]-B[h][w]
for a in G[h][w]:
if h!=H-1:
G[h+1][w].add(abs(a+d))
G[h+1][w].add(abs(a-d))
if w!=W-1:
G[h][w+1].add(abs(a+d))
G[h][w+1].add(abs(a-d))
res=set()
d=A[H-1][W-1]-B[H-1][W-1]
for a in G[H-1][W-1]:
res.add(abs(a+d))
res.add(abs(a-d))
res=sorted(list(res))
print((min(res))) | p02839 |
import sys
def main():
input = sys.stdin.readline
H,W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
S = (80+80)*80//2
dp = [[[0]*(S+1) for _ in range(W)] for __ in range(H)]
dp[0][0][abs(A[0][0] - B[0][0])] = 1
for i in range(H):
for j in range(W):
for s in range(S+1):
for ni,nj in [(i,j+1),(i+1,j)]:
if ni >= H or nj >= W: continue
t = abs(A[ni][nj] - B[ni][nj])
if s+t <= S:
dp[ni][nj][s+t] |= dp[i][j][s]
dp[ni][nj][abs(s-t)] |= dp[i][j][s]
for s in range(S+1):
if dp[H-1][W-1][s]:
print(s)
break
if __name__ == '__main__':
main() | import sys
def main():
input = sys.stdin.readline
H,W = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(H)]
B = [list(map(int, input().split())) for _ in range(H)]
C = [[abs(A[i][j] - B[i][j]) for j in range(W)] for i in range(H)]
M = 160*80
dp = [[0 for _ in range(W)] for __ in range(H)]
dp[0][0] = 1 << (C[0][0] + M)
for i in range(H):
for j in range(W):
for ni,nj in [(i,j+1),(i+1,j)]:
if ni >= H or nj >= W: continue
t = C[ni][nj]
dp[ni][nj] |= dp[i][j] << t
dp[ni][nj] |= dp[i][j] >> t
a = dp[H-1][W-1]
ans = 0
while True:
if a & (1 << (M+ans)) or a & (1 >> (M-ans)): break
ans += 1
print(ans)
if __name__ == '__main__':
main() | p02839 |
import sys
def main():
input = sys.stdin.readline
H,W=list(map(int, input().split()))
A=[list(map(int, input().split())) for _ in range(H)]
B=[list(map(int, input().split())) for _ in range(H)]
mx=80*(80+80)
C=[[A[i][j]-B[i][j] for j in range(W)] for i in range(H)]
dp=[[[0]*(mx*2+1) for _ in range(W)] for __ in range(H)]
dp[0][0][C[0][0]+mx]=1
dp[0][0][-C[0][0]+mx]=1
from collections import deque
q=deque([(0,0)])
while q:
i,j=q.popleft()
for d in range(80*(i+j+1)*2):
d=d-80*(i+j+1)+mx
if i>0:
if 0<=d-C[i][j]<=mx*2: dp[i][j][d] = max(dp[i][j][d], dp[i-1][j][d-C[i][j]])
if 0<=d+C[i][j]<=mx*2: dp[i][j][d] = max(dp[i][j][d], dp[i-1][j][d+C[i][j]])
if j>0:
if 0<=d-C[i][j]<=mx*2: dp[i][j][d] = max(dp[i][j][d], dp[i][j-1][d-C[i][j]])
if 0<=d+C[i][j]<=mx*2: dp[i][j][d] = max(dp[i][j][d], dp[i][j-1][d+C[i][j]])
if i<H-1: q.append((i+1,j))
if j<W-1: q.append((i,j+1))
for ans in range(mx+1):
if dp[H-1][W-1][mx+ans] or dp[H-1][W-1][mx-ans]:
print(ans)
break
if __name__ == '__main__':
main() | import sys
def main():
input = sys.stdin.readline
H,W=list(map(int, input().split()))
A=[list(map(int, input().split())) for _ in range(H)]
B=[list(map(int, input().split())) for _ in range(H)]
mx=80*(H+W)
C=[[abs(A[i][j]-B[i][j]) for j in range(W)] for i in range(H)]
dp=[[0 for _ in range(W)] for __ in range(H)]
dp[0][0]=1<<(mx+C[0][0]) | 1<<(mx-C[0][0])
from collections import deque
q=deque([(0,0)])
while q:
i,j=q.popleft()
if i>0:
dp[i][j] |= dp[i-1][j] << C[i][j]
dp[i][j] |= dp[i-1][j] >> C[i][j]
if j>0:
dp[i][j] |= dp[i][j-1] << C[i][j]
dp[i][j] |= dp[i][j-1] >> C[i][j]
if i<H-1: q.append((i+1,j))
if j<W-1: q.append((i,j+1))
for ans in range(mx+1):
if dp[H-1][W-1] & (1<<(mx+ans) | 1<<(mx-ans)):
print(ans)
break
if __name__ == '__main__':
main() | p02839 |
import sys
def main():
input = sys.stdin.readline
H,W=list(map(int, input().split()))
A=[list(map(int, input().split())) for _ in range(H)]
B=[list(map(int, input().split())) for _ in range(H)]
mx=80*(H+W)
C=[[abs(A[i][j]-B[i][j]) for j in range(W)] for i in range(H)]
dp=[[0 for _ in range(W)] for __ in range(H)]
dp[0][0]=1<<(mx+C[0][0]) | 1<<(mx-C[0][0])
from collections import deque
q=deque([(0,0)])
while q:
i,j=q.popleft()
if i>0:
dp[i][j] |= dp[i-1][j] << C[i][j]
dp[i][j] |= dp[i-1][j] >> C[i][j]
if j>0:
dp[i][j] |= dp[i][j-1] << C[i][j]
dp[i][j] |= dp[i][j-1] >> C[i][j]
if i<H-1: q.append((i+1,j))
if j<W-1: q.append((i,j+1))
for ans in range(mx+1):
if dp[H-1][W-1] & (1<<(mx+ans) | 1<<(mx-ans)):
print(ans)
break
if __name__ == '__main__':
main() | import sys
def main():
input = sys.stdin.readline
H,W=list(map(int, input().split()))
A=[list(map(int, input().split())) for _ in range(H)]
B=[list(map(int, input().split())) for _ in range(H)]
mx=80*(H+W)
C=[[abs(A[i][j]-B[i][j]) for j in range(W)] for i in range(H)]
dp=[[0 for _ in range(W)] for __ in range(H)]
dp[0][0]=1<<(mx+C[0][0])
for i in range(H):
for j in range(W):
for ni,nj in ((i+1,j),(i,j+1)):
if ni>=H or nj>=W: continue
dp[ni][nj] |= dp[i][j] << C[ni][nj]
dp[ni][nj] |= dp[i][j] >> C[ni][nj]
for ans in range(mx+1):
if dp[H-1][W-1] & (1<<(mx+ans) | 1<<(mx-ans)):
print(ans)
break
if __name__ == '__main__':
main() | p02839 |
def main():
H, W = [int(i) for i in input().split()]
A = [[int(i) for i in input().split()] for _ in range(H)]
B = [[int(i) for i in input().split()] for _ in range(H)]
M = (H + W) * 80 + 1
u = [[False] * M for _ in range(W)]
v = [[False] * M for _ in range(W)]
v[0][0] = True
for h in range(H):
v, u = u, v
for w in range(W):
a, b = A[h][w], B[h][w]
d = a - b if a > b else b - a
for i in range(M):
t = False
if 0 <= i + d < M:
t = t or u[w][i + d] or (w > 0 and v[w - 1][i + d])
if 0 <= i - d < M:
t = t or u[w][i - d] or (w > 0 and v[w - 1][i - d])
if 0 <= d - i < M:
t = t or u[w][d - i] or (w > 0 and v[w - 1][d - i])
v[w][i] = t
vv = v[-1]
for i in range(M):
if vv[i]:
print(i)
return
raise
main()
| def main():
H, W = [int(i) for i in input().split()]
A = [[int(i) for i in input().split()] for _ in range(H)]
B = [[int(i) for i in input().split()] for _ in range(H)]
M = (H + W) * 80 + 1
u = [[False] * M for _ in range(W)]
v = [[False] * M for _ in range(W)]
F = [False] * M
v[0][0] = True
for h in range(H):
v, u = u, v
vl = F
for w in range(W):
a, b = A[h][w], B[h][w]
d = a - b if a > b else b - a
uu = u[w]
vv = v[w]
for i in range(M):
di = i - d if i > d else d - i
vv[i] = ((i + d < M and (uu[i + d] or vl[i + d])) or
(uu[di] or vl[di]))
vl = vv
va = v[-1]
for i in range(M):
if va[i]:
print(i)
return
raise
main()
| p02839 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
h,w = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(h)]
b = [list(map(int, input().split())) for _ in range(h)]
c = [[0]*w for _ in range(h)]
for i in range(h):
for j in range(w):
c[i][j] = abs(a[i][j] -b[i][j])
mid = 12800
dp = [[0]*w for _ in range(h)]
dp[0][0] = (1<<(mid+c[0][0])) | (1<<(mid-c[0][0]))
for x in range(h):
for y in range(w):
for dx, dy in [[0, 1], [1, 0]]:
nx = x + dx
ny = y + dy
if 0<=nx<h and 0<=ny<w:
dp[nx][ny] = dp[nx][ny] | (dp[x][y]<<c[nx][ny])
dp[nx][ny] = dp[nx][ny] | (dp[x][y]>>c[nx][ny])
for i in range(mid+1):
if (dp[-1][-1]>>i) & 1:
res = mid - i
print(res)
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
h,w = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(h)]
b = [list(map(int, input().split())) for _ in range(h)]
c = [[0]*w for _ in range(h)]
for i in range(h):
for j in range(w):
c[i][j] = abs(a[i][j] -b[i][j])
mid = 3200
dp = [[0]*w for _ in range(h)]
dp[0][0] = (1<<(mid+c[0][0])) | (1<<(mid-c[0][0]))
for x in range(h):
for y in range(w):
for dx, dy in [[0, 1], [1, 0]]:
nx = x + dx
ny = y + dy
if 0<=nx<h and 0<=ny<w:
dp[nx][ny] = dp[nx][ny] | (dp[x][y]<<c[nx][ny])
dp[nx][ny] = dp[nx][ny] | (dp[x][y]>>c[nx][ny])
for i in range(mid+1):
if (dp[-1][-1]>>i) & 1:
res = mid - i
print(res)
if __name__ == '__main__':
main() | p02839 |
import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
h, w = ril()
ls0 = rils(h)
ls1 = rils(h)
nums = [[set() for _ in range(w)] for _ in range(h)]
nums[0][0].add(abs(ls0[0][0] - ls1[0][0]))
for i in range(h):
for j in range(w):
x = abs(ls0[i][j] - ls1[i][j])
if i > 0 and j > 0:
s = nums[i - 1][j] | nums[i][j - 1]
for y in s:
nums[i][j].add(abs(x + y))
nums[i][j].add(abs(x - y))
elif i > 0:
for y in nums[i - 1][j]:
nums[i][j].add(abs(x + y))
nums[i][j].add(abs(x - y))
elif j > 0:
for y in nums[i][j - 1]:
nums[i][j].add(abs(x + y))
nums[i][j].add(abs(x - y))
print((min(nums[h - 1][w - 1]))) | import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
h, w = ril()
ls0 = rils(h)
ls1 = rils(h)
nums = [[set() for _ in range(w)] for _ in range(h)]
nums[0][0].add(abs(ls0[0][0] - ls1[0][0]))
for i in range(h):
for j in range(w):
x = abs(ls0[i][j] - ls1[i][j])
if i > 0:
for y in nums[i - 1][j]:
z = abs(x + y)
if z <= 80 * 81:
nums[i][j].add(abs(x + y))
nums[i][j].add(abs(x - y))
if j > 0:
for y in nums[i][j - 1]:
z = abs(x + y)
if z <= 80 * 81:
nums[i][j].add(abs(x + y))
nums[i][j].add(abs(x - y))
print((min(nums[h - 1][w - 1]))) | p02839 |
def main():
B_MAX = (80 + 80 - 1) * 80
H, W = list(map(int, input().split(' ')))
A = [list(map(int, input().split(' '))) for _ in range(H)]
B = [list(map(int, input().split(' '))) for _ in range(H)]
dp = [[[0 for _ in range(B_MAX + 1)] for _ in range(W)] for _ in range(H)]
dp[0][0][abs(A[0][0] - B[0][0])] = 1
max_b = abs(A[0][0] - B[0][0])
for h in range(H):
for w in range(W):
if h == 0 and w == 0:
continue
d = abs(A[h][w] - B[h][w])
max_b += d
for b in range(min(B_MAX, max_b) + 1):
v = 0
if h > 0:
v = max(v, dp[h - 1][w][abs(b - d)])
if b + d <= B_MAX:
v = max(v, dp[h - 1][w][b + d])
if w > 0:
v = max(v, dp[h][w - 1][abs(b - d)])
if b + d <= B_MAX:
v = max(v, dp[h][w - 1][b + d])
dp[h][w][b] = v
ans = 0
while dp[H - 1][W - 1][ans] == 0:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| def main():
B_MAX = (80 + 80 - 1) * 80 // 2
H, W = list(map(int, input().split(' ')))
A = [list(map(int, input().split(' '))) for _ in range(H)]
B = [list(map(int, input().split(' '))) for _ in range(H)]
dp = [[[0 for _ in range(B_MAX + 1)] for _ in range(W)] for _ in range(H)]
dp[0][0][abs(A[0][0] - B[0][0])] = 1
max_b = abs(A[0][0] - B[0][0])
for h in range(H):
for w in range(W):
if h == 0 and w == 0:
continue
d = abs(A[h][w] - B[h][w])
max_b += d
for b in range(min(B_MAX, max_b) + 1):
v = 0
if h > 0:
v = max(v, dp[h - 1][w][abs(b - d)])
if b + d <= B_MAX:
v = max(v, dp[h - 1][w][b + d])
if w > 0:
v = max(v, dp[h][w - 1][abs(b - d)])
if b + d <= B_MAX:
v = max(v, dp[h][w - 1][b + d])
dp[h][w][b] = v
ans = 0
while dp[H - 1][W - 1][ans] == 0:
ans += 1
print(ans)
if __name__ == '__main__':
main()
| p02839 |
h, w = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(h)]
b = [list(map(int, input().split())) for _ in range(h)]
k_max = 81 * (h + w)
dp = [[[0] * (k_max+1) for _ in range(w+1)] for _ in range(h+1)]
for i in range(h + 1):
dp[i][0][0] = 1
for j in range(w + 1):
dp[0][j][0] = 1
for i in range(1, h + 1):
for j in range(1, w + 1):
ab = abs(a[i-1][j-1] - b[i-1][j-1])
for k in range(k_max + 1):
d = dp[i-1][j][abs(k-ab)]
r = dp[i][j-1][abs(k-ab)]
if k + ab <= k_max:
d |= dp[i-1][j][k+ab]
r |= dp[i][j-1][k+ab]
dp[i][j][k] = d or r
ans = 0
for k in range(k_max + 1):
if dp[h][w][k]:
ans = k
break
print(ans)
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
H,W = list(map(int,readline().split()))
A = [list(map(int,readline().split())) for _ in range(H)]
B = [list(map(int,readline().split())) for _ in range(H)]
X = (H + W) * 80
# X点持った状態から始める
dp = [[0] * W for _ in range(H)]
d = abs(A[0][0] - B[0][0])
dp[0][0] = (1 << (X - d))
for h in range(H):
for w,(a,b) in enumerate(zip(A[h],B[h])):
if h == w == 0:
continue
d = abs(a - b)
x = 0
if h != 0:
x |= (dp[h-1][w] << d)
x |= (dp[h-1][w] >> d)
if w != 0:
x |= (dp[h][w-1] << d)
x |= (dp[h][w-1] >> d)
dp[h][w] = x
dp = dp[-1][-1]
B = bin(dp)[2:]
can_make = [i - X for i,b in enumerate(B[::-1]) if b == '1']
answer = min(x if x >= 0 else -x for x in can_make)
print(answer) | p02839 |
import sys
input = sys.stdin.readline
h,w = list(map(int,input().split()))
a = [list(map(int,input().split())) for i in range(h)]
b = [list(map(int,input().split())) for i in range(h)]
grid = [[0 for i in range(w)] for j in range(h)]
for i in range(h):
for j in range(w):
grid[i][j] = abs(a[i][j]-b[i][j])
dp = [[[False for i in range(12881)] for j in range(w)] for k in range(h)]
for i in range(h):
for j in range(w):
for k in range(12801):
t = grid[i][j]
if i == j == 0 and t == k:
dp[i][j][k] = True
if j > 0:
dp[i][j][k] = dp[i][j][k] or dp[i][j-1][k+t] or dp[i][j-1][abs(k-t)]
if i > 0:
dp[i][j][k] = dp[i][j][k] or dp[i-1][j][k+t] or dp[i-1][j][abs(k-t)]
for i in range(12801):
if dp[h-1][w-1][i]:
print(i)
break
| h,w = list(map(int,input().split()))
a = [list(map(int,input().split())) for i in range(h)]
b = [list(map(int,input().split())) for i in range(h)]
grid = [[0 for i in range(w)] for j in range(h)]
for i in range(h):
for j in range(w):
grid[i][j] = abs(a[i][j]-b[i][j])
dp = [[0 for j in range(w)] for k in range(h)]
buf = (h+w)*80
for i in range(h):
for j in range(w):
t = grid[i][j]
if i == j == 0:
dp[i][j] = 1 << buf+t | 1 << buf-t
if j > 0:
dp[i][j] = dp[i][j] | dp[i][j-1] << t | dp[i][j-1] >> t
if i > 0:
dp[i][j] = dp[i][j] | dp[i-1][j] << t | dp[i-1][j] >> t
for i in range(buf):
if (dp[h-1][w-1] & 1 << buf+i) or (dp[h-1][w-1] & 1 << buf-i):
print(i)
exit() | p02839 |
def getval():
h,w = list(map(int,input().split()))
a = [list(map(int,input().split())) for i in range(h)]
b = [list(map(int,input().split())) for i in range(h)]
return h,w,a,b
def main(h,w,a,b):
dp = []
for i in range(w):
dp.append([False for j in range(1+160*(i+1))])
dp[0][abs(a[0][0]-b[0][0])] = True
for i in range(w-1):
cura = a[0][i+1]
curb = b[0][i+1]
prev = dp[i]
for j in range(len(prev)):
if prev[j]:
u1 = abs(j-(cura-curb))
u2 = abs(j-(curb-cura))
for k in [u1,u2]:
if k<=160*80:
dp[i+1][k] = True
#for i in dp:
#print(i[:20])
for i in range(h-1):
temp = []
for j in range(w):
cur = [False for k in range(min(1+160*(i+j+2),1+160*80))]
prev1 = dp[j]
prev2 = dp[j]
if temp:
prev2 = temp[-1]
cura = a[i+1][j]
curb = b[i+1][j]
for k in range(len(prev1)):
if prev1[k] or prev2[k]:
u1 = abs(k-(cura-curb))
u2 = abs(k-(curb-cura))
for l in [u1,u2]:
if l<160*80:
cur[l] = True
temp.append(cur)
dp = temp
#for i in dp:
#print(i[:20])
ans = 0
for i in range(160*80+1):
if dp[-1][i]:
ans = i
break
print(ans)
if __name__=="__main__":
h,w,a,b = getval()
main(h,w,a,b) | def getval():
h,w = list(map(int,input().split()))
a = [list(map(int,input().split())) for i in range(h)]
b = [list(map(int,input().split())) for i in range(h)]
return h,w,a,b
def main(h,w,a,b):
dp = []
for i in range(w):
dp.append([False for j in range(1+160*(i+1))])
dp[0][abs(a[0][0]-b[0][0])] = True
for i in range(w-1):
cura = a[0][i+1]
curb = b[0][i+1]
prev = dp[i]
for j in range(len(prev)):
if prev[j]:
u1 = abs(j-(cura-curb))
u2 = abs(j-(curb-cura))
for k in [u1,u2]:
if k<=160*80:
dp[i+1][k] = True
#for i in dp:
#print(i[:20])
for i in range(h-1):
temp = []
rowa = a[i+1]
rowb = b[i+1]
for j in range(w):
cur = [False for k in range(min(1+160*(i+j+2),1+160*80))]
prev1 = dp[j]
prev2 = dp[j]
if temp:
prev2 = temp[-1]
cura = rowa[j]
curb = rowb[j]
for k in range(len(prev1)):
if prev1[k] or prev2[k]:
u1 = abs(k-(cura-curb))
u2 = abs(k-(curb-cura))
if u1<len(cur):
cur[u1] = True
if u2<len(cur):
cur[u2] = True
temp.append(cur)
dp = temp
#for i in dp:
#print(i[:20])
ans = 0
for i in range(160*80+1):
if dp[-1][i]:
ans = i
break
print(ans)
if __name__=="__main__":
h,w,a,b = getval()
main(h,w,a,b) | p02839 |
h,w = list(map(int,input().split()))
a = []
b = []
for i in range(h):
a1 = list(map(int,input().split()))
a.append(a1)
for i in range(h):
b1 = list(map(int,input().split()))
b.append(b1)
l = [[] for i in range(h)]
for i in range(h):
for j in range(w):
l[i].append(abs(a[i][j]-b[i][j]))
dp = [[[0 for i in range(81*(h+w))] for i in range(w)] for i in range(h)]
for i in range(h):
for j in range(w):
#print(dp)
for k in range(81*(h+w)):
if i == 0:
if j == 0:
dp[i][j][l[i][j]] = 1
else:
if dp[i][j-1][k] == 1:
dp[i][j][k+l[i][j]] = 1
dp[i][j][abs(k-l[i][j])] = 1
else:
if j == 0:
if dp[i-1][j][k] == 1:
dp[i][j][k+l[i][j]] = 1
dp[i][j][abs(k-l[i][j])] = 1
else:
if dp[i-1][j][k] == 1:
dp[i][j][k+l[i][j]] = 1
dp[i][j][abs(k-l[i][j])] = 1
if dp[i][j-1][k] == 1:
dp[i][j][k+l[i][j]] = 1
dp[i][j][abs(k-l[i][j])] = 1
ans = 80
for i in range(81):
if dp[h-1][w-1][i] == 1:
ans = i
break
print(ans) | h,w = list(map(int,input().split()))
a = []
b = []
for i in range(h):
a1 = list(map(int,input().split()))
a.append(a1)
for i in range(h):
b1 = list(map(int,input().split()))
b.append(b1)
l = [[] for i in range(h)]
for i in range(h):
for j in range(w):
l[i].append(abs(a[i][j]-b[i][j]))
dp = [[[0 for i in range(81*(h+w)//2+1)] for i in range(w)] for i in range(h)]
for i in range(h):
for j in range(w):
#print(dp)
for k in range(81*(h+w)//2+1):
if i == 0:
if j == 0:
dp[i][j][l[i][j]] = 1
else:
if dp[i][j-1][k] == 1:
if k+l[i][j] <= 81*(h+w)//2:
dp[i][j][k+l[i][j]] = 1
dp[i][j][abs(k-l[i][j])] = 1
else:
if j == 0:
if dp[i-1][j][k] == 1:
if k+l[i][j] <= 81*(h+w)//2:
dp[i][j][k+l[i][j]] = 1
dp[i][j][abs(k-l[i][j])] = 1
else:
if dp[i-1][j][k] == 1:
if k+l[i][j] <= 81*(h+w)//2:
dp[i][j][k+l[i][j]] = 1
dp[i][j][abs(k-l[i][j])] = 1
if dp[i][j-1][k] == 1:
if k+l[i][j] <= 81*(h+w)//2:
dp[i][j][k+l[i][j]] = 1
dp[i][j][abs(k-l[i][j])] = 1
ans = 80
for i in range(81):
if dp[h-1][w-1][i] == 1:
ans = i
break
print(ans) | p02839 |
H, W = list(map(int, input().split()))
AB = []
for i in range(H):
AB.append(list(map(int, input().split())))
for i in range(H):
AB[i] = [abs(AB[i][j] - int(b)) for j, b in enumerate(input().split())]
K = 80*H*W
dp = [[[False]*K for w in range(W)] for h in range(H)]
dp[0][0][abs(AB[0][0])] = True
for h in range(H):
for w in range(W):
if h == 0:
if w == 0:
continue
else:
for k in range(K):
ab = AB[h][w]
k1, k2 = abs(k - ab), k + ab
if k1 < K and k2 < K:
dp[h][w][k] = dp[h][w-1][k1] or dp[h][w-1][k2]
elif k1 < K and k2 >= K:
dp[h][w][k] = dp[h][w-1][k1]
else:
dp[h][w][k] = dp[h][w-1][k2]
else:
if w == 0:
for k in range(K):
ab = AB[h][w]
k1, k2 = abs(k - ab), k + ab
if k1 < K and k2 < K:
dp[h][w][k] = dp[h-1][w][k1] or dp[h-1][w][k2]
elif k1 < K and k2 >= K:
dp[h][w][k] = dp[h-1][w][k1]
else:
dp[h][w][k] = dp[h-1][w][k2]
else:
for k in range(K):
ab = AB[h][w]
k1, k2 = abs(k - ab), k + ab
if k1 < K and k2 < K:
dp[h][w][k] = dp[h][w-1][k1] or dp[h][w-1][k2] or dp[h-1][w][k1] or dp[h-1][w][k2]
elif k1 < K and k2 >= K:
dp[h][w][k] = dp[h][w-1][k1] or dp[h-1][w][k1]
else:
dp[h][w][k] = dp[h][w-1][k2] or dp[h-1][w][k2]
for k in range(K):
if dp[H-1][W-1][k]:
print(k)
break | H, W = list(map(int, input().split()))
AB = []
for i in range(H):
AB.append(list(map(int, input().split())))
for i in range(H):
AB[i] = [abs(AB[i][j] - int(b)) for j, b in enumerate(input().split())]
K = 80*(H + W)
dp = [[[False]*K for w in range(W)] for h in range(H)]
dp[0][0][abs(AB[0][0])] = True
for h in range(H):
for w in range(W):
if h == 0:
if w == 0:
continue
else:
for k in range(K):
ab = AB[h][w]
k1, k2 = abs(k - ab), k + ab
if k1 < K and k2 < K:
dp[h][w][k] = dp[h][w-1][k1] or dp[h][w-1][k2]
elif k1 < K and k2 >= K:
dp[h][w][k] = dp[h][w-1][k1]
else:
dp[h][w][k] = dp[h][w-1][k2]
else:
if w == 0:
for k in range(K):
ab = AB[h][w]
k1, k2 = abs(k - ab), k + ab
if k1 < K and k2 < K:
dp[h][w][k] = dp[h-1][w][k1] or dp[h-1][w][k2]
elif k1 < K and k2 >= K:
dp[h][w][k] = dp[h-1][w][k1]
else:
dp[h][w][k] = dp[h-1][w][k2]
else:
for k in range(K):
ab = AB[h][w]
k1, k2 = abs(k - ab), k + ab
if k1 < K and k2 < K:
dp[h][w][k] = dp[h][w-1][k1] or dp[h][w-1][k2] or dp[h-1][w][k1] or dp[h-1][w][k2]
elif k1 < K and k2 >= K:
dp[h][w][k] = dp[h][w-1][k1] or dp[h-1][w][k1]
else:
dp[h][w][k] = dp[h][w-1][k2] or dp[h-1][w][k2]
for k in range(K):
if dp[H-1][W-1][k]:
print(k)
break | p02839 |
H, W = list(map(int, input().split()))
AB = []
max_ab = 0
for i in range(H):
AB.append(list(map(int, input().split())))
max_ab = max(max_ab, max(AB[-1]))
for i in range(H):
AB[i] = [abs(AB[i][j] - int(b)) for j, b in enumerate(input().split())]
K = max_ab*(H + W) + 1
dp = [[[False]*K for w in range(W+1)] for h in range(H+1)]
dp[0][0][0] = True
dp[0][1][0] = True
dp[1][0][0] = True
for h in range(H):
for w in range(W):
ab = AB[h][w]
for i, tp in enumerate(dp[h][w+1]):
if not tp:
continue
dp[h+1][w+1][abs(i+ab)] = True
dp[h+1][w+1][abs(i-ab)] = True
for i, tp in enumerate(dp[h+1][w]):
if not tp:
continue
dp[h+1][w+1][abs(i+ab)] = True
dp[h+1][w+1][abs(i-ab)] = True
for k in range(K):
if dp[H][W][k]:
print(k)
break | H, W = list(map(int, input().split()))
AB = []
max_ab = 0
for i in range(H):
AB.append(list(map(int, input().split())))
max_ab = max(max_ab, max(AB[-1]))
for i in range(H):
AB[i] = [abs(AB[i][j] - int(b)) for j, b in enumerate(input().split())]
base = max_ab*(H + W)
dp = [[1 << base for w in range(W)] for h in range(H)]
dp[0][0] = (1 << base + AB[0][0]) | (1 << base - AB[0][0])
for h in range(1, H):
dp[h][0] = (dp[h-1][0] << AB[h][0]) | (dp[h-1][0] >> AB[h][0])
for w in range(1, W):
dp[0][w] = (dp[0][w-1] << AB[0][w]) | (dp[0][w-1] >> AB[0][w])
for h in range(1, H):
for w in range(1, W):
dp[h][w] = (
(dp[h-1][w] << AB[h][w]) | (dp[h-1][w] >> AB[h][w])
| (dp[h][w-1] << AB[h][w]) | (dp[h][w-1] >> AB[h][w]))
positive = bin(dp[H-1][W-1] >> base)
print((positive[::-1].find('1'))) | p02839 |
import sys
input = sys.stdin.readline
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(H)]
B = [list(map(int, input().split())) for i in range(H)]
D = [[0]*W for i in range(H)]
mx = 1
for i in range(H):
for j in range(W):
D[i][j] = abs(A[i][j]-B[i][j])
mx = max(mx, D[i][j])
MX = mx*(H+W)
dp = [[[0]*(MX+1) for _ in range(W+1)] for _ in range(H+1)]
dp[1][1][D[0][0]] = 1
for i in range(1,H+1):
for j in range(1,W+1):
for k in range(MX+1):
if dp[i][j][k]:
if j+1 <= W:
d = D[i-1][j]
if k+d <= MX:
dp[i][j+1][k+d] = 1
dp[i][j+1][abs(k-d)] = 1
if i+1 <= H:
d = D[i][j-1]
if k+d <= MX:
dp[i+1][j][k+d] = 1
dp[i+1][j][abs(k-d)] = 1
#for i in range(H+1):
# for j in range(W+1):
# print(i, j)
# print(dp[i][j])
for i in range(MX+1):
if dp[H][W][i]:
print(i)
exit()
| import sys
input = sys.stdin.readline
H, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(H)]
B = [list(map(int, input().split())) for i in range(H)]
D = [[0]*W for i in range(H)]
for i in range(H):
for j in range(W):
D[i][j] = abs(A[i][j]-B[i][j])
buf = 80*(H+W)
dp = [[0]*W for i in range(H)]
dp[0][0] = 1<<(buf+D[0][0]) | 1<<(buf-D[0][0])
for i in range(H):
for j in range(W):
d = D[i][j]
if i:
dp[i][j] |= dp[i-1][j]<<d | dp[i-1][j]>>d
if j:
dp[i][j] |= dp[i][j-1]<<d | dp[i][j-1]>>d
ans = 10**18
for i in range(buf*2+1):
if dp[H-1][W-1]&(1<<i):
ans = min(ans, abs(buf-i))
print(ans)
| p02839 |
import sys
from collections import defaultdict
input = sys.stdin.readline
H, W = list(map(int, input().split()))
A, B = [None] * H, [None] * H
for i in range(H):
A[i] = list(map(int, input().split()))
for i in range(H):
B[i] = list(map(int, input().split()))
C = [[abs(A[i][j] - B[i][j]) for j in range(W)] for i in range(H)]
M = 80*(80+80)
dp = [[defaultdict(lambda :False) for j in range(W+1)] for i in range(H+1)]
dp[0][1][0] = True
dp[1][0][0] = True
for i in range(1, H+1):
for j in range(1, W+1):
d = C[i-1][j-1]
for k in range((i+j-1)*80):
if dp[i-1][j][abs(k-d)] or dp[i-1][j][k+d] or dp[i][j-1][abs(k-d)] or dp[i][j-1][k+d]:
dp[i][j][k] = True
for i in range(M):
if i in dp[H][W]:
print(i)
break
| import sys
input = sys.stdin.readline
H, W = list(map(int, input().split()))
A, B = [None] * H, [None] * H
for i in range(H):
A[i] = list(map(int, input().split()))
for i in range(H):
B[i] = list(map(int, input().split()))
C = [[abs(A[i][j] - B[i][j]) for j in range(W)] for i in range(H)]
M = 80*(80+80)
dp = [[0 for j in range(W+1)] for i in range(H+1)]
dp[0][1] = 1
dp[1][0] = 1
for i in range(1, H+1):
for j in range(1, W+1):
d = C[i-1][j-1]
if d != 0:
x = int(bin((dp[i-1][j]&(2**d-1))+2**d)[::-1][:d], 2)<<1
y = int(bin((dp[i][j-1]&(2**d-1))+2**d)[::-1][:d], 2)<<1
else:
x=y=0
#print(bin(dp[i-1][j]), bin(dp[i-1][j]+(2**10)))
dp[i][j] = (dp[i-1][j] >> d) | (dp[i-1][j] << d) | (dp[i][j-1] >> d) | (dp[i][j-1] << d) | x | y
#print(i, j, d, bin(dp[i][j]))
for i, v in enumerate(bin(dp[H][W])[::-1]):
if v == '1':
print(i)
break
| p02839 |
#!/usr/bin/env python3
import sys
INF = float("inf")
def solve(H: int, W: int, A: "List[List[int]]", B: "List[List[int]]"):
base = [[None]*W for _ in range(H)]
for h in range(H):
for w in range(W):
base[h][w] = abs(A[h][w]-B[h][w])
table = [[0 for _ in range(W)] for _ in range(H)]
table[0][0] |= (1 << base[0][0])
for h in range(H):
for w in range(W):
if h > 0:
for i in range(6401):
j = (table[h-1][w] >> i) & 1
if j == 0:
continue
if base[h][w]+i < 6401:
table[h][w] |= 1 << abs(i+base[h][w])
table[h][w] |= 1 << abs(i-base[h][w])
if w > 0:
for i in range(6401):
j = (table[h][w-1] >> i) & 1
if j == 0:
continue
if base[h][w]+i < 6401:
table[h][w] |= 1 << abs(i+base[h][w])
table[h][w] |= 1 << abs(i-base[h][w])
for j in range(6401):
i = (table[H-1][W-1] >> j) & 1
if i == 1:
print(j)
return
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
H = int(next(tokens)) # type: int
W = int(next(tokens)) # type: int
A = [[int(next(tokens)) for _ in range(W)]
for _ in range(H)] # type: "List[List[int]]"
B = [[int(next(tokens)) for _ in range(W)]
for _ in range(H)] # type: "List[List[int]]"
solve(H, W, A, B)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
INF = float("inf")
def solve(H: int, W: int, A: "List[List[int]]", B: "List[List[int]]"):
base = [[abs(A[h][w]-B[h][w]) for w in range(W)] for h in range(H)]
mx = (1 << 12800) - 1
table = [[0]*W for _ in range(H)]
table[0][0] = (1 << (6400 + base[0][0])) | (1 << (6400-base[0][0]))
for h in range(H):
for w in range(W):
if h > 0:
table[h][w] |= (table[h-1][w] << base[h][w])
table[h][w] |= (table[h-1][w] >> base[h][w])
if w > 0:
table[h][w] |= (table[h][w-1] << base[h][w])
table[h][w] |= (table[h][w-1] >> base[h][w])
table[h][w] &= mx
m = INF
for j in range(12800):
i = (table[H-1][W-1] >> j) & 1
if i == 1:
m = min(m, abs(j-6400))
print(m)
# print(table[H-1])
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
H = int(next(tokens)) # type: int
W = int(next(tokens)) # type: int
A = [[int(next(tokens)) for _ in range(W)]
for _ in range(H)] # type: "List[List[int]]"
B = [[int(next(tokens)) for _ in range(W)]
for _ in range(H)] # type: "List[List[int]]"
solve(H, W, A, B)
if __name__ == '__main__':
main()
| p02839 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
G = [[0] * W for _ in range(H)]
M = 0
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
if M < G[i][j]:
M = G[i][j]
L = (H + W) * M
dp = [[[False] * (L + 1) for j in range(W + 1)] for i in range(H + 1)]
dp[0][1][0] = dp[1][0][0] = True
for i in range(H):
for j in range(W):
b = G[i][j]
for k in range(L + 1):
if abs(k + b) <= L:
dp[i + 1][j + 1][k] = (
dp[i][j + 1][abs(k - b)]
or dp[i][j + 1][abs(k + b)]
or dp[i + 1][j][abs(k - b)]
or dp[i + 1][j][abs(k + b)]
)
else:
dp[i + 1][j + 1][k] = dp[i][j + 1][abs(k - b)] or dp[i + 1][j][abs(k - b)]
ans = INF
for k in range(L + 1):
if dp[H][W][k]:
ans = k
break
print(ans)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
G = [[0] * W for _ in range(H)]
M = 0
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
if M < G[i][j]:
M = G[i][j]
dp = [[set() for j in range(W + 1)] for i in range(H + 1)]
dp[0][1].add(0)
dp[1][0].add(0)
for i in range(H):
for j in range(W):
b = G[i][j]
for k in dp[i + 1][j]:
dp[i + 1][j + 1].add(k + b)
dp[i + 1][j + 1].add(abs(k - b))
for k in dp[i][j + 1]:
dp[i + 1][j + 1].add(k + b)
dp[i + 1][j + 1].add(abs(k - b))
print((min(dp[H][W])))
return
if __name__ == '__main__':
main()
| p02839 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
G = [[0] * W for _ in range(H)]
M = 0
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
if M < G[i][j]:
M = G[i][j]
dp = [[set() for j in range(W + 1)] for i in range(H + 1)]
dp[0][1].add(0)
dp[1][0].add(0)
for i in range(H):
for j in range(W):
b = G[i][j]
for k in dp[i + 1][j]:
dp[i + 1][j + 1].add(k + b)
dp[i + 1][j + 1].add(abs(k - b))
for k in dp[i][j + 1]:
dp[i + 1][j + 1].add(k + b)
dp[i + 1][j + 1].add(abs(k - b))
print((min(dp[H][W])))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
G = [[0] * W for _ in range(H)]
M = 0
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
if M < G[i][j]:
M = G[i][j]
dp = [[set() for j in range(W + 1)] for i in range(H + 1)]
dp[0][1].add(0)
dp[1][0].add(0)
for i in range(H):
for j in range(W):
s = dp[i + 1][j + 1]
b = G[i][j]
for k in dp[i + 1][j]:
s.add(k + b)
s.add(abs(k - b))
for k in dp[i][j + 1]:
s.add(k + b)
s.add(abs(k - b))
print((min(dp[H][W])))
return
if __name__ == '__main__':
main()
| p02839 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
M = 0
G = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
if M < G[i][j]:
M = G[i][j]
M = 20000
dp = [[0] * W for _ in range(H)]
dp[0][0] = 1 << (M + G[0][0]) | 1 << (M - G[0][0])
for i in range(H):
for j in range(W):
if i + 1 < H:
dp[i + 1][j] |= (dp[i][j] >> G[i + 1][j]) | (dp[i][j] << G[i + 1][j])
if j + 1 < W:
dp[i][j + 1] |= (dp[i][j] >> G[i][j + 1]) | (dp[i][j] << G[i][j + 1])
ans = INF
for i in range(2 * M + 2):
if dp[H - 1][W - 1] & (1 << i) and ans > abs(i - M):
ans = abs(i - M)
print(ans)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
M = 0
G = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
if M < G[i][j]:
M = G[i][j]
M *= max(H, W)
dp = [[0] * W for _ in range(H)]
dp[0][0] = 1 << (M + G[0][0]) | 1 << (M - G[0][0])
for i in range(H):
for j in range(W):
if i + 1 < H:
dp[i + 1][j] |= (dp[i][j] >> G[i + 1][j]) | (dp[i][j] << G[i + 1][j])
if j + 1 < W:
dp[i][j + 1] |= (dp[i][j] >> G[i][j + 1]) | (dp[i][j] << G[i][j + 1])
ans = INF
for i in range(2 * M + 2):
if dp[H - 1][W - 1] & (1 << i) and ans > abs(i - M):
ans = abs(i - M)
print(ans)
return
if __name__ == '__main__':
main()
| p02839 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
M = 0
G = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
if M < G[i][j]:
M = G[i][j]
M *= max(H, W)
dp = [[0] * W for _ in range(H)]
dp[0][0] = 1 << (M + G[0][0]) | 1 << (M - G[0][0])
for i in range(H):
for j in range(W):
if i + 1 < H:
dp[i + 1][j] |= (dp[i][j] >> G[i + 1][j]) | (dp[i][j] << G[i + 1][j])
if j + 1 < W:
dp[i][j + 1] |= (dp[i][j] >> G[i][j + 1]) | (dp[i][j] << G[i][j + 1])
ans = INF
for i in range(2 * M + 2):
if dp[H - 1][W - 1] & (1 << i) and ans > abs(i - M):
ans = abs(i - M)
print(ans)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
H, W = list(map(int, readline().split()))
A = [list(map(int, readline().split())) for _ in range(H)]
B = [list(map(int, readline().split())) for _ in range(H)]
M = 0
G = [[0] * W for _ in range(H)]
for i in range(H):
for j in range(W):
G[i][j] = abs(A[i][j] - B[i][j])
if M < G[i][j]:
M = G[i][j]
M *= max(H, W)
dp = [0] * W
dp[0] = 1 << (M + G[0][0]) | 1 << (M - G[0][0])
for i in range(H):
for j in range(W):
if j + 1 < W:
dp[j + 1] |= (dp[j] >> G[i][j + 1]) | (dp[j] << G[i][j + 1])
if i + 1 < H:
dp[j] = (dp[j] >> G[i + 1][j]) | (dp[j] << G[i + 1][j])
ans = INF
for i in range(2 * M + 2):
if dp[W - 1] & (1 << i) and ans > abs(i - M):
ans = abs(i - M)
print(ans)
return
if __name__ == '__main__':
main()
| p02839 |
import sys
input = sys.stdin.readline
H,W = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(H)]
B = [list(map(int,input().split())) for i in range(H)]
C = [[0]*W for i in range(H)]
M = 0
for h in range(H):
for w in range(W):
C[h][w] = abs(A[h][w] - B[h][w])
M = max(M,C[h][w])
#print(C)
ZZZ = M*(H+W-1)+1
DP = [[[0]*ZZZ for i in range(W)] for j in range(H)]
for h in range(H):
for w in range(W):
if h==0 and w==0:
DP[h][w][C[h][w]] = 1
elif h==0:
for i in range(ZZZ):
DP[h][w][i] = DP[h][w-1][abs(i-C[h][w])]| (DP[h][w-1][abs(i+C[h][w])] if abs(i+C[h][w])<ZZZ else 0)
elif w==0:
for i in range(ZZZ):
DP[h][w][i] = DP[h-1][w][abs(i-C[h][w])]|(DP[h-1][w][abs(i+C[h][w])] if abs(i+C[h][w])<ZZZ else 0)
else:
for i in range(ZZZ):
DP[h][w][i] = DP[h-1][w][abs(i-C[h][w])]|(DP[h-1][w][abs(i+C[h][w])] if abs(i+C[h][w])<ZZZ else 0)|DP[h][w-1][abs(i-C[h][w])]|(DP[h][w-1][abs(i+C[h][w])] if abs(i+C[h][w])<ZZZ else 0)
for i in range(ZZZ):
if DP[H-1][W-1][i]==1:
ans = i
break
print(ans) | import sys
input = sys.stdin.readline
H,W = list(map(int,input().split()))
A = [list(map(int,input().split())) for i in range(H)]
B = [list(map(int,input().split())) for i in range(H)]
C = [[0]*W for i in range(H)]
M = 0
for h in range(H):
for w in range(W):
C[h][w] = abs(A[h][w] - B[h][w])
#print(C)
c = 80*(H+W-1)+1
DP = [[0]*W for j in range(H)]
for h in range(H):
for w in range(W):
if h==0 and w==0:
DP[h][w] = 1 << (C[h][w]+c)
elif h==0:
DP[h][w] = (DP[h][w-1] << C[h][w]) | (DP[h][w-1] >> C[h][w])
elif w==0:
DP[h][w] = (DP[h-1][w] << C[h][w]) | (DP[h-1][w] >> C[h][w])
else:
DP[h][w] = (DP[h][w-1] << C[h][w]) | (DP[h][w-1] >> C[h][w]) | (DP[h-1][w] << C[h][w]) | (DP[h-1][w] >> C[h][w])
ans = float('inf')
now = DP[H-1][W-1]
tmpans = -c
while now != 0:
if now%2==1:
ans = min(ans,abs(tmpans))
tmpans += 1
now = now >> 1
print(ans) | p02839 |
import sys
input = sys.stdin.buffer.readline
h, w = list(map(int, input().split()))
AA = [list(map(int, input().split())) for _ in range(h)]
BB = [list(map(int, input().split())) for _ in range(h)]
kouho = [[set() for _ in range(w)] for _ in range(h)]
delta = AA[0][0] - BB[0][0]
kouho[0][0].add(delta)
kouho[0][0].add(-delta)
dx = [1, 0]
dy = [0, 1]
for y in range(h):
for x in range(w):
for d in range(2):
nx = x + dx[d]
ny = y + dy[d]
if nx < 0 or nx >= w or ny < 0 or ny >= h:
continue
delta = AA[ny][nx] - BB[ny][nx]
for num in kouho[y][x]:
temp = ((h + w - 2) - (ny + nx) + 1) * 80
if temp >= abs(num + delta):
kouho[ny][nx].add(num + delta)
if temp >= abs(num - delta):
kouho[ny][nx].add(num - delta)
ans = 10 ** 10
for a in kouho[h - 1][w - 1]:
ans = min(ans, abs(a))
print(ans)
| import sys
input = sys.stdin.buffer.readline
h, w = list(map(int, input().split()))
AA = [list(map(int, input().split())) for _ in range(h)]
BB = [list(map(int, input().split())) for _ in range(h)]
kouho = [[set() for _ in range(w)] for _ in range(h)]
delta = AA[0][0] - BB[0][0]
kouho[0][0].add(delta)
kouho[0][0].add(-delta)
dx = [1, 0]
dy = [0, 1]
for y in range(h):
for x in range(w):
for d in range(2):
nx = x + dx[d]
ny = y + dy[d]
if nx < 0 or nx >= w or ny < 0 or ny >= h:
continue
delta = AA[ny][nx] - BB[ny][nx]
for num in kouho[y][x]:
if 80 * (h + w) >= abs(num + delta):
kouho[ny][nx].add(abs(num + delta))
if 80 * (h + w) >= abs(num - delta):
kouho[ny][nx].add(abs(num - delta))
ans = 10 ** 10
for a in kouho[h - 1][w - 1]:
ans = min(ans, abs(a))
print(ans)
| p02839 |
import sys
from heapq import heappush, heapify
def solve():
file_input = sys.stdin
N, R, L = list(map(int, file_input.readline().split()))
hq = []
m = {}
for i in range(1, N + 1):
team = [0, i, 0]
heappush(hq, team)
m[i] = team
time = 0
for line in file_input:
d, t, x = list(map(int, line.split()))
m[d][0] -= x
hq[0][2] += t - time
time = t
heapify(hq)
hq[0][2] += L - time
ans_team = max(hq, key = lambda x: (x[2], -x[1]))
print((ans_team[1]))
solve()
| import sys
from heapq import heappush, heappop
def solve():
file_input = sys.stdin
N, R, L = list(map(int, file_input.readline().split()))
hq = []
m = {}
for i in range(1, N + 1):
team = [0, i, 0]
heappush(hq, team)
m[i] = team
time = 0
for line in file_input:
d, t, x = list(map(int, line.split()))
hq[0][2] += t - time
time = t
scored_team = m[d][:]
scored_team[0] -= x
heappush(hq, scored_team)
m[d][2] = -1
m[d] = scored_team
while hq[0][2] == -1:
heappop(hq)
hq[0][2] += L - time
ans_team = max(hq, key = lambda x: (x[2], -x[1]))
print((ans_team[1]))
solve()
| p00277 |
import sys
from heapq import heappush, heappop, heapreplace
def solve():
file_input = sys.stdin
N, R, L = list(map(int, file_input.readline().split()))
pq = [[0, i, 0] for i in range(1, N + 1)]
m = dict(list(zip(list(range(1, N + 1)), pq)))
pre_t = 0
for line in file_input:
d, t, x = list(map(int, line.split()))
team = pq[0]
team[2] += t - pre_t
pre_t = t
if team[1] == d:
team[0] -= x
if x < 0:
heapreplace(pq, team)
else:
scored_team = m[d][:]
scored_team[0] -= x
heappush(pq, scored_team)
m[d][2] = -1
m[d] = scored_team
while pq[0][2] == -1:
heappop(pq)
pq[0][2] += L - pre_t
ans_team = max(pq, key = lambda x: (x[2], -x[1]))
print((ans_team[1]))
solve()
| import sys
from heapq import heappush, heappop, heapreplace
def solve():
file_input = sys.stdin
N, R, L = list(map(int, file_input.readline().split()))
pq = [[0, i] for i in range(1, N + 1)]
m = dict(list(zip(list(range(1, N + 1)), pq)))
time = [0] * (N + 1)
INVALID = -1
pre_t = 0
for line in file_input:
d, t, x = list(map(int, line.split()))
top_team = pq[0]
time[top_team[1]] += t - pre_t
pre_t = t
if top_team[1] == d:
top_team[0] -= x
if x < 0:
heapreplace(pq, top_team)
else:
scored_team = m[d][:]
scored_team[0] -= x
heappush(pq, scored_team)
m[d][1] = INVALID
m[d] = scored_team
while pq[0][1] == INVALID:
heappop(pq)
time[pq[0][1]] += L - pre_t
print((time.index(max(time))))
solve()
| p00277 |
n, r, l = list(map(int, input().split()))
leaf_num = 1
while leaf_num < n:
leaf_num *= 2
tree = [None] * (leaf_num * 2 - 1)
for i in range(n):
tree[leaf_num - 1 + i] = (i, 0)
def set_value(index):
if leaf_num - 1 <= index <= leaf_num * 2 - 2:
return tree[index]
t1 = set_value(index * 2 + 1)
t2 = set_value(index * 2 + 2)
if t1 == None and t2 == None:
return None
else:
tree[index] = (t1[0], t1[1])
return tree[index]
def update(index):
if index <= -1:return
elif leaf_num - 1 <= index <= leaf_num * 2 - 2:
update((index - 1) // 2)
else:
left = tree[index * 2 + 1]
right = tree[index * 2 + 2]
if right == None:
tree[index] = left
else:
if left[1] < right[1]:
tree[index] = right
else:
tree[index] = left
update((index - 1) // 2)
set_value(0)
score = [0] * n
last_time = 0
for _ in range(r):
d, t, x = list(map(int, input().split()))
index, _ = tree[0]
score[index] += t - last_time
last_time = t
d -= 1
tree[leaf_num - 1 + d] = (tree[leaf_num - 1 + d][0], tree[leaf_num - 1 + d][1] + x)
update(leaf_num - 1 + d)
score[tree[0][0]] += l - last_time
print((score.index(max(score)) + 1))
| import sys
input = sys.stdin.readline
def main():
n, r, l = list(map(int, input().split()))
leaf_num = 1
while leaf_num < n:
leaf_num *= 2
INF = 10 ** 20
tree = [None] * (leaf_num * 2 - 1)
save = [0] * n
for i in range(n):
tree[leaf_num - 1 + i] = i
def set_value(index):
if leaf_num - 1 <= index <= leaf_num * 2 - 2:
return tree[index]
t1 = set_value(index * 2 + 1)
t2 = set_value(index * 2 + 2)
tree[index] = t1
return tree[index]
def update(index):
index = (index - 1) // 2
while index >= 0:
left = tree[index * 2 + 1]
right = tree[index * 2 + 2]
if right == None:
index = (index - 1) // 2
continue
tree[index] = right if save[right] > save[left] else left
index = (index - 1) // 2
set_value(0)
score = [0] * n
last_time = 0
for _ in range(r):
d, t, x = list(map(int, input().split()))
score[tree[0]] += t - last_time
last_time = t
save[d - 1] += x
update(leaf_num + d - 2)
score[tree[0]] += l - last_time
print((score.index(max(score)) + 1))
main()
| p00277 |
n, r, l = list(map(int, input().split()))
point, time = [], []
for i in range(n):
point.append(0)
time.append(0)
now, tv = 0, 0
for i in range(r):
d, t, x = list(map(int, input().split()))
time[tv] += t - now
now = t
point[d-1] += x
m = sorted(point, reverse=True)[0]
i = 0
while True:
if point[i] == m:
tv = i
break
i += 1
time[tv] += l - now
m = sorted(time, reverse=True)[0]
i = 0
while True:
if time[i] == m:
print((i+1))
break
i += 1 | n, r, l = list(map(int, input().split()))
point, time = [], []
rev = {0: []}
for i in range(n):
point.append(0)
time.append(0)
rev[0].append(i)
now, tv = 0, 0
for i in range(r):
d, t, x = list(map(int, input().split()))
time[tv] += t - now
now = t
rev[point[d-1]].remove(d-1)
point[d-1] += x
if point[d-1] in rev:
rev[point[d-1]].append(d-1)
else:
rev[point[d-1]] = [d-1]
if tv != d-1:
if point[tv] == point[d-1]:
tv = min(tv, d-1)
elif point[tv] < point[d-1]:
tv = d-1
elif x < 0:
tv = min(rev[max(point)])
time[tv] += l - now
m = max(time)
i = 0
while True:
if time[i] == m:
print((i+1))
break
i += 1 | p00277 |
n,r,l=list(map(int,input().split()))
log=[list(map(int,input().split())) for i in range(r)]
log.insert(0,[1,0,0])
log.append([1,l,0])
id_t=[0]*n
id_x=[0]*n
max_id=0
for i in range(1,r+2):
cur_id=log[i][0]-1
id_t[max_id]+=log[i][1]-log[i-1][1]
id_x[cur_id]+=log[i][2]
if log[i][2]<0:
max_id=id_x.index(max(id_x))
elif id_x[max_id]<id_x[cur_id] or (id_x[max_id]==id_x[cur_id] and max_id>cur_id):
max_id=cur_id
print(id_t.index(max(id_t))+1) | n,r,l=list(map(int,input().split()))
log=[list(map(int,input().split())) for i in range(r)]
log.insert(0,[1,0,0])
log.append([1,l,0])
id_t=[0]*n
id_x=[0]*n
max_id=0
for i in range(1,r+2):
cur_id=log[i][0]-1
id_t[max_id]+=log[i][1]-log[i-1][1]
id_x[cur_id]+=log[i][2]
if cur_id==max_id and log[i][2]<0:
max_id=id_x.index(max(id_x))
elif id_x[max_id]<id_x[cur_id] or (id_x[max_id]==id_x[cur_id] and max_id>cur_id):
max_id=cur_id
print(id_t.index(max(id_t))+1) | p00277 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0282
"""
import sys
from sys import stdin
from heapq import heappop, heappush
input = stdin.readline
pq = [] # list of entries arranged in a heap
entry_finder = {} # mapping of tasks to entries
REMOVED = 100000000 # placeholder for a removed task
def add_team(score, team):
if team in entry_finder:
remove_team(team)
entry = [-score, team]
entry_finder[team] = entry
heappush(pq, entry)
def remove_team(team):
entry = entry_finder.pop(team)
entry[-1] = REMOVED
def pop_team():
while pq:
score, team = heappop(pq)
if team is not REMOVED:
del entry_finder[team]
return team
raise KeyError('pop from an empty priority queue')
def main(args):
N, R, L = list(map(int, input().split()))
on_tv = [0] * (N + 1) # ????????????????????¬???????????£??????????????????????¨?
scores = [0] * (N + 1) # ????????????????????¨?????????
for i in range(1, N+1):
add_team(0, i)
last_time = 0
for i in range(R):
d, t, x = [int(x) for x in input().split()]
team = pop_team()
on_tv[team] += (t - last_time)
if d != team:
add_team(scores[team], team)
scores[d] += x
add_team(scores[d], d)
last_time = t
t = L
team = pop_team()
on_tv[team] += (t - last_time)
print((on_tv.index(max(on_tv))))
if __name__ == '__main__':
main(sys.argv[1:]) | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0282
"""
import sys
from sys import stdin
from heapq import heappop, heappush
input = stdin.readline
pq = [] # list of entries arranged in a heap
entry_finder = {} # mapping of tasks to entries
REMOVED = float('inf') # placeholder for a removed task
def add_team(score, team):
if team in entry_finder:
remove_team(team)
entry = [-score, team]
entry_finder[team] = entry
heappush(pq, entry)
def remove_team(team):
entry = entry_finder.pop(team)
entry[-1] = REMOVED
def pop_team():
while pq:
score, team = heappop(pq)
if team is not REMOVED:
del entry_finder[team]
return team
#raise KeyError('pop from an empty priority queue')
def main(args):
N, R, L = list(map(int, input().split()))
on_tv = [0] * (N + 1) # ????????????????????¬???????????£??????????????????????¨?
scores = [0] * (N + 1) # ????????????????????¨?????????
for i in range(1, N+1):
add_team(0, i)
last_time = 0
for i in range(R):
d, t, x = [int(x) for x in input().split()]
team = pop_team()
on_tv[team] += (t - last_time)
if d != team:
add_team(scores[team], team)
scores[d] += x
add_team(scores[d], d)
last_time = t
t = L
team = pop_team()
on_tv[team] += (t - last_time)
print((on_tv.index(max(on_tv))))
if __name__ == '__main__':
main(sys.argv[1:]) | p00277 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0282
"""
import sys
from sys import stdin
from heapq import heappop, heappush
input = stdin.readline
pq = [] # list of entries arranged in a heap
entry_finder = {} # mapping of tasks to entries
REMOVED = float('inf') # placeholder for a removed task
def add_team(score, team):
if team in entry_finder:
remove_team(team)
entry = [-score, team]
entry_finder[team] = entry
heappush(pq, entry)
def remove_team(team):
entry = entry_finder.pop(team)
entry[-1] = REMOVED
def pop_team():
while pq:
score, team = heappop(pq)
if team is not REMOVED:
del entry_finder[team]
return team
#raise KeyError('pop from an empty priority queue')
def main(args):
N, R, L = list(map(int, input().split()))
on_tv = [0] * (N + 1) # ????????????????????¬???????????£??????????????????????¨?
scores = [0] * (N + 1) # ????????????????????¨?????????
for i in range(1, N+1):
add_team(0, i)
last_time = 0
for i in range(R):
d, t, x = [int(x) for x in input().split()]
team = pop_team()
on_tv[team] += (t - last_time)
if d != team:
add_team(scores[team], team)
scores[d] += x
add_team(scores[d], d)
last_time = t
t = L
team = pop_team()
on_tv[team] += (t - last_time)
print((on_tv.index(max(on_tv))))
if __name__ == '__main__':
main(sys.argv[1:]) | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0282
"""
import sys
from sys import stdin
from heapq import heappop, heappush
input = stdin.readline
pq = [] # list of entries arranged in a heap
entry_finder = {} # mapping of tasks to entries
REMOVED = float('inf') # placeholder for a removed task
def add_team(score, team):
if team in entry_finder:
remove_team(team)
entry = [-score, team]
entry_finder[team] = entry
heappush(pq, entry)
def remove_team(team):
entry = entry_finder.pop(team)
entry[-1] = REMOVED
def pop_team():
while pq:
score, team = heappop(pq)
if team is not REMOVED:
del entry_finder[team]
return team
raise KeyError('pop from an empty priority queue')
def main(args):
N, R, L = list(map(int, input().split()))
on_tv = [0] * (N + 1) # ????????????????????¬???????????£??????????????????????¨?
scores = [0] * (N + 1) # ????????????????????¨?????????
for i in range(1, N+1):
add_team(0, i)
last_top = 1
last_score = 1
last_time = 0
for i in range(R):
d, t, x = [int(x) for x in input().split()]
if last_score > 0:
team = pop_team()
if d != team:
add_team(scores[team], team)
else:
team = last_team
on_tv[team] += (t - last_time)
scores[d] += x
add_team(scores[d], d)
last_time = t
last_score = x
last_team = d
t = L
team = pop_team()
on_tv[team] += (t - last_time)
print((on_tv.index(max(on_tv))))
if __name__ == '__main__':
main(sys.argv[1:]) | p00277 |
import heapq
def d_manhattan(node_list):
s = 0
for i in range(9):
x_goal = i%3
y_goal = i//3
x_now = (node_list[i] - 1)%3
y_now = (node_list[i] - 1)//3
if y_now == -1:
y_now = 2
dx = abs(x_now - x_goal)
dy = abs(y_now - y_goal)
s += dx + dy
return s
def moveNodeE(node_list, space):
node_tmp = node_list[:]
node_tmp[space], node_tmp[space + 1] = node_tmp[space + 1], node_tmp[space]
return node_tmp
def moveNodeW(node_list, space):
node_tmp = node_list[:]
node_tmp[space], node_tmp[space - 1] = node_tmp[space - 1], node_tmp[space]
return node_tmp
def moveNodeN(node_list, space):
node_tmp = node_list[:]
node_tmp[space], node_tmp[space - 3] = node_tmp[space - 3], node_tmp[space]
return node_tmp
def moveNodeS(node_list, space):
node_tmp = node_list[:]
node_tmp[space], node_tmp[space + 3] = node_tmp[space + 3], node_tmp[space]
return node_tmp
class board:
def __init__(self, node_list, g):
self.node = node_list
self.space = node_list.index(0)
self.g = g
self.h = d_manhattan(node_list)
self.f = self.g + self.h
def makeBoard(self):
space = self.space
cost_now = self.f
x_s = space%3
y_s = space//3
if x_s < 2:
node_tmp = moveNodeE(self.node, space)
yield board(node_tmp, self.g + 1)
if x_s > 0:
node_tmp = moveNodeW(self.node, space)
yield board(node_tmp, self.g + 1)
if y_s < 2:
node_tmp = moveNodeS(self.node, space)
yield board(node_tmp, self.g + 1)
if y_s > 0:
node_tmp = moveNodeN(self.node, space)
yield board(node_tmp, self.g + 1)
b_open = []
n_close = []
n_goal = [1,2,3,4,5,6,7,8,0]
n_start = []
for i in range(3):
inp = list(map(int, input().split()))
n_start.extend(inp)
b_start = board(n_start, 0)
heapq.heappush(b_open, (b_start.f, b_start.h, 0, b_start))
i = 0
while b_open:
_, _, _, b_now = heapq.heappop(b_open)
if b_now.node == n_goal:
b_goal = b_now
break
n_close.append(b_now.node)
for b_new in b_now.makeBoard():
if b_new.node in n_close:
continue
heapq.heappush(b_open, (b_new.f, b_new.h, i, b_new))
i += 1
print((b_goal.g)) | import heapq
def d_manhattan(node_list):
s = 0
for i in range(9):
x_goal = i%3
y_goal = i//3
x_now = (node_list[i] - 1)%3
y_now = (node_list[i] - 1)//3
if y_now == -1:
y_now = 2
dx = abs(x_now - x_goal)
dy = abs(y_now - y_goal)
s += dx + dy
return s
def moveNodeE(node_list, space):
node_tmp = node_list[:]
node_tmp[space], node_tmp[space + 1] = node_tmp[space + 1], node_tmp[space]
return node_tmp
def moveNodeW(node_list, space):
node_tmp = node_list[:]
node_tmp[space], node_tmp[space - 1] = node_tmp[space - 1], node_tmp[space]
return node_tmp
def moveNodeN(node_list, space):
node_tmp = node_list[:]
node_tmp[space], node_tmp[space - 3] = node_tmp[space - 3], node_tmp[space]
return node_tmp
def moveNodeS(node_list, space):
node_tmp = node_list[:]
node_tmp[space], node_tmp[space + 3] = node_tmp[space + 3], node_tmp[space]
return node_tmp
class board:
def __init__(self, node_list, g):
self.node = node_list
self.space = node_list.index(0)
self.g = g
self.h = d_manhattan(node_list)
self.f = self.g + self.h
def makeBoard(self):
space = self.space
cost_now = self.f
x_s = space%3
y_s = space//3
if x_s < 2:
node_tmp = moveNodeE(self.node, space)
yield board(node_tmp, self.g + 1)
if x_s > 0:
node_tmp = moveNodeW(self.node, space)
yield board(node_tmp, self.g + 1)
if y_s < 2:
node_tmp = moveNodeS(self.node, space)
yield board(node_tmp, self.g + 1)
if y_s > 0:
node_tmp = moveNodeN(self.node, space)
yield board(node_tmp, self.g + 1)
b_open = []
n_close = {}
n_goal = [1,2,3,4,5,6,7,8,0]
n_start = []
for i in range(3):
inp = list(map(int, input().split()))
n_start.extend(inp)
b_start = board(n_start, 0)
heapq.heappush(b_open, (b_start.f, b_start.h, 0, b_start))
i = 0
while b_open:
_, _, _, b_now = heapq.heappop(b_open)
if b_now.node == n_goal:
b_goal = b_now
break
n_close["".join(map(str, b_now.node))] = i
for b_new in b_now.makeBoard():
if "".join(map(str, b_new.node)) in n_close:
continue
heapq.heappush(b_open, (b_new.f, b_new.h, i, b_new))
i += 1
print((b_goal.g)) | p02245 |
import copy
def movable_state(state):
x, y = None, None
for i in range(3):
for j in range(3):
if state[i][j] == 0:
x, y = i, j
break
rsts = []
for r, c in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]:
if 0 <= r and r < 3 and 0 <= c and c < 3:
rst = copy.deepcopy(state)
rst[x][y], rst[r][c] = rst[r][c], rst[x][y]
rsts.append(rst)
return rsts
def hist_check(state, depth):
for i in range(depth-1):
for hist in state_history[i]:
if hist == state:
return True
return False
puzzle = [list(map(int, input().split(' '))) for i in range(3)]
state_history = [[puzzle]]
goal = [[1, 2, 3], [4, 5, 6], [7, 8, 0]]
exchange_num = 0
depth = 0
still_not = True
while still_not:
depth += 1
state_history.append([])
for hist in state_history[depth-1]:
next_states = movable_state(hist)
for next_stat in next_states:
if hist_check(next_stat, depth): continue
if next_stat == goal:
still_not = False
break
state_history[depth].append(next_stat)
if not still_not: break
print(depth)
| import copy
def movable_state(state):
x, y = None, None
for i in range(3):
for j in range(3):
if state[3*i+j] == 0:
x, y = i, j
break
rsts = []
for r, c in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]:
if 0 <= r and r < 3 and 0 <= c and c < 3:
rst = copy.copy(state)
rst[3*x+y], rst[3*r+c] = rst[3*r+c], rst[3*x+y]
rsts.append(rst)
return rsts
def hist_check(state, depth):
for i in range(depth-2, -1, -1):
for hist in state_history[i]:
if hist == state:
return True
return False
puzzle = []
for i in range(3):
puzzle.extend(list(map(int, input().split(' '))))
state_history = [[puzzle]]
goal = [1, 2, 3, 4, 5, 6, 7, 8, 0]
exchange_num = 0
depth = 0
still_not = True
while still_not:
depth += 1
state_history.append([])
for hist in state_history[depth-1]:
next_states = movable_state(hist)
for next_stat in next_states:
if hist_check(next_stat, depth): continue
if next_stat == goal:
still_not = False
break
state_history[depth].append(next_stat)
if not still_not: break
print(depth)
| p02245 |
from collections import deque, OrderedDict
class Puzzle:
def __init__(self, field=None, path=''):
self.f = field
self.space = None
for i in range(9):
if self.f[i] == 9:
self.space = i
self.path = path
def __lt__(self, pzl): # <
for i in range(9):
if self.f[i] == pzl.f[i]:
continue
return self.f[i] > pzl.f[i]
return False
def __gt__(self, pzl): # >
for i in range(9):
if self.f[i] == pzl.f[i]:
continue
return self.f[i] < pzl.f[i]
return False
dx = [-1, 0, 1, 0]
dy = [0, -1, 0, 1]
dir = ['u', 'l', 'd', 'r']
def is_target(pzl):
for i in range(9):
if pzl.f[i] != i+1:
return False
return True
def print_puzzle(pzl):
for i, p in enumerate(pzl.f):
print(p, '', end='')
if i%3 == 2:
print('')
def bfs(pzl):
queue = deque([])
V = OrderedDict()
pzl.path = ''
queue.append(pzl)
V[pzl] = True
if is_target(pzl): return u.path
while len(queue) != 0:
u = queue.popleft()
sx, sy = u.space//3, u.space%3
for r in range(4):
tx, ty = sx + dx[r], sy + dy[r]
if tx < 0 or ty < 0 or tx >= 3 or ty >= 3:
continue
v = Puzzle(field=[u.f[i] for i in range(9)], path=u.path)
v.f[u.space], v.f[tx*3+ty] = v.f[tx*3+ty], v.f[u.space]
v.space = tx*3 + ty
if v not in V:
V[v] = True
v.path += dir[r]
if is_target(v): return v.path
queue.append(v)
return 'unsolvable'
field = []
for i in range(3):
field.extend(list(map(int, input().split(' '))))
for i in range(9):
if field[i] == 0: field[i] = 9
pzl = Puzzle(field=field)
ans= bfs(pzl)
print(len(ans))
| from collections import deque, OrderedDict
class Puzzle:
def __init__(self, field=None, path=''):
self.f = field
self.space = None
for i in range(9):
if self.f[i] == 9:
self.space = i
self.path = path
def __lt__(self, pzl): # <
for i in range(9):
if self.f[i] == pzl.f[i]:
continue
return self.f[i] > pzl.f[i]
return False
def __gt__(self, pzl): # >
for i in range(9):
if self.f[i] == pzl.f[i]:
continue
return self.f[i] < pzl.f[i]
return False
dx = [-1, 0, 1, 0]
dy = [0, -1, 0, 1]
dir = ['u', 'l', 'd', 'r']
def is_target(pzl):
for i in range(9):
if pzl.f[i] != i+1:
return False
return True
def bfs(pzl):
queue = deque([])
V = {}
pzl.path = ''
queue.append(pzl)
V[str(pzl.f)] = True
if is_target(pzl): return pzl.path
while len(queue) != 0:
u = queue.popleft()
sx, sy = u.space//3, u.space%3
for r in range(4):
tx, ty = sx + dx[r], sy + dy[r]
if tx < 0 or ty < 0 or tx >= 3 or ty >= 3:
continue
v = Puzzle(field=[u.f[i] for i in range(9)], path=u.path)
v.f[u.space], v.f[tx*3+ty] = v.f[tx*3+ty], v.f[u.space]
v.space = tx*3 + ty
if str(v.f) not in V:
V[str(v.f)] = True
v.path += dir[r]
if is_target(v): return v.path
queue.append(v)
return 'unsolvable'
field = []
for i in range(3):
field.extend(list(map(int, input().split(' '))))
for i in range(9):
if field[i] == 0: field[i] = 9
pzl = Puzzle(field=field)
ans= bfs(pzl)
print((len(ans)))
| p02245 |
from heapq import heappop, heappush
from copy import deepcopy
class Board:
def __init__(self, size, nums):
self.size = size
self.nums = nums
self.code = self._code()
def __eq__(self, other):
return self.code == other.code
def __lt__(self, other):
return self.code < other.code
def __gt__(self, other):
return self.code > other.code
def __hash__(self):
nums = tuple(self.nums[i][j]
for i in range(self.size)
for j in range(self.size))
return hash(nums)
def same(self, other):
if other is None:
return False
if self.__class__ != other.__class__:
return False
for i in range(self.size):
for j in range(self.size):
if self.nums[i][j] != other.nums[i][j]:
return False
return True
def solved(self):
for i in range(self.size):
for j in range(self.size):
if (i, j) != self._validpos(self.nums[i][j]):
return False
return True
def _validpos(self, num):
if num > 0:
return ((num-1) // self.size, (num-1) % self.size)
else:
return (self.size-1, self.size-1)
def _code(self):
code = 0
for i in range(self.size):
for j in range(self.size):
if self.nums[i][j] != 0:
vi, vj = self._validpos(self.nums[i][j])
code += abs(vi - i) + abs(vj - j)
return code
def find(self, num):
for i in range(self.size):
for j in range(self.size):
if self.nums[i][j] == num:
return (i, j)
raise IndexError()
def move(self, p1, p2):
i1, j1 = p1
i2, j2 = p2
nums = deepcopy(self.nums)
nums[i1][j1], nums[i2][j2] = nums[i2][j2], nums[i1][j1]
return self.__class__(self.size, nums)
def moves(self):
i, j = self.find(0)
if i > 0:
yield self.move((i, j), (i-1, j))
if j > 0:
yield self.move((i, j), (i, j-1))
if i < self.size-1:
yield self.move((i, j), (i+1, j))
if j < self.size-1:
yield self.move((i, j), (i, j+1))
def __str__(self):
s = ''
for i in range(self.size):
for j in range(self.size):
s += ' {}'.format(self.nums[i][j])
s += '\n'
return s
class EightPuzzle:
def __init__(self, board):
self.board = Board(3, board)
self.steps = 0
if not self.board.solved():
self._solve()
def _solve(self):
bs = []
checked = {}
heappush(bs, (self.board, 0))
while len(bs) > 0:
b, step = heappop(bs)
if 0 < self.steps <= step:
continue
checked[b] = step
for nb in b.moves():
if nb.solved():
if self.steps == 0 or step < self.steps:
self.steps = step+1
elif nb in checked and checked[nb] <= step:
continue
else:
heappush(bs, (nb, step+1))
def run():
board = []
for i in range(3):
board.append([int(i) for i in input().split()])
eight_puzzle = EightPuzzle(board)
print((eight_puzzle.steps))
if __name__ == '__main__':
run()
| from heapq import heappop, heappush
from copy import deepcopy
class Board:
def __init__(self, size, nums):
self.size = size
self.nums = nums
self.code = self._code()
def __eq__(self, other):
return self.code == other.code
def __lt__(self, other):
return self.code < other.code
def __gt__(self, other):
return self.code > other.code
def __hash__(self):
nums = tuple(self.nums[i][j]
for i in range(self.size)
for j in range(self.size))
return hash(nums)
def same(self, other):
if other is None:
return False
if self.__class__ != other.__class__:
return False
for i in range(self.size):
for j in range(self.size):
if self.nums[i][j] != other.nums[i][j]:
return False
return True
def solved(self):
for i in range(self.size):
for j in range(self.size):
if (i, j) != self._validpos(self.nums[i][j]):
return False
return True
def _validpos(self, num):
if num > 0:
return ((num-1) // self.size, (num-1) % self.size)
else:
return (self.size-1, self.size-1)
def _code(self):
code = 0
for i in range(self.size):
for j in range(self.size):
if self.nums[i][j] != 0:
vi, vj = self._validpos(self.nums[i][j])
code += abs(vi - i) + abs(vj - j)
return code
def find(self, num):
for i in range(self.size):
for j in range(self.size):
if self.nums[i][j] == num:
return (i, j)
raise IndexError()
def move(self, p1, p2):
i1, j1 = p1
i2, j2 = p2
nums = deepcopy(self.nums)
nums[i1][j1], nums[i2][j2] = nums[i2][j2], nums[i1][j1]
return self.__class__(self.size, nums)
def moves(self):
i, j = self.find(0)
if i > 0:
yield self.move((i, j), (i-1, j))
if j > 0:
yield self.move((i, j), (i, j-1))
if i < self.size-1:
yield self.move((i, j), (i+1, j))
if j < self.size-1:
yield self.move((i, j), (i, j+1))
def __str__(self):
s = ''
for i in range(self.size):
for j in range(self.size):
s += ' {}'.format(self.nums[i][j])
s += '\n'
return s
class EightPuzzle:
def __init__(self, board):
self.board = Board(3, board)
self.steps = 0
if not self.board.solved():
self._solve()
def _solve(self):
bs = []
checked = {}
heappush(bs, (self.board.code, self.board, 0))
while len(bs) > 0:
w, b, step = heappop(bs)
if 0 < self.steps <= step:
continue
checked[b] = step
for nb in b.moves():
if nb.solved():
self.steps = step+1
return
elif nb in checked and checked[nb] <= step:
continue
else:
heappush(bs, (nb.code + step + 1, nb, step+1))
def run():
board = []
for i in range(3):
board.append([int(i) for i in input().split()])
eight_puzzle = EightPuzzle(board)
print((eight_puzzle.steps))
if __name__ == '__main__':
run()
| p02245 |
import sys;
import queue;
def iterative(i,j,c_depth,c_puz):
if(puzzleCheck(c_puz)):
global finding
finding = 1
print(c_depth)
if(finding == 1 or (c_depth+HS(c_puz)) > depth):
return
if(i != 0):
iterative(i-1,j,c_depth+1,swapPuz(c_puz[0:],i,j,i-1,j))
if(i != 2):
iterative(i+1,j,c_depth+1,swapPuz(c_puz[0:],i,j,i+1,j))
if(j != 0):
iterative(i,j-1,c_depth+1,swapPuz(c_puz[0:],i,j,i,j-1))
if(j != 2):
iterative(i,j+1,c_depth+1,swapPuz(c_puz[0:],i,j,i,j+1))
def simpleHS(c_puz):
count = 0
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
count+=1
return count
def HS(c_puz):
value = 0
for i in range(len(c_puz)):
k = correctPuz.index(c_puz[i])
_i = (int)(i/3)
_j = i - _i
ki = (int)(k/3)
kj = k - ki
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
swap = c_puz[i*3+j]
c_puz[i*3+j] = c_puz[i2*3+j2]
c_puz[i2*3+j2] = swap
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start,0,puz[0:])
depth+=1
| import sys;
import queue;
def iterative(i,j,c_depth,c_puz):
if(puzzleCheck(c_puz)):
global finding
finding = 1
print(c_depth)
if(finding == 1 or (c_depth+HS(c_puz)) > depth):
return
if(i != 0):
iterative(i-1,j,c_depth+1,swapPuz(c_puz[0:],i,j,i-1,j))
if(i != 2):
iterative(i+1,j,c_depth+1,swapPuz(c_puz[0:],i,j,i+1,j))
if(j != 0):
iterative(i,j-1,c_depth+1,swapPuz(c_puz[0:],i,j,i,j-1))
if(j != 2):
iterative(i,j+1,c_depth+1,swapPuz(c_puz[0:],i,j,i,j+1))
def simpleHS(c_puz):
count = 0
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
count+=1
return count
def HS(c_puz):
value = 0
for i in range(len(c_puz)):
k = correctPuz.index(c_puz[i])
_i = (int)(i/3)
_j = i - _i
ki = (int)(k/3)
kj = k - ki
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
swap = c_puz[i*3+j]
c_puz[i*3+j] = c_puz[i2*3+j2]
c_puz[i2*3+j2] = swap
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
finding = 0
depth = HS(puz)
while True:
if(finding == 1):
break
iterative(i_start,j_start,0,puz[0:])
depth+=1
| p02245 |
import sys;
import queue;
def iterative(i,j,c_depth,c_puz):
if(puzzleCheck(c_puz)):
global finding
finding = 1
print(c_depth)
if(finding == 1 or (c_depth+HS(c_puz)) > depth or (c_depth+simpleHS(c_puz)) > depth):
return
if(i != 0 and finding != 1):
iterative(i-1,j,c_depth+1,swapPuz(c_puz[0:],i,j,i-1,j))
if(i != 2 and finding != 1):
iterative(i+1,j,c_depth+1,swapPuz(c_puz[0:],i,j,i+1,j))
if(j != 0 and finding != 1):
iterative(i,j-1,c_depth+1,swapPuz(c_puz[0:],i,j,i,j-1))
if(j != 2 and finding != 1):
iterative(i,j+1,c_depth+1,swapPuz(c_puz[0:],i,j,i,j+1))
def simpleHS(c_puz):
count = 0
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
count+=1
return count
def HS(c_puz):
value = 0
for i in range(len(c_puz)):
k = correctPuz.index(c_puz[i])
_i = (int)(i/3)
_j = i - _i
ki = (int)(k/3)
kj = k - ki
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
swap = c_puz[i*3+j]
c_puz[i*3+j] = c_puz[i2*3+j2]
c_puz[i2*3+j2] = swap
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start,0,puz[0:])
depth+=1
| import sys;
import heapq
def iterative(i,j):
q = []
heapq.heappush(q,(0,i,j,puz))
global finding
while len(q):
items = heapq.heappop(q)
c_depth = items[0]
_i = items[1]
_j = items[2]
c_puz = items[3]
if(puzzleCheck(c_puz)):
finding = 1
print(c_depth)
break
if((c_depth+simpleHS(c_puz)) > depth):
continue
if(_i != 0):
heapq.heappush(q,(c_depth+1,_i-1,_j,swapPuz(c_puz[0:],_i,_j,_i-1,_j)))
if(_i != 2):
heapq.heappush(q,(c_depth+1,_i+1,_j,swapPuz(c_puz[0:],_i,_j,_i+1,_j)))
if(_j != 0):
heapq.heappush(q,(c_depth+1,_i,_j-1,swapPuz(c_puz[0:],_i,_j,_i,_j-1)))
if(_j != 2):
heapq.heappush(q,(c_depth+1,_i,_j+1,swapPuz(c_puz[0:],_i,_j,_i,_j+1)))
def simpleHS(c_puz):
count = 0
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
count+=1
return count
def HS(c_puz):
value = 0
for i in range(len(c_puz)):
k = correctPuz.index(c_puz[i])
_i = (int)(i/3)
_j = i - _i
ki = (int)(k/3)
kj = k - ki
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
swap = c_puz[i*3+j]
c_puz[i*3+j] = c_puz[i2*3+j2]
c_puz[i2*3+j2] = swap
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start)
depth+=1
| p02245 |
import sys;
import heapq
def iterative(i,j):
q = []
heapq.heappush(q,(0,i,j,puz))
global finding
while len(q):
items = heapq.heappop(q)
c_depth = items[0]
_i = items[1]
_j = items[2]
c_puz = items[3]
if(puzzleCheck(c_puz)):
finding = 1
print(c_depth)
break
if((c_depth+simpleHS(c_puz)) >= depth):
continue
if(_i != 0):
heapq.heappush(q,(c_depth+1,_i-1,_j,swapPuz(c_puz[0:],_i,_j,_i-1,_j)))
if(_i != 2):
heapq.heappush(q,(c_depth+1,_i+1,_j,swapPuz(c_puz[0:],_i,_j,_i+1,_j)))
if(_j != 0):
heapq.heappush(q,(c_depth+1,_i,_j-1,swapPuz(c_puz[0:],_i,_j,_i,_j-1)))
if(_j != 2):
heapq.heappush(q,(c_depth+1,_i,_j+1,swapPuz(c_puz[0:],_i,_j,_i,_j+1)))
def simpleHS(c_puz):
count = 0
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
count+=1
return count
def HS(c_puz):
value = 0
for i in range(len(c_puz)):
k = correctPuz.index(c_puz[i])
_i = (int)(i/3)
_j = i - _i
ki = (int)(k/3)
kj = k - ki
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
swap = c_puz[i*3+j]
c_puz[i*3+j] = c_puz[i2*3+j2]
c_puz[i2*3+j2] = swap
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start)
depth+=1
| import sys;
import heapq
def iterative(i,j):
q = []
heapq.heappush(q,(0,i,j,0,puz))
global finding
while len(q):
items = heapq.heappop(q)
c_depth = items[0]
_i = items[1]
_j = items[2]
prev_move = items[3]
c_puz = items[4]
if(puzzleCheck(c_puz)):
finding = 1
print(c_depth)
break
if((c_depth+simpleHS(c_puz)) >= depth):
continue
if(_i != 0 and prev_move != 1):
heapq.heappush(q,(c_depth+1,_i-1,_j,2,swapPuz(c_puz[0:],_i,_j,_i-1,_j)))
if(_i != 2 and prev_move != 2):
heapq.heappush(q,(c_depth+1,_i+1,_j,1,swapPuz(c_puz[0:],_i,_j,_i+1,_j)))
if(_j != 0 and prev_move != 3):
heapq.heappush(q,(c_depth+1,_i,_j-1,4,swapPuz(c_puz[0:],_i,_j,_i,_j-1)))
if(_j != 2 and prev_move != 4):
heapq.heappush(q,(c_depth+1,_i,_j+1,3,swapPuz(c_puz[0:],_i,_j,_i,_j+1)))
def simpleHS(c_puz):
count = 0
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
count+=1
return count
def HS(c_puz):
value = 0
for i in range(len(c_puz)):
k = correctPuz.index(c_puz[i])
_i = (int)(i/3)
_j = i - _i
ki = (int)(k/3)
kj = k - ki
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
swap = c_puz[i*3+j]
c_puz[i*3+j] = c_puz[i2*3+j2]
c_puz[i2*3+j2] = swap
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start)
depth+=1
| p02245 |
import sys;
import heapq
def iterative(i,j):
q = []
q.append((simpleHS(puz),0,i,j,0,puz))
global finding
while len(q):
items = q.pop()
c_dWithH = items[0]
c_depth = items[1]
_i = items[2]
_j = items[3]
prev_move = items[4]
c_puz = items[5]
if(puzzleCheck(c_puz)):
finding = 1
print(c_depth)
break
if((c_depth+c_dWithH) > depth):
continue
if(_i != 0 and prev_move != 1):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i-1,_j)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),c_depth+1,_i-1,_j,2,swap_puz))
if(_i != 2 and prev_move != 2):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i+1,_j)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),c_depth+1,_i+1,_j,1,swap_puz))
if(_j != 0 and prev_move != 3):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j-1)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),c_depth+1,_i,_j-1,4,swap_puz))
if(_j != 2 and prev_move != 4):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j+1)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),c_depth+1,_i,_j+1,3,swap_puz))
def checkPuzIsExisted(puz,q):
for i in range(len(q)):
exist_puz = q[i][4]
count = 0
for j in range(len(exist_puz)):
if(exist_puz[j] != puz[j]):
count = 1
if(count == 0):
return True
return False
def sumCost(costs):
value = 0
for i in range(len(costs)):
value += costs[i]
return value
def simpleHS(c_puz):
count = 0
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
count+=1
return count
def HS(i,j,num):
k = correctPuz.index(num)
ki = (int)(k/3)
kj = k - ki*3
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
c_puz[i2*3+j2],c_puz[i*3+j] = c_puz[i*3+j],c_puz[i2*3+j2]
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start)
depth+=1
| import sys;
import heapq
def iterative(i,j):
q = []
q.append((simpleHS(puz),0,i,j,0,puz))
global finding
while len(q):
items = q.pop(0)
c_dWithH = items[0]
c_depth = items[1]
_i = items[2]
_j = items[3]
prev_move = items[4]
c_puz = items[5]
if(puzzleCheck(c_puz)):
finding = 1
print(c_depth)
break
if((c_depth+c_dWithH) > depth):
continue
if(_i != 0 and prev_move != 1):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i-1,_j)
q.append((c_depth+1+simpleHS(swap_puz),c_depth+1,_i-1,_j,2,swap_puz))
if(_i != 2 and prev_move != 2):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i+1,_j)
q.append((c_depth+1+simpleHS(swap_puz),c_depth+1,_i+1,_j,1,swap_puz))
if(_j != 0 and prev_move != 3):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j-1)
q.append((c_depth+1+simpleHS(swap_puz),c_depth+1,_i,_j-1,4,swap_puz))
if(_j != 2 and prev_move != 4):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j+1)
q.append((c_depth+1+simpleHS(swap_puz),c_depth+1,_i,_j+1,3,swap_puz))
def checkPuzIsExisted(puz,q):
for i in range(len(q)):
exist_puz = q[i][4]
count = 0
for j in range(len(exist_puz)):
if(exist_puz[j] != puz[j]):
count = 1
if(count == 0):
return True
return False
def sumCost(costs):
value = 0
for i in range(len(costs)):
value += costs[i]
return value
def simpleHS(c_puz):
count = 0
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
count+=1
return count
def HS(i,j,num):
k = correctPuz.index(num)
ki = (int)(k/3)
kj = k - ki*3
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
c_puz[i2*3+j2],c_puz[i*3+j] = c_puz[i*3+j],c_puz[i2*3+j2]
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start)
depth+=1
| p02245 |
import sys;
import heapq
def iterative(i,j):
q = []
q.append((sumCost(costs),0,i,j,0,puz,costs))
global finding
while len(q):
items = q.pop(0)
cost = items[0]
c_depth = items[1]
_i = items[2]
_j = items[3]
prev_move = items[4]
c_puz = items[5]
_costs = items[6]
if(puzzleCheck(c_puz)):
finding = 1
print(c_depth)
break
if((c_depth+cost) >= depth):
continue
if(_i != 0 and prev_move != 1):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i-1,_j)
swap_cost = _costs[0:]
swap_cost[_i*3+_j] = HS(_i,_j,swap_puz[_i*3+_j])
swap_cost[(_i-1)*3+_j] = HS(_i-1,_j,swap_puz[(_i-1)*3+_j])
q.append((c_depth+1+sumCost(swap_cost),c_depth+1,_i-1,_j,2,swap_puz,swap_cost))
if(_i != 2 and prev_move != 2):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i+1,_j)
swap_cost = _costs[0:]
swap_cost[_i*3+_j] = HS(_i,_j,swap_puz[_i*3+_j])
swap_cost[(_i+1)*3+_j] = HS(_i+1,_j,swap_puz[(_i+1)*3+_j])
q.append((c_depth+1+sumCost(swap_cost),c_depth+1,_i+1,_j,1,swap_puz,swap_cost))
if(_j != 0 and prev_move != 3):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j-1)
swap_cost = _costs[0:]
swap_cost[_i*3+_j] = HS(_i,_j,swap_puz[_i*3+_j])
swap_cost[_i*3+_j-1] = HS(_i,_j-1,swap_puz[_i*3+_j-1])
q.append((c_depth+1+sumCost(swap_cost),c_depth+1,_i,_j-1,4,swap_puz,swap_cost))
if(_j != 2 and prev_move != 4):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j+1)
swap_cost = _costs[0:]
swap_cost[_i*3+_j] = HS(_i,_j,swap_puz[_i*3+_j])
swap_cost[_i*3+_j+1] = HS(_i,_j+1,swap_puz[_i*3+_j+1])
q.append((c_depth+1+sumCost(swap_cost),c_depth+1,_i,_j+1,3,swap_puz,swap_cost))
def checkPuzIsExisted(puz,q):
for i in range(len(q)):
exist_puz = q[i][4]
count = 0
for j in range(len(exist_puz)):
if(exist_puz[j] != puz[j]):
count = 1
if(count == 0):
return True
return False
def sumCost(costs):
value = 0
for i in range(len(costs)):
value += costs[i]
return value
def simpleHS(c_puz):
count = 0
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
count+=1
return count
def HS(i,j,num):
k = correctPuz.index(num)
ki = (int)(k/3)
kj = k - ki*3
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
c_puz[i2*3+j2],c_puz[i*3+j] = c_puz[i*3+j],c_puz[i2*3+j2]
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
costs = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
for i in range(len(costs)):
_i = (int)(i/3)
_j = i - _i*3
costs[i] = HS(_i,_j,puz[i])
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start)
depth+=1
| import sys;
import heapq
def iterative(i,j):
q = []
q.append((simpleHS(puz),0,i,j,0,puz))
global finding
while len(q):
items = q.pop(0)
c_dWithH = items[0]
c_depth = items[1]
_i = items[2]
_j = items[3]
prev_move = items[4]
c_puz = items[5]
if(puzzleCheck(c_puz)):
finding = 1
print(c_depth)
break
if((c_depth+c_dWithH) > depth):
continue
if(_i != 0 and prev_move != 1):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i-1,_j)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),c_depth+1,_i-1,_j,2,swap_puz))
if(_i != 2 and prev_move != 2):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i+1,_j)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),c_depth+1,_i+1,_j,1,swap_puz))
if(_j != 0 and prev_move != 3):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j-1)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),c_depth+1,_i,_j-1,4,swap_puz))
if(_j != 2 and prev_move != 4):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j+1)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),c_depth+1,_i,_j+1,3,swap_puz))
def checkPuzIsExisted(puz,q):
for i in range(len(q)):
exist_puz = q[i][4]
count = 0
for j in range(len(exist_puz)):
if(exist_puz[j] != puz[j]):
count = 1
if(count == 0):
return True
return False
def sumCost(costs):
value = 0
for i in range(len(costs)):
value += costs[i]
return value
def simpleHS(c_puz):
count = 0
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
count+=1
return count
def HS(i,j,num):
k = correctPuz.index(num)
ki = (int)(k/3)
kj = k - ki*3
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
c_puz[i2*3+j2],c_puz[i*3+j] = c_puz[i*3+j],c_puz[i2*3+j2]
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
costs = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
for i in range(len(costs)):
_i = (int)(i/3)
_j = i - _i*3
costs[i] = HS(_i,_j,puz[i])
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start)
depth+=1
| p02245 |
import sys;
import heapq
def iterative(i,j):
q = []
heapq.heappush(q,(simpleHS(puz),(0,i,j,0,puz)))
global finding
while len(q):
c_dWithH, items = q.pop(0)
c_depth = items[0]
_i = items[1]
_j = items[2]
prev_move = items[3]
c_puz = items[4]
if(puzzleCheck(c_puz)):
finding = 1
print(c_depth)
break
if((c_dWithH) > depth):
continue
if(_i != 0 and prev_move != 1):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i-1,_j)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),(c_depth+1,_i-1,_j,2,swap_puz)))
if(_i != 2 and prev_move != 2):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i+1,_j)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),(c_depth+1,_i+1,_j,1,swap_puz)))
if(_j != 0 and prev_move != 3):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j-1)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),(c_depth+1,_i,_j-1,4,swap_puz)))
if(_j != 2 and prev_move != 4):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j+1)
heapq.heappush(q,(c_depth+1+simpleHS(swap_puz),(c_depth+1,_i,_j+1,3,swap_puz)))
def checkPuzIsExisted(puz,q):
for i in range(len(q)):
exist_puz = q[i][4]
count = 0
for j in range(len(exist_puz)):
if(exist_puz[j] != puz[j]):
count = 1
if(count == 0):
return True
return False
def sumCost(costs):
value = 0
for i in range(len(costs)):
value += costs[i]
return value
def simpleHS(c_puz):
count = 0
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
count+=1
return count
def HS(i,j,num):
k = correctPuz.index(num)
ki = (int)(k/3)
kj = k - ki*3
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
c_puz[i2*3+j2],c_puz[i*3+j] = c_puz[i*3+j],c_puz[i2*3+j2]
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
costs = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
for i in range(len(costs)):
_i = (int)(i/3)
_j = i - _i*3
costs[i] = HS(_i,_j,puz[i])
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start)
depth+=1
| import sys;
import heapq
def iterative(i,j):
q = []
heapq.heappush(q,(sumcost,(0,i,j,0,puz)))
global finding
while len(q):
c_dWithH, items = heapq.heappop(q)
c_depth = items[0]
_i = items[1]
_j = items[2]
prev_move = items[3]
c_puz = items[4]
_sum_cost = c_dWithH - c_depth
if(c_dWithH - c_depth == 0):
finding = 1
print(c_depth)
break
if(c_dWithH > depth):
continue
c_cost = simpleHS(c_puz,_i,_j)
if(_i != 0 and prev_move != 1):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i-1,_j)
heapq.heappush(q,(c_depth+1+_sum_cost+checkCost(c_cost,simpleHS(c_puz,_i-1,_j),simpleHS(swap_puz,_i,_j),simpleHS(swap_puz,_i-1,_j)),(c_depth+1,_i-1,_j,2,swap_puz)))
if(_i != 2 and prev_move != 2):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i+1,_j)
heapq.heappush(q,(c_depth+1+_sum_cost+checkCost(c_cost,simpleHS(c_puz,_i+1,_j),simpleHS(swap_puz,_i,_j),simpleHS(swap_puz,_i+1,_j)),(c_depth+1,_i+1,_j,1,swap_puz)))
if(_j != 0 and prev_move != 3):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j-1)
heapq.heappush(q,(c_depth+1+_sum_cost+checkCost(c_cost,simpleHS(c_puz,_i,_j-1),simpleHS(swap_puz,_i,_j),simpleHS(swap_puz,_i,_j-1)),(c_depth+1,_i,_j-1,4,swap_puz)))
if(_j != 2 and prev_move != 4):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j+1)
heapq.heappush(q,(c_depth+1+_sum_cost+checkCost(c_cost,simpleHS(c_puz,_i,_j+1),simpleHS(swap_puz,_i,_j),simpleHS(swap_puz,_i,_j+1)),(c_depth+1,_i,_j+1,3,swap_puz)))
def checkCost(c_cost,m_cost,c2_cost,m2_cost):
return c2_cost - c_cost + m2_cost - m_cost
def sumCost(costs):
value = 0
for i in range(len(costs)):
value += costs[i]
return value
def simpleHS(c_puz,i,j):
if(correctPuz[i*3+j] != c_puz[i*3+j]):
return 1
return 0
def HS(i,j,num):
k = correctPuz.index(num)
ki = (int)(k/3)
kj = k - ki*3
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
c_puz[i2*3+j2],c_puz[i*3+j] = c_puz[i*3+j],c_puz[i2*3+j2]
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
sumcost=0
for i in range(len(correctPuz)):
if(correctPuz[i] != puz[i]):
sumcost+=1
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start)
depth+=1
| p02245 |
import sys;
import heapq
def iterative(i,j):
q = []
heapq.heappush(q,(sumcost,(0,i,j,0,puz)))
global finding
while len(q):
c_dWithH, items = heapq.heappop(q)
c_depth = items[0]
_i = items[1]
_j = items[2]
prev_move = items[3]
c_puz = items[4]
_sum_cost = c_dWithH - c_depth
if(c_dWithH - c_depth == 0):
finding = 1
print(c_depth)
break
if(c_dWithH > depth):
continue
c_cost = simpleHS(c_puz,_i,_j)
if(_i != 0 and prev_move != 1):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i-1,_j)
n_cost = c_depth+1+_sum_cost+checkCost(c_cost,simpleHS(c_puz,_i-1,_j),simpleHS(swap_puz,_i,_j),simpleHS(swap_puz,_i-1,_j))
if(n_cost <= depth):
heapq.heappush(q,(n_cost,(c_depth+1,_i-1,_j,2,swap_puz)))
if(_i != 2 and prev_move != 2):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i+1,_j)
n_cost = c_depth+1+_sum_cost+checkCost(c_cost,simpleHS(c_puz,_i+1,_j),simpleHS(swap_puz,_i,_j),simpleHS(swap_puz,_i+1,_j))
if(n_cost <= depth):
heapq.heappush(q,(n_cost,(c_depth+1,_i+1,_j,1,swap_puz)))
if(_j != 0 and prev_move != 3):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j-1)
n_cost = c_depth+1+_sum_cost+checkCost(c_cost,simpleHS(c_puz,_i,_j-1),simpleHS(swap_puz,_i,_j),simpleHS(swap_puz,_i,_j-1))
if(n_cost <= depth):
heapq.heappush(q,(n_cost,(c_depth+1,_i,_j-1,4,swap_puz)))
if(_j != 2 and prev_move != 4):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j+1)
n_cost = c_depth+1+_sum_cost+checkCost(c_cost,simpleHS(c_puz,_i,_j+1),simpleHS(swap_puz,_i,_j),simpleHS(swap_puz,_i,_j+1))
if(n_cost <= depth):
heapq.heappush(q,(n_cost,(c_depth+1,_i,_j+1,3,swap_puz)))
def checkCost(c_cost,m_cost,c2_cost,m2_cost):
return c2_cost - c_cost + m2_cost - m_cost
def sumCost(costs):
value = 0
for i in range(len(costs)):
value += costs[i]
return value
def simpleHS(c_puz,i,j):
if(correctPuz[i*3+j] != c_puz[i*3+j]):
return 1
return 0
def HS(i,j,num):
k = correctPuz.index(num)
ki = (int)(k/3)
kj = k - ki*3
value = abs(_i-ki)+abs(_j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
c_puz[i2*3+j2],c_puz[i*3+j] = c_puz[i*3+j],c_puz[i2*3+j2]
return c_puz
def puzzleCheck(c_puz):
if(c_puz[8] == 0):
for i in range(len(correctPuz)):
if(correctPuz[i] != c_puz[i]):
return False
return True
return False
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
sumcost=0
for i in range(len(correctPuz)):
if(correctPuz[i] != puz[i]):
sumcost+=1
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start)
depth+=1
| import sys;
import heapq
def iterative(i,j):
q = []
heapq.heappush(q,(sumcost,(0,i,j,0,puz)))
global finding
while len(q):
cost, items = heapq.heappop(q)
c_depth = items[0]
_i = items[1]
_j = items[2]
prev_move = items[3]
c_puz = items[4]
_sum_cost = cost - c_depth
if(_sum_cost == 0):
finding = 1
print(c_depth)
break
if(cost > depth):
continue
c_cost = HS(_i,_j,c_puz[_i*3+_j])
if(_i != 0 and prev_move != 1):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i-1,_j)
n_cost = cost+1+checkCost(c_cost,HS(_i-1,_j,c_puz[(_i-1)*3+_j]),HS(_i,_j,swap_puz[_i*3+_j]),HS(_i-1,_j,swap_puz[(_i-1)*3+_j]))
if(n_cost <= depth):
heapq.heappush(q,(n_cost,(c_depth+1,_i-1,_j,2,swap_puz)))
if(_i != 2 and prev_move != 2):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i+1,_j)
n_cost = cost+1+checkCost(c_cost,HS(_i+1,_j,c_puz[(_i+1)*3+_j]),HS(_i,_j,swap_puz[_i*3+_j]),HS(_i+1,_j,swap_puz[(_i+1)*3+_j]))
if(n_cost <= depth):
heapq.heappush(q,(n_cost,(c_depth+1,_i+1,_j,1,swap_puz,)))
if(_j != 0 and prev_move != 3):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j-1)
n_cost = cost+1+checkCost(c_cost,HS(_i,_j-1,c_puz[_i*3+_j-1]),HS(_i,_j,swap_puz[_i*3+_j]),HS(_i,_j-1,swap_puz[_i*3+_j-1]))
if(n_cost <= depth):
heapq.heappush(q,(n_cost,(c_depth+1,_i,_j-1,4,swap_puz)))
if(_j != 2 and prev_move != 4):
swap_puz = swapPuz(c_puz[0:],_i,_j,_i,_j+1)
n_cost = cost+1+checkCost(c_cost,HS(_i,_j+1,c_puz[_i*3+_j+1]),HS(_i,_j,swap_puz[_i*3+_j]),HS(_i,_j+1,swap_puz[_i*3+_j+1]))
if(n_cost <= depth):
heapq.heappush(q,(n_cost,(c_depth+1,_i,_j+1,3,swap_puz)))
def checkCost(c_cost,m_cost,c2_cost,m2_cost):
return c2_cost - c_cost + m2_cost - m_cost
def sumCost(puz):
value = 0
for i in range(3):
value += HS(i,0,puz[i*3])
value += HS(i,1,puz[i*3+1])
value += HS(i,2,puz[i*3+2])
return value
def HS(i,j,num):
if(num != 0):
k = num-1
else:
k = 8
ki = (int)(k/3)
kj = k - ki*3
value = abs(i-ki)+abs(j-kj)
return value
def swapPuz(c_puz, i, j, i2,j2):
c_puz[i2*3+j2],c_puz[i*3+j] = c_puz[i*3+j],c_puz[i2*3+j2]
return c_puz
correctPuz = [i+1 for i in range(9)]
correctPuz[8] = 0
puz = [0 for i in range(9)]
i_start = 0
j_start = 0
for i in range(3):
puz[i*3],puz[i*3+1],puz[i*3+2] = list(map(int, input().split()));
if(puz[i*3] == 0):
i_start,j_start = i,0
elif(puz[i*3+1] == 0):
i_start,j_start = i,1
elif(puz[i*3+2] == 0):
i_start,j_start = i,2
sumcost = sumCost(puz)
finding = 0
depth = 0
while True:
if(finding == 1):
break
iterative(i_start,j_start)
depth+=1
| p02245 |
from collections import deque
from copy import deepcopy, copy
dy = [-1, 0, 0, 1]
dx = [0, -1, 1, 0]
N = 3
def MAIN():
MAP = tuple(sum([input().split() for _ in range(N)], []))
y0, x0 = divmod(MAP.index("0"), N)
goal = ('1', '2', '3', '4', '5', '6', '7', '8', '0')
ans = 0
dp = deque([[y0, x0, 0, MAP]])
LOG = {MAP}
while dp:
y, x, cnt, M = dp.popleft()
if M == goal:
print(cnt)
break
cnt += 1
yx = y * N + x
for ny, nx in ((y - 1, x), (y, x - 1), (y, x + 1), (y + 1, x)):
if 0 <= ny < N and 0 <= nx < N:
CM = list(deepcopy(M))
nyx = ny * N + nx
CM[yx], CM[nyx] = CM[nyx], CM[yx]
CM = tuple(CM)
if not CM in LOG:
dp.append([ny, nx, cnt, CM])
LOG.add(CM)
MAIN()
| from collections import deque
from copy import deepcopy, copy
dy = [-1, 0, 0, 1]
dx = [0, -1, 1, 0]
N = 3
def g(i, j, a):
t = a // (10 ** j) % 10
return a - t * (10 ** j) + t * (10 ** i)
def MAIN():
m = {8:{7, 5}, 7:{8, 6, 4}, 6:{7, 3}, 5:{8, 4, 2}, 4:{7, 5, 3, 1}, 3:{6, 4, 0}, 2:{5, 1}, 1:{4, 2, 0}, 0:{3, 1}}
MAP = "".join(input().replace(" ", "") for _ in range(N))
start = 8 - MAP.find("0")
MAP = int(MAP)
goal = ('1', '2', '3', '4', '5', '6', '7', '8', '0')
goal = 123456780
dp = deque([(0, start, MAP)])
LOG = {MAP}
while dp:
cnt, yx, M = dp.popleft()
if M == goal:
print(cnt)
break
cnt += 1
for nyx in m[yx]:
CM = g(yx, nyx, M)
if not CM in LOG:
dp.append((cnt, nyx, CM))
LOG.add(CM)
MAIN()
| p02245 |
from heapq import heapify, heappush, heappop
from collections import deque
from copy import deepcopy, copy
N = 3
m = {8:{7, 5}, 7:{8, 6, 4}, 6:{7, 3}, 5:{8, 4, 2}, 4:{7, 5, 3, 1}, 3:{6, 4, 0}, 2:{5, 1}, 1:{4, 2, 0}, 0:{3, 1}}
def g(i, j, a):
if i > j:
i, j = j, i
return a[:i] + a[j] + a[i + 1:j] + a[i] + a[j + 1:]
def MAIN():
MAP = "".join(input().replace(" ", "") for _ in range(N))
goal = "123456780"
if MAP == goal:
print((0))
return
start = MAP.find("0")
dp = [(0, MAP, start)]
LOG = {MAP}
while dp:
cnt, M, yx = heappop(dp)
cnt += 1
for nyx in m[yx]:
CM = g(yx, nyx, M)
if not CM in LOG:
if CM == goal:
print(cnt)
return
heappush(dp, (cnt, CM, nyx))
LOG.add(CM)
MAIN()
| from collections import deque
N = 3
def g(i, j, a):
if i > j:
i, j = j, i
return a[:i] + a[j] + a[i + 1:j] + a[i] + a[j + 1:]
goal = "123456780"
def solve():
m = {8:{7, 5}, 7:{8, 6, 4}, 6:{7, 3}, 5:{8, 4, 2}, 4:{7, 5, 3, 1}, 3:{6, 4, 0}, 2:{5, 1}, 1:{4, 2, 0}, 0:{3, 1}}
MAP = "".join(input().replace(" ", "") for _ in range(N))
if MAP == goal:
return 0
start = MAP.find("0")
dp = deque([(0, MAP, start, 1), (0, goal, 8, 0)])
TABLE = {MAP:(1, 0), goal:(0, 0)}
while dp:
cnt, M, yx, flg = dp.popleft()
cnt += 1
for nyx in m[yx]:
CM = g(yx, nyx, M)
if CM in TABLE:
if TABLE[CM][0] != flg:
return TABLE[CM][1] + cnt
continue
TABLE[CM] = (flg, cnt)
dp.append((cnt, CM, nyx, flg))
def MAIN():
print((solve()))
MAIN()
| p02245 |
import sys, itertools
f = sys.stdin
start = [line.split() for line in f]
start = tuple(int(x) for y in start for x in y)
end =(1, 2, 3, 4, 5, 6,7, 8, 0)
d = {start:0}
def next_board(b):
brank = b.index(0)
if brank % 3:
yield b[:brank - 1] + (b[brank], b[brank - 1]) + b[brank + 1:]
if brank // 3:
yield b[:brank - 3] + (b[brank],)+ b[brank - 2:brank] + (b[brank - 3],) + b[brank + 1:]
if brank % 3 != 2:
yield b[:brank] + (b[brank + 1], b[brank]) + b[brank + 2:]
if brank // 3 != 2:
yield b[:brank] + (b[brank + 3],)+ b[brank + 1:brank + 3] + (b[brank],) + b[brank + 4:]
queue = set([start])
while len(queue):
u = queue.pop()
for b in next_board(u):
if b not in d or d[b] > d[u] + 1:
d[b] = d[u] + 1
queue.update([b])
print((d[end])) | from sys import stdin
readline = stdin.readline
adjacent = (
(1, 3), # 0
(0, 2, 4), # 1
(1, 5), # 2
(0, 4, 6), # 3
(1, 3, 5, 7), # 4
(2, 4, 8), # 5
(3, 7), # 6
(4, 6, 8), # 7
(5, 7) # 8
)
def next_board(board, space, prev):
for nxt in adjacent[space]:
if nxt == prev:
continue
b = board[:]
b[space], b[nxt] = b[nxt], 0
yield b, nxt
from heapq import heappop, heappush
end = [1, 2, 3, 4, 5, 6, 7, 8, 0]
# ???????????¨????????°
FORE = 1
BACK = 0
def search(start):
if start == end:
return 0
table = {}
table[tuple(start)] = (FORE, 0)
table[tuple(end)] = (BACK, 0)
heap = [(0, start, start.index(0), None, FORE), (0, end, end.index(0), None, BACK)]
while heap:
i, board, space, prev, direction = heappop(heap)
i += 1
for b, nxt in next_board(board, space, prev):
key = tuple(b)
if key in table:
if table[key][0] != direction:
return table[key][1] + i
continue
table[key] = (direction, i)
if b == end:
return i
heappush(heap, (i, b, nxt, space, direction))
def main():
start = (list(map(int, readline().split())) for _ in range(3))
start = [y for x in start for y in x]
print((search(start)))
main() | p02245 |
# -*- coding: utf-8 -*-
from collections import deque
import copy
class Puzzle(list):
def __init__(self):
list.__init__(self)
self.space = None
self.path = ""
def __hash__(self):
return hash(str(self[:]))
if __name__ == '__main__':
N = 3
N2 = 9
dx = [-1, 0, 1, 0]
dy = [0, -1, 0, 1]
d = ["u", "l", "d", "r"]
p = Puzzle()
for i in range(N):
p += [int(x) for x in input().split()]
for i in range(N2):
if p[i] == 0:
p[i] = N2
p.space = i
target = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def isTarget(p):
return p[:] == target[:]
def bfs(s):
Q = deque()
V = set()
Q.append(s)
V.add(s)
while Q:
u = Q.popleft()
if isTarget(u):
return u.path
sx = u.space // N
sy = u.space % N
for r in range(4):
tx = sx + dx[r]
ty = sy + dy[r]
if not (0<= tx < N and 0 <= ty < N):
continue
v = copy.copy(u)
v[u.space], v[tx * N + ty] = v[tx * N + ty], v[u.space]
v.space = tx * N + ty
if not v in V:
V.add(v)
v.path += d[r]
Q.append(v)
return "unsolvable"
ans = bfs(p)
print((len(ans)))
| # -*- coding: utf-8 -*-
from collections import deque
import copy
class Puzzle(list):
def __init__(self):
list.__init__(self)
self.space = None
self.path = ""
def __hash__(self):
return hash(str(self[:]))
if __name__ == '__main__':
N = 3
N2 = 9
dx = [-1, 0, 1, 0]
dy = [0, -1, 0, 1]
d = ["u", "l", "d", "r"]
p = Puzzle()
for i in range(N):
p += [int(x) for x in input().split()]
for i in range(N2):
if p[i] == 0:
p[i] = N2
p.space = i
target = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def isTarget(p):
return p[:] == target[:]
def bfs(s):
Q = deque()
V = set()
Q.append(s)
V.add(s)
while Q:
u = Q.popleft()
if isTarget(u):
return u.path
sx = u.space // N
sy = u.space % N
for r in range(4):
tx = sx + dx[r]
ty = sy + dy[r]
if not (0<= tx < N and 0 <= ty < N):
continue
v = copy.copy(u)
change = tx * N + ty
v[u.space], v[change] = v[change], v[u.space]
v.space = change
if not v in V:
V.add(v)
v.path += d[r]
Q.append(v)
return "unsolvable"
ans = bfs(p)
print((len(ans)))
| p02245 |
# -*- coding: utf-8 -*-
from collections import deque
import copy
class Puzzle(list):
def __init__(self):
list.__init__(self)
self.space = None
self.path = ""
def __hash__(self):
return hash(str(self[:]))
if __name__ == '__main__':
N = 3
N2 = 9
dx = [-1, 0, 1, 0]
dy = [0, -1, 0, 1]
d = ["u", "l", "d", "r"]
p = Puzzle()
for i in range(N):
p += [int(x) for x in input().split()]
for i in range(N2):
if p[i] == 0:
p[i] = N2
p.space = i
target = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def isTarget(p):
return p[:] == target[:]
def bfs(s):
Q = deque()
V = set()
Q.append(s)
V.add(s)
while Q:
u = Q.popleft()
if isTarget(u):
return u.path
sx = u.space // N
sy = u.space % N
for r in range(4):
tx = sx + dx[r]
ty = sy + dy[r]
if not (0<= tx < N and 0 <= ty < N):
continue
v = copy.copy(u)
change = tx * N + ty
v[u.space], v[change] = v[change], v[u.space]
v.space = change
if not v in V:
V.add(v)
v.path += d[r]
Q.append(v)
return "unsolvable"
ans = bfs(p)
print((len(ans)))
| # -*- coding: utf-8 -*-
from collections import deque
import copy
class Puzzle(list):
def __init__(self):
list.__init__(self)
self.space = None
self.path = ""
def __hash__(self):
return hash(str(self[:]))
if __name__ == '__main__':
N = 3
N2 = 9
dx = [-1, 0, 1, 0]
dy = [0, -1, 0, 1]
d = ["u", "l", "d", "r"]
p = Puzzle()
for i in range(N):
p += [int(x) for x in input().split()]
for i in range(N2):
if p[i] == 0:
p[i] = N2
p.space = i
target = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def isTarget(p):
return p[:] == target[:]
def bfs(s):
Q = deque()
V = set()
Q.append(s)
V.add(s)
while Q:
u = Q.popleft()
if isTarget(u):
return u.path
sx = u.space // N
sy = u.space % N
for r in range(4):
tx = sx + dx[r]
ty = sy + dy[r]
if not (0<= tx < N and 0 <= ty < N):
continue
v = Puzzle()
v[:] = u[:]
v.path = u.path
change = tx * N + ty
v[u.space], v[change] = v[change], v[u.space]
v.space = change
if not v in V:
V.add(v)
v.path += d[r]
Q.append(v)
return "unsolvable"
ans = bfs(p)
print((len(ans)))
| p02245 |
import copy
def hashnum(state):
num = 0
for i in range(3):
for j in range(3):
num *= 10
num += state[i][j]
return num
answer = 123456780
ini_state = []
for i in range(3):
temp = [int(n) for n in input().split(" ")]
if 0 in temp:
zero_x, zero_y = temp.index(0), i
ini_state.append(temp)
queue = [[ini_state, zero_x, zero_y]]
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
visited = set()
visited |= {hashnum(ini_state)}
trial = 0
while answer not in visited:
new_queue = []
for q in queue:
state, zero_x, zero_y = q
for i in range(len(dx)):
new_state = copy.deepcopy(state)
new_x = zero_x + dx[i]
new_y = zero_y + dy[i]
if 0 <= new_x < 3 and 0 <= new_y < 3:
new_state[new_y][new_x], new_state[zero_y][zero_x] = new_state[zero_y][zero_x], new_state[new_y][new_x]
perm = hashnum(new_state)
if perm not in visited:
visited |= {perm}
new_queue.append([new_state, new_x, new_y])
queue = new_queue
trial += 1
print(trial) | import copy
def hashnum(state):
num = 0
for i in range(3):
for j in range(3):
num *= 10
num += state[i][j]
return num
answer = 123456780
ini_state = []
for i in range(3):
temp = [int(n) for n in input().split(" ")]
if 0 in temp:
zero_x, zero_y = temp.index(0), i
ini_state.append(temp)
queue = [[ini_state, zero_x, zero_y]]
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
visited = set()
visited |= {hashnum(ini_state)}
trial = 0
while answer not in visited:
new_queue = []
trial += 1
for q in queue:
state, zero_x, zero_y = q
for i in range(len(dx)):
new_state = copy.deepcopy(state)
new_x = zero_x + dx[i]
new_y = zero_y + dy[i]
if 0 <= new_x < 3 and 0 <= new_y < 3:
new_state[new_y][new_x], new_state[zero_y][zero_x] = new_state[zero_y][zero_x], new_state[new_y][new_x]
perm = hashnum(new_state)
if perm == answer:
print(trial)
exit()
if perm not in visited:
visited |= {perm}
new_queue.append([new_state, new_x, new_y])
queue = new_queue
# print(trial) | p02245 |
import copy
def hashnum(state):
num = 0
for i in range(3):
for j in range(3):
num *= 10
num += state[i][j]
return num
answer = 123456780
ini_state = []
for i in range(3):
temp = [int(n) for n in input().split(" ")]
if 0 in temp:
zero_x, zero_y = temp.index(0), i
ini_state.append(temp)
queue = [[ini_state, zero_x, zero_y]]
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
visited = set()
visited |= {hashnum(ini_state)}
trial = 0
while answer not in visited:
new_queue = []
trial += 1
for q in queue:
state, zero_x, zero_y = q
for i in range(len(dx)):
new_state = copy.deepcopy(state)
new_x = zero_x + dx[i]
new_y = zero_y + dy[i]
if 0 <= new_x < 3 and 0 <= new_y < 3:
new_state[new_y][new_x], new_state[zero_y][zero_x] = new_state[zero_y][zero_x], new_state[new_y][new_x]
perm = hashnum(new_state)
if perm == answer:
print(trial)
exit()
if perm not in visited:
visited |= {perm}
new_queue.append([new_state, new_x, new_y])
queue = new_queue
# print(trial) | import copy
def hashnum(state):
num = 0
for i in range(3):
for j in range(3):
num *= 10
num += state[i][j]
return num
answer = 123456780
ini_state = []
for i in range(3):
temp = [int(n) for n in input().split(" ")]
if 0 in temp:
zero_x, zero_y = temp.index(0), i
ini_state.append(temp)
end_state = [[1, 2, 3], [4, 5, 6], [7, 8, 0]]
queue = [[ini_state, zero_x, zero_y, 0], [end_state, 2, 2, 1]]
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
visited = {}
if hashnum(ini_state) == answer:
print((0))
else:
visited[hashnum(ini_state)] = [0, 0]
visited[answer] = [0, 1]
trial = 0
ended = 0
while queue:
new_queue = []
trial += 1
for q in queue:
if ended:
break
state, zero_x, zero_y, direction = q
for i in range(len(dx)):
new_state = copy.deepcopy(state)
new_x = zero_x + dx[i]
new_y = zero_y + dy[i]
if 0 <= new_x < 3 and 0 <= new_y < 3:
new_state[new_y][new_x], new_state[zero_y][zero_x] = new_state[zero_y][zero_x], new_state[new_y][new_x]
perm = hashnum(new_state)
if perm in visited and direction != visited[perm][1]:
print((trial + visited[perm][0]))
ended = 1
break
elif perm not in visited:
visited[perm] = [trial, direction]
new_queue.append([new_state, new_x, new_y, direction])
queue = new_queue | p02245 |
# 8 Puzzle
import copy
z = 0
[N, d] = [3, 0]
check_flag = [[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4],
[2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1],
[3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2],
[4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3],
[3, 2, 1, 4, 3, 2, 1, 4, 3, 2, 1, 4],
[2, 1, 4, 3, 2, 1, 4, 3, 2, 1, 4, 3],
[1, 4, 3, 2, 1, 4, 3, 2, 1, 4, 3, 2],
[4, 3, 2, 1, 4, 3, 2, 1, 4, 3, 2, 1]]
start = []
goal = [[i + j*N for i in range(1, N + 1)] for j in range(N)]
goal[2][2] = 0
for i in range(N):
start.append(list(map(int, input().split())))
def manhattan(value, pairs):
h = 0
if value == 1:
h = (pairs[0] + pairs[1])
if value == 2:
h = (pairs[0] + abs(pairs[1] - 1))
if value == 3:
h = (pairs[0] + abs(pairs[1] - 2))
if value == 4:
h = (abs(pairs[0] - 1) + pairs[1])
if value == 5:
h = (abs(pairs[0] - 1) + abs(pairs[1] - 1))
if value == 6:
h = (abs(pairs[0] - 1) + abs(pairs[1] - 2))
if value == 7:
h = (abs(pairs[0] - 2) + pairs[1])
if value == 8:
h = (abs(pairs[0] - 2) + abs(pairs[1] - 1))
return h
def flag_array(flag, input):
flag.pop(0)
flag.append(input)
return flag
s_h = 0
for i in range(N):
for j in range(N):
s_h += manhattan(start[i][j], [i, j])
# print(s_h)
for i in range(N):
check = start[i].count(0)
if check != 0:
[s_r, s_c] = [i, start[i].index(0)]
break
if i == 3:
print("Error")
while True:
d += 1
queue = []
flag = [0 for i in range(12)]
queue.append([s_h, start, 0, [s_r, s_c], flag])
#while True:
while len(queue) != 0:
#print("Q: ", len(queue), "depth: ", d)
short_n = queue.pop(0)
h = short_n[0] - short_n[2]
state = short_n[1]
g = short_n[2]
[r, c] = short_n[3]
flag = short_n[4]
#print("left_Q: ", len(queue), "depth: ", d, "h: ", h, "g: ", g, "state: ", state, "g+h: ", short_n[0], "flag: ", flag[len(flag) - 1])
#print("left_Q: ", len(queue), "depth: ", d, "h: ", h, "g: ", g, "flag: ", flag, "g+h: ", short_n[0])
#if d == 1:
#print(short_n[0])
#print(state)
#print(g)
if h == 0:
print((short_n[2]))
#print(z)
break
"""
if flag in check_flag:
z += 1
continue
"""
if r - 1 >= 0 and flag[len(flag) - 1] != 3:
[temp, temp_array] = [copy.deepcopy(state), flag[:]]
h = short_n[0] - short_n[2] - manhattan(temp[r - 1][c], [r - 1, c]) + manhattan(temp[r - 1][c], [r, c])
[temp[r][c], temp[r - 1][c]] = [temp[r - 1][c], temp[r][c]]
#if temp[r][c] != goal[r][c]:
#[r, c] = [r - 1, c]
#if temp
#h = manhattan(temp)
#print("1: ", h, temp)
if g + 1 + h <= d:
queue.append([h + g + 1, temp, g + 1, [r - 1, c], flag_array(temp_array, 1)])
if c + 1 < N and flag[len(flag) - 1] != 4:
#print("2: ")
[temp, temp_array] = [copy.deepcopy(state), flag[:]]
#temp_array = copy.deepcopy(flag)
h = short_n[0] - short_n[2] - manhattan(temp[r][c + 1], [r, c + 1]) + manhattan(temp[r][c + 1], [r, c])
[temp[r][c], temp[r][c + 1]] = [temp[r][c + 1], temp[r][c]]
#queue.append(calculate(temp, g + 1))
#print("2: ", h, temp)
if g + 1 + h <= d:
queue.append([h + g + 1, temp, g + 1, [r, c + 1], flag_array(temp_array, 2)])
if r + 1 < N and flag[len(flag) - 1] != 1:
#print("3: ")
[temp, temp_array] = [copy.deepcopy(state), flag[:]]
#temp_array = copy.deepcopy(flag)
h = short_n[0] - short_n[2] - manhattan(temp[r + 1][c], [r + 1, c]) + manhattan(temp[r + 1][c], [r, c])
[temp[r][c], temp[r + 1][c]] = [temp[r + 1][c], temp[r][c]]
#queue.append(calculate(temp, g + 1))
#print("3: ", h, temp)
if g + 1 + h <= d:
queue.append([h + g + 1, temp, g + 1, [r + 1, c], flag_array(temp_array, 3)])
if c - 1 >= 0 and flag[len(flag) - 1] != 2:
#print("4: ")
[temp, temp_array] = [copy.deepcopy(state), flag[:]]
h = short_n[0] - short_n[2] - manhattan(temp[r][c - 1], [r, c - 1]) + manhattan(temp[r][c - 1], [r, c])
[temp[r][c], temp[r][c - 1]] = [temp[r][c - 1], temp[r][c]]
if g + 1 + h <= d:
queue.append([h + g + 1, temp, g + 1, [r, c - 1], flag_array(temp_array, 4)])
queue.sort(key = lambda data:data[0])
queue.sort(key = lambda data:data[2], reverse = True)
data = []
g_data = []
#print(queue)
"""
for i in range(len(queue)):
data.append(str(queue[i][0]))
g_data.append(str(queue[i][2]))
#print(queue[i])
print("g+h: ",' '.join(data))
print("g: ",' '.join(g_data))
"""
#if d == 1:
#print(len(queue))
if state == goal:
break
| # 8 Puzzle
import copy
[N, d] = [3, 0]
start = []
goal = [[i + j*N for i in range(1, N + 1)] for j in range(N)]
goal[2][2] = 0
for i in range(N):
start.append(list(map(int, input().split())))
def manhattan(value, pairs):
h = 0
if value == 1:
h = (pairs[0] + pairs[1])
if value == 2:
h = (pairs[0] + abs(pairs[1] - 1))
if value == 3:
h = (pairs[0] + abs(pairs[1] - 2))
if value == 4:
h = (abs(pairs[0] - 1) + pairs[1])
if value == 5:
h = (abs(pairs[0] - 1) + abs(pairs[1] - 1))
if value == 6:
h = (abs(pairs[0] - 1) + abs(pairs[1] - 2))
if value == 7:
h = (abs(pairs[0] - 2) + pairs[1])
if value == 8:
h = (abs(pairs[0] - 2) + abs(pairs[1] - 1))
return h
s_h = 0
for i in range(N):
for j in range(N):
s_h += manhattan(start[i][j], [i, j])
for i in range(N):
check = start[i].count(0)
if check != 0:
[s_r, s_c] = [i, start[i].index(0)]
break
if i == 3:
print("Error")
while True:
d += 1
flag = 0
queue = [[s_h, start, 0, [s_r, s_c], flag]]
while len(queue) != 0:
short_n = queue.pop(0)
h = short_n[0] - short_n[2]
state = short_n[1]
g = short_n[2]
[r, c] = short_n[3]
flag = short_n[4]
if h == 0:
print((short_n[2]))
break
if r - 1 >= 0 and flag != 3:
temp = copy.deepcopy(state)
h = short_n[0] - short_n[2] - manhattan(temp[r - 1][c], [r - 1, c]) + manhattan(temp[r - 1][c], [r, c])
[temp[r][c], temp[r - 1][c]] = [temp[r - 1][c], temp[r][c]]
if g + 1 + h <= d:
queue.append([h + g + 1, temp, g + 1, [r - 1, c], 1])
if c + 1 < N and flag != 4:
temp = copy.deepcopy(state)
h = short_n[0] - short_n[2] - manhattan(temp[r][c + 1], [r, c + 1]) + manhattan(temp[r][c + 1], [r, c])
[temp[r][c], temp[r][c + 1]] = [temp[r][c + 1], temp[r][c]]
if g + 1 + h <= d:
queue.append([h + g + 1, temp, g + 1, [r, c + 1], 2])
if r + 1 < N and flag != 1:
temp = copy.deepcopy(state)
h = short_n[0] - short_n[2] - manhattan(temp[r + 1][c], [r + 1, c]) + manhattan(temp[r + 1][c], [r, c])
[temp[r][c], temp[r + 1][c]] = [temp[r + 1][c], temp[r][c]]
if g + 1 + h <= d:
queue.append([h + g + 1, temp, g + 1, [r + 1, c], 3])
if c - 1 >= 0 and flag != 2:
temp = copy.deepcopy(state)
h = short_n[0] - short_n[2] - manhattan(temp[r][c - 1], [r, c - 1]) + manhattan(temp[r][c - 1], [r, c])
[temp[r][c], temp[r][c - 1]] = [temp[r][c - 1], temp[r][c]]
if g + 1 + h <= d:
queue.append([h + g + 1, temp, g + 1, [r, c - 1], 4])
queue.sort(key = lambda data:data[0])
queue.sort(key = lambda data:data[2], reverse = True)
data = []
g_data = []
if state == goal:
break
| p02245 |
v,e = list(map(int, input().split()))
adj = [list(map(int, input().split())) for i in range(e)]
adj.sort(key = lambda x:x[2])
group = [[i] for i in range(v)]
key = [i for i in range(v)]
sum = 0
for i,j,k in adj:
if key[i] != key[j]:
h = key[j]
group[key[i]] += group[h]
sum += k
for t in group[h]:
key[t] = key[i]
group[h] = []
if len(group[key[i]]) == v:
break
print(sum)
| def root(x):
if par[x] == x:
return x
par[x] = root(par[x])
return par[x]
def same(x, y):
return root(x) == root(y)
def unite(x, y):
x = root(x)
y = root(y)
par[x] = y
v,e = list(map(int, input().split()))
adj = [list(map(int, input().split())) for i in range(e)]
adj.sort(key = lambda x:x[2])
par = [i for i in range(v)]
sum = 0
for i,j,k in adj:
if not same(i, j):
sum += k
unite(i, j)
print(sum)
| p02364 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
6 9
0 1 1
0 2 3
1 2 1
1 3 7
2 4 1
1 4 3
3 4 1
3 5 1
4 5 6
output:
5
"""
import sys
import heapq as hp
WHITE, GRAY, BLACK = 0, 1, 2
def generate_adj_table(v_table):
for each in v_table:
v_from, v_to, edge_weight = list(map(int, each))
init_adj_table[v_from][v_to] = edge_weight
init_adj_table[v_to][v_from] = edge_weight
return init_adj_table
def prim_span_tree():
distance[init_v] = 0
parent[init_v] = -1
path_heap = []
hp.heappush(path_heap, (distance[init_v], init_v))
while len(path_heap) >= 1:
current_vertex = hp.heappop(path_heap)[1]
color[current_vertex] = BLACK
for adj_vertex, adj_weight in list(adj_table[current_vertex].items()):
if color[adj_vertex] is not BLACK:
if adj_weight < distance[adj_vertex]:
distance[adj_vertex] = adj_weight
parent[adj_vertex] = current_vertex
color[adj_vertex] = GRAY
hp.heappush(path_heap, (adj_weight, adj_vertex))
return distance
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:]]
parent = [-1] * vertices
distance = [float('inf')] * vertices
color = [WHITE] * vertices
init_v = 0
init_adj_table = tuple(dict() for _ in range(vertices))
adj_table = generate_adj_table(v_info)
print((sum(prim_span_tree()))) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
6 9
0 1 1
0 2 3
1 2 1
1 3 7
2 4 1
1 4 3
3 4 1
3 5 1
4 5 6
output:
5
"""
import sys
import heapq as hp
WHITE, GRAY, BLACK = 0, 1, 2
def generate_adj_table(v_table):
for each in v_table:
v_from, v_to, edge_weight = list(map(int, each))
init_adj_table[v_from][v_to] = edge_weight
init_adj_table[v_to][v_from] = edge_weight
return init_adj_table
def prim_span_tree():
distance[init_v] = 0
parent[init_v] = -1
path_heap = []
hp.heappush(path_heap, (0, init_v))
while len(path_heap) >= 1:
current_vertex = hp.heappop(path_heap)[1]
color[current_vertex] = BLACK
for adj_vertex, adj_weight in list(adj_table[current_vertex].items()):
if color[adj_vertex] is not BLACK:
if adj_weight < distance[adj_vertex]:
distance[adj_vertex] = adj_weight
parent[adj_vertex] = current_vertex
color[adj_vertex] = GRAY
hp.heappush(path_heap, (adj_weight, adj_vertex))
return distance
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:]]
parent = [-1] * vertices
distance = [float('inf')] * vertices
color = [WHITE] * vertices
init_v = 0
init_adj_table = tuple(dict() for _ in range(vertices))
adj_table = generate_adj_table(v_info)
print((sum(prim_span_tree()))) | p02364 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
6 9
0 1 1
0 2 3
1 2 1
1 3 7
2 4 1
1 4 3
3 4 1
3 5 1
4 5 6
output:
5
"""
import sys
from operator import attrgetter
class Edge(object):
__slots__ = ('source', 'target', 'weight')
def __init__(self):
self.weight = float('inf')
self.source, self.target = None, None
class UnionFind(object):
__slots__ = ('size', 'tree_height_rank_list', 'ancestor_list')
def __init__(self, size):
self.size = int(size)
self.tree_height_rank_list = [0] * self.size
self.ancestor_list = [i for i in range(self.size)]
def _find(self, x):
if x != self.ancestor_list[x]:
self.ancestor_list[x] = self._find(self.ancestor_list[x])
return self.ancestor_list[x]
def same(self, x, y):
return self._find(x) == self._find(y)
def _link(self, x, y):
if self.tree_height_rank_list[x] > self.tree_height_rank_list[y]:
self.ancestor_list[y] = x
else:
self.ancestor_list[x] = y
if self.tree_height_rank_list[x] == self.tree_height_rank_list[y]:
self.tree_height_rank_list[y] += 1
def union(self, x, y):
self._link(self._find(x), self._find(y))
def generate_edge_table(v_table):
for index, each in enumerate(v_table):
source, target, weight = list(map(int, each))
init_edge_table[index].source = source
init_edge_table[index].target = target
init_edge_table[index].weight = weight
return init_edge_table
def graph_Kruskal():
total_cost = 0
edge_table.sort(key=attrgetter('weight'))
# MST--> E = V + 1
union_find_case = UnionFind(size=vertices + 1)
for edge in edge_table:
if not union_find_case.same(edge.source, edge.target):
total_cost += edge.weight
union_find_case.union(edge.source, edge.target)
return total_cost
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:]]
init_edge_table = [Edge() for _ in range(edges)]
edge_table = generate_edge_table(v_info)
print((graph_Kruskal())) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
6 9
0 1 1
0 2 3
1 2 1
1 3 7
2 4 1
1 4 3
3 4 1
3 5 1
4 5 6
output:
5
"""
import sys
import heapq as hp
WHITE, GRAY, BLACK = 0, 1, 2
def generate_adj_table(v_table):
for each in v_table:
v_from, v_to, edge_weight = list(map(int, each))
init_adj_table[v_from][v_to] = edge_weight
init_adj_table[v_to][v_from] = edge_weight
return init_adj_table
def prim_span_tree():
distance[init_v] = 0
distance_heap = []
hp.heappush(distance_heap, (0, init_v))
while distance_heap:
current_vertex = hp.heappop(distance_heap)[1]
color[current_vertex] = BLACK
for adj_vertex, adj_weight in list(adj_table[current_vertex].items()):
if color[adj_vertex] is not BLACK:
if adj_weight < distance[adj_vertex]:
distance[adj_vertex] = adj_weight
parent[adj_vertex] = current_vertex
color[adj_vertex] = GRAY
hp.heappush(distance_heap, (adj_weight, adj_vertex))
return distance
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:]]
parent = [-1] * vertices
distance = [float('inf')] * vertices
color = [WHITE] * vertices
init_v = 0
init_adj_table = tuple(dict() for _ in range(vertices))
adj_table = generate_adj_table(v_info)
print((sum(prim_span_tree()))) | p02364 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
6 9
0 1 1
0 2 3
1 2 1
1 3 7
2 4 1
1 4 3
3 4 1
3 5 1
4 5 6
output:
5
"""
import sys
from operator import attrgetter
class Edge(object):
__slots__ = ('source', 'target', 'weight')
def __init__(self):
self.weight = float('inf')
self.source, self.target = None, None
class UnionFind(object):
__slots__ = ('size', 'tree_height_rank_list', 'ancestor_list')
def __init__(self, size):
self.size = int(size)
self.tree_height_rank_list = [0] * self.size
self.ancestor_list = [i for i in range(self.size)]
def _find(self, x):
if x != self.ancestor_list[x]:
self.ancestor_list[x] = self._find(self.ancestor_list[x])
return self.ancestor_list[x]
def same(self, x, y):
return self._find(x) == self._find(y)
def _link(self, x, y):
if self.tree_height_rank_list[x] > self.tree_height_rank_list[y]:
self.ancestor_list[y] = x
else:
self.ancestor_list[x] = y
if self.tree_height_rank_list[x] == self.tree_height_rank_list[y]:
self.tree_height_rank_list[y] += 1
def union(self, x, y):
self._link(self._find(x), self._find(y))
def generate_edge_table(v_table):
for index, each in enumerate(v_table):
source, target, weight = list(map(int, each))
init_edge_table[index].source = source
init_edge_table[index].target = target
init_edge_table[index].weight = weight
return init_edge_table
def graph_Kruskal():
total_cost = 0
# sort edge_table by edge's weight
edge_table.sort(key=attrgetter('weight'))
# MST--> E = V + 1
union_find_case = UnionFind(size=vertices + 1)
for edge in edge_table:
if not union_find_case.same(edge.source, edge.target):
total_cost += edge.weight
union_find_case.union(edge.source, edge.target)
return total_cost
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:]]
init_edge_table = [Edge() for _ in range(edges)]
edge_table = generate_edge_table(v_info)
print((graph_Kruskal())) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
6 9
0 1 1
0 2 3
1 2 1
1 3 7
2 4 1
1 4 3
3 4 1
3 5 1
4 5 6
output:
5
"""
import sys
from operator import attrgetter
class Edge(object):
__slots__ = ('source', 'target', 'weight')
def __init__(self):
self.weight = float('inf')
self.source, self.target = None, None
class UnionFind(object):
__slots__ = ('size', 'tree_height_rank', 'ancestors')
def __init__(self, size):
self.size = int(size)
self.tree_height_rank = [0] * self.size
self.ancestors = [i for i in range(self.size)]
def _find(self, x):
if x != self.ancestors[x]:
self.ancestors[x] = self._find(self.ancestors[x])
return self.ancestors[x]
def same(self, x, y):
return self._find(x) == self._find(y)
def _link(self, x, y):
if self.tree_height_rank[x] > self.tree_height_rank[y]:
self.ancestors[y] = x
else:
self.ancestors[x] = y
if self.tree_height_rank[x] == self.tree_height_rank[y]:
self.tree_height_rank[y] += 1
def union(self, x, y):
self._link(self._find(x), self._find(y))
def generate_edge_table(v_table):
for index, each in enumerate(v_table):
source, target, weight = list(map(int, each))
edge = init_edge_table[index]
edge.source = source
edge.target = target
edge.weight = weight
return init_edge_table
def graph_Kruskal():
total_cost = 0
# sort edge_table by edge's weight
edge_table.sort(key=attrgetter('weight'))
# MST--> E = V + 1
union_find_case = UnionFind(size=vertices + 1)
for edge in edge_table:
if not union_find_case.same(edge.source, edge.target):
total_cost += edge.weight
union_find_case.union(edge.source, edge.target)
return total_cost
if __name__ == '__main__':
_input = sys.stdin.readlines()
vertices, edges = list(map(int, _input[0].split()))
v_info = [x.split() for x in _input[1:]]
init_edge_table = [Edge() for _ in range(edges)]
edge_table = generate_edge_table(v_info)
print((graph_Kruskal())) | p02364 |
import sys
class UnionFind:
def __init__(self, node_size):
self._node = node_size
self.par = [i for i in range(self._node)]
self.rank = [0] * self._node
def find(self, ver):
if self.par[ver] == ver:
return ver
else:
self.par[ver] = self.find(self.par[ver])
return self.par[ver]
def unite(self, ver1, ver2):
ver1, ver2 = self.find(ver1), self.find(ver2)
if ver1 == ver2:
return
if self.rank[ver1] < self.rank[ver2]:
ver1, ver2 = ver2, ver1
self.par[ver2] = ver1
if self.rank[ver1] == self.rank[ver2]:
self.rank[ver1] += 1
def same(self, ver1, ver2):
return self.find(ver1) == self.find(ver2)
class Kruskal:
class Edge:
def __init__(self, u, v, cost):
self.u, self.v, self.cost = u, v, cost
def __lt__(self, another):
return self.cost < another.cost
def __init__(self, node_size):
self._node = node_size
self._edge_list = []
def add_edge(self, u, v, cost):
self._edge_list.append(self.Edge(u, v, cost))
def solve(self):
uf = UnionFind(self._node)
res = 0
edge_count = 0
sorted_edge_list = sorted(self._edge_list)
for e in sorted_edge_list:
if not uf.same(e.u, e.v):
uf.unite(e.u, e.v)
res += e.cost
edge_count += 1
if edge_count == self._node-1:
break
return res
if __name__ == '__main__':
n, m = list(map(int, sys.stdin.readline().split()))
kr = Kruskal(n)
for _ in range(m):
s, t, w = list(map(int, sys.stdin.readline().split()))
kr.add_edge(s, t, w)
print((kr.solve()))
| import sys
class UnionFind:
def __init__(self, node_size):
self._node = node_size
self.par = [i for i in range(self._node)]
self.rank = [0] * self._node
def find(self, ver):
if self.par[ver] == ver:
return ver
else:
self.par[ver] = self.find(self.par[ver])
return self.par[ver]
def unite(self, ver1, ver2):
ver1, ver2 = self.find(ver1), self.find(ver2)
if ver1 == ver2:
return
if self.rank[ver1] < self.rank[ver2]:
ver1, ver2 = ver2, ver1
self.par[ver2] = ver1
if self.rank[ver1] == self.rank[ver2]:
self.rank[ver1] += 1
def same(self, ver1, ver2):
return self.find(ver1) == self.find(ver2)
class Kruskal:
class Edge:
def __init__(self, u, v, cost):
self.u, self.v, self.cost = u, v, cost
def __lt__(self, another):
return self.cost < another.cost
def __init__(self, node_size):
self._node = node_size
self._edge_list = []
def add_edge(self, u, v, cost):
self._edge_list.append(self.Edge(u, v, cost))
def solve(self):
uf = UnionFind(self._node)
res = 0
edge_count = 0
self._edge_list.sort()
for e in self._edge_list:
if not uf.same(e.u, e.v):
uf.unite(e.u, e.v)
res += e.cost
edge_count += 1
if edge_count == self._node-1:
break
return res
if __name__ == '__main__':
n, m = list(map(int, sys.stdin.readline().split()))
kr = Kruskal(n)
for _ in range(m):
s, t, w = list(map(int, sys.stdin.readline().split()))
kr.add_edge(s, t, w)
print((kr.solve()))
| p02364 |
import sys
def kruskal(v_count: int, edges: list) -> int:
tree = [-1]*v_count
def get_root(x):
if tree[x] < 0:
return x
tree[x] = get_root(tree[x])
return tree[x]
def unite(x, y):
x, y = get_root(x), get_root(y)
if x != y:
big, small = (x, y) if tree[x] < tree[y] else (y, x)
tree[big] += tree[small]
tree[small] = big
return x != y
cost = 0
for (w, _s, _t), _ in zip([p for p in sorted(edges) if unite(*p[1:])],
list(range(v_count-1))):
cost += w
return cost
V, E = list(map(int, input().split()))
edges = [(w, s, t) for s, t, w in (list(map(int, l.split())) for l in sys.stdin)]
print((kruskal(V, edges)))
| import sys
from itertools import islice
def kruskal(v_count: int, edges: list) -> int:
tree = [-1]*v_count
def get_root(x):
if tree[x] < 0:
return x
tree[x] = get_root(tree[x])
return tree[x]
def unite(a):
x, y = get_root(a[1]), get_root(a[2])
if x != y:
big, small = (x, y) if tree[x] < tree[y] else (y, x)
tree[big] += tree[small]
tree[small] = big
return x != y
cost = 0
for w, _s, _t in islice(list(filter(unite, sorted(edges))), v_count-1):
cost += w
return cost
V, E = list(map(int, input().split()))
edges = [(w, s, t) for s, t, w in (list(map(int, l.split())) for l in sys.stdin)]
print((kruskal(V, edges)))
| p02364 |
from heapq import heappush, heappop
class Prim:
""" find minimum spanning tree by Prim's algorithm
"""
def __init__(self, V, E, start=0, INF=10**9):
""" V: the number of vertexes
E: adjacency list (undirected graph)
start: start vertex
INF: Infinity cost
"""
self.prim(V, E, start, INF)
def prim(self, V, E, start=0, INF=10**9):
used = [False] * V
self.mincost = 0
que = []
heappush(que, (0, 0))
while len(que) > 0:
cost, v = heappop(que)
if used[v]: continue
used[v] = True
self.mincost += cost
for to, c in E[v]:
heappush(que, (c, to))
def minCost(self):
return self.mincost
V, E = list(map(int, input().split()))
edge = [[] for _ in range(V)]
for _ in range(E):
s, t, w = list(map(int, input().split()))
edge[s].append((t, w))
edge[t].append((s, w))
msp = Prim(V, edge)
print((msp.minCost())) | class UnionFindTree:
"""Disjoint-Set Data Structure
Union-Find Tree
used in SRM505 div.2 900
"""
def __init__(self, n):
self.par = list(range(n)) # parent
self.rank = [0] * n # depth of tree
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y: return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
class Kruskal:
""" Kruskal's algorithm: find minimum spanning tree
Complexity: O(E log(V))
used in GRL2A(AOJ)
"""
def __init__(self, V, E, start=0, INF=10**9):
""" V: the number of vertexes
E: adjacency list (undirected graph)
"""
self.kruskal(V, E)
def kruskal(self, V, E):
edges = []
for v1 in range(V):
for v2, cost in E[v1]:
if v1 < v2: edges.append((cost, v1, v2))
edges.sort()
self.mincost = 0
self.minSpanningTree = []
uf = UnionFindTree(V)
for cost, v1, v2 in edges:
if uf.same(v1, v2) == False:
self.mincost += cost
uf.unite(v1, v2)
self.minSpanningTree.append((v1, v2, cost))
def minCost(self):
return self.mincost
def getMinSpanningTree(self):
return sorted(self.minSpanningTree)
V, E = list(map(int, input().split()))
edge = [[] for _ in range(V)]
for _ in range(E):
s, t, w = list(map(int, input().split()))
edge[s].append((t, w))
edge[t].append((s, w))
msp = Kruskal(V, edge)
print((msp.minCost())) | p02364 |
class UnionFindTree:
"""Disjoint-Set Data Structure
Union-Find Tree
used in SRM505 div.2 900
"""
def __init__(self, n):
self.par = list(range(n)) # parent
self.rank = [0] * n # depth of tree
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y: return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
class Kruskal:
""" Kruskal's algorithm: find minimum spanning tree
Complexity: O(E log(V))
used in GRL2A(AOJ)
"""
def __init__(self, V, E, start=0, INF=10**9):
""" V: the number of vertexes
E: adjacency list (undirected graph)
"""
self.kruskal(V, E)
def kruskal(self, V, E):
edges = []
for v1 in range(V):
for v2, cost in E[v1]:
if v1 < v2: edges.append((cost, v1, v2))
edges.sort()
self.mincost = 0
self.minSpanningTree = []
uf = UnionFindTree(V)
for cost, v1, v2 in edges:
if uf.same(v1, v2) == False:
self.mincost += cost
uf.unite(v1, v2)
self.minSpanningTree.append((v1, v2, cost))
def minCost(self):
return self.mincost
def getMinSpanningTree(self):
return sorted(self.minSpanningTree)
V, E = list(map(int, input().split()))
edge = [[] for _ in range(V)]
for _ in range(E):
s, t, w = list(map(int, input().split()))
edge[s].append((t, w))
edge[t].append((s, w))
msp = Kruskal(V, edge)
print((msp.minCost())) | class UnionFindTree:
"""Disjoint-Set Data Structure
Union-Find Tree
used in SRM505 div.2 900
"""
def __init__(self, n):
self.par = list(range(n)) # parent
self.rank = [0] * n # depth of tree
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y: return
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
class Kruskal:
""" Kruskal's algorithm: find minimum spanning tree
Complexity: O(E log(V))
used in GRL2A(AOJ)
"""
def __init__(self, V, E, start=0, INF=10**9):
""" V: the number of vertexes
E: adjacency list (undirected graph)
"""
self.kruskal(V, E)
def kruskal(self, V, E):
edges = []
for v1 in range(V):
for v2, cost in E[v1]:
if v1 < v2: edges.append((cost, v1, v2))
edges.sort(reverse=True)
self.mincost = 0
self.minSpanningTree = []
uf = UnionFindTree(V)
while len(self.minSpanningTree) < V - 1:
cost, v1, v2 = edges.pop()
if uf.same(v1, v2) == False:
self.mincost += cost
uf.unite(v1, v2)
self.minSpanningTree.append((v1, v2, cost))
def minCost(self):
return self.mincost
def getMinSpanningTree(self):
return sorted(self.minSpanningTree)
V, E = list(map(int, input().split()))
edge = [[] for _ in range(V)]
for _ in range(E):
s, t, w = list(map(int, input().split()))
edge[s].append((t, w))
edge[t].append((s, w))
msp = Kruskal(V, edge)
print((msp.minCost())) | p02364 |
import array
import collections
import heapq
AdjacentVertex = collections.namedtuple("AdjacentVertex", "vertex cost")
INF = 2 ** 31 - 1
NO_VERTEX = -1
# Prim?????§??????0?????????????°???¨?????¨????±???????
def compute_mst_prim(max_v, adj_list):
# pred[u]?????????u???????????¨???????????????????????¨???
pred = collections.defaultdict(lambda: NO_VERTEX)
# u??¨pred[u]????????¶???????????????key[u]?????\???
key = collections.defaultdict(lambda: INF)
key[0] = 0
# ??????????????????????????????????????\?????¨????????¨??????
pq = [(key[v], v) for v in range(max_v)]
heapq.heapify(pq)
# ????????????????????\?????????????????\??£???????????????????????????
in_pq = array.array("B", (True for _ in range(max_v)))
while pq:
_, u = heapq.heappop(pq)
in_pq[u] = False
for v, v_cost in adj_list[u]:
if in_pq[v]:
weight = v_cost
if weight < key[v]:
pred[v] = u
key[v] = weight
heapq.heappush(pq, (weight, v))
in_pq[v] = True
return (pred, key)
max_v, max_e = list(map(int, input().split()))
adjacency_list = collections.defaultdict(set)
for _ in range(max_e):
s, t, w = list(map(int, input().split()))
adjacency_list[s].add(AdjacentVertex(t, w))
adjacency_list[t].add(AdjacentVertex(s, w))
(_, key) = compute_mst_prim(max_v, adjacency_list)
print((sum(key.values()))) | import heapq
from collections import defaultdict
INF = float('inf')
V, E = list(map(int, input().split()))
Adj_list = defaultdict(set)
for i in range(E):
s, t, w = list(map(int, input().split()))
Adj_list[s].add((t, w))
Adj_list[t].add((s, w))
def prim(x):
d = [INF] * x
d[0] = 0
isVisited = [False] * x
hq = [(0,0)]
while hq:
u = heapq.heappop(hq)[1]
isVisited[u] = True
for v, c in Adj_list[u]:
if not isVisited[v] and d[v] > c:
d[v] = c
heapq.heappush(hq, (c, v))
return sum(d)
print((prim(V)))
| p02364 |
import heapq
def prim(g, v):
for vi in range(v):
g[vi].sort()
cost = 0
heap = iter(g[0])
rest_tree = set(range(1, v))
while rest_tree:
d, u = next(heap)
if u in rest_tree:
cost += d
rest_tree -= {u}
heap = heapq.merge(heap, g[u])
return cost
from sys import stdin
readline = stdin.readline
v, e = list(map(int, readline().split()))
from collections import defaultdict
g = defaultdict(list)
for _ in range(e):
s, t, d = list(map(int, readline().split()))
g[s].append((d, t))
g[t].append((d, s))
print((prim(g, v))) | def kruskal(g, size):
g.sort(key=itemgetter(2), reverse=True)
uf = union_find(size)
tree = []
while len(tree) < size - 1:
u, v, d = g.pop()
if not uf.union(u, v):
tree.append((u, v, d))
return tree
class union_find:
def __init__(self, size):
self.table = [-1 for _ in range(size)]
def union(self, x, y):
x, y = self.find(x), self.find(y)
if x == y:return True
if self.table[y] < self.table[x]:x, y = y, x
self.table[x] += self.table[y]
self.table[y] = x
return False
def find(self, x):
if self.table[x] < 0:return x
self.table[x] = self.find(self.table[x])
return self.table[x]
from sys import stdin
from operator import itemgetter
import heapq
readline = stdin.readline
v, e = list(map(int, readline().split()))
g = [list(map(int, readline().split())) for _ in range(e)]
tree = kruskal(g, v)
print((sum(d for s, t, d in tree))) | p02364 |
# -*- coding: utf-8 -*-
V, E = list(map(int, input().split()))
weight = []
for i in range(E):
s, t, w = list(map(int, input().split()))
weight.append((s,t,w))
weight.sort(key = lambda x: x[2])
parent = [i for i in range(V)]
def find(x):
if parent[x] == x:
return x
else:
return find(parent[x])
def union(x, y):
a = find(x)
b = find(y)
parent[a] = b
sum_weight = 0
while weight:
a, b, c = weight[0]
if find(a) != find(b):
union(a, b)
sum_weight += c
weight.pop(0)
print(sum_weight)
| # -*- coding: utf-8 -*-
V, E = list(map(int, input().split()))
weight = []
for i in range(E):
s, t, w = list(map(int, input().split()))
weight.append((s,t,w))
weight.sort(key = lambda x: x[2])
parent = [i for i in range(V)]
def find(x):
if parent[x] == x:
return x
else:
return find(parent[x])
def union(x, y):
a = find(x)
b = find(y)
parent[a] = b
sum_weight = 0
for i in range(E):
a, b, c = weight[i]
if find(a) != find(b):
union(a, b)
sum_weight += c
else:
continue
print(sum_weight)
| p02364 |
from collections import defaultdict
import heapq
vertices,edges = list(map(int,input().split(" ")))
link = defaultdict(dict)
weight = defaultdict(dict)
way = [float("inf")] * vertices
for e in range(edges):
source,target,w = list(map(int,input().split(" ")))
link[source] = link.get(source,set()) | {target}
link[target] = link.get(target,set()) | {source}
weight[source].update({target:w})
weight[target].update({source:w})
queue = []
heapq.heapify(queue)
heapq.heappush(queue,[0,0])
went = set()
now_weight = 0
way[0] = 0
while len(went) < vertices:
here_weight,here = heapq.heappop(queue)
#print(now_weight,here)
now_weight += here_weight
can_go = link.get(here,set()) - went
min_weight,next_t = float("inf"),-1
for c in can_go:
#heapq.heappush(queue,[now_weight + weight[here][c],c])
if c not in went and way[c] > weight[here][c]:
heapq.heappush(queue,[weight[here][c],c])
way[c] = weight[here][c]
#print(queue)
went = went | {here}
print(now_weight) | from collections import defaultdict
import heapq
vertices,edges = list(map(int,input().split(" ")))
link = defaultdict(dict)
weight = defaultdict(dict)
way = [float("inf")] * vertices
for e in range(edges):
source,target,w = list(map(int,input().split(" ")))
link[source] = link.get(source,set()) | {target}
link[target] = link.get(target,set()) | {source}
weight[source].update({target:w})
weight[target].update({source:w})
queue = []
heapq.heapify(queue)
heapq.heappush(queue,[0,0])
went = [0] * vertices
now_weight = 0
way[0] = 0
while queue:
here_weight,here = heapq.heappop(queue)
#print(went)
if went[here]:
continue
went[here] = 1
now_weight += here_weight
min_weight,next_t = float("inf"),-1
for c in link[here]:
if not went[c] and way[c] > weight[here][c]:
heapq.heappush(queue,[weight[here][c],c])
way[c] = weight[here][c]
#print(queue)
print(now_weight) | p02364 |
from collections import defaultdict
import heapq
vertices,edges = list(map(int,input().split(" ")))
link = defaultdict(dict)
weight = defaultdict(dict)
way = [float("inf")] * vertices
for e in range(edges):
source,target,w = list(map(int,input().split(" ")))
link[source] = link.get(source,set()) | {target}
link[target] = link.get(target,set()) | {source}
weight[source].update({target:w})
weight[target].update({source:w})
queue = []
heapq.heapify(queue)
heapq.heappush(queue,[0,0])
went = [0] * vertices
now_weight = 0
way[0] = 0
while queue:
here_weight,here = heapq.heappop(queue)
#print(went)
if went[here]:
continue
went[here] = 1
now_weight += here_weight
min_weight,next_t = float("inf"),-1
for c in link[here]:
if not went[c] and way[c] > weight[here][c]:
heapq.heappush(queue,[weight[here][c],c])
way[c] = weight[here][c]
#print(queue)
print(now_weight) | from collections import defaultdict
import heapq
vertices, edges = (int(n) for n in input().split(" "))
conn = defaultdict(set)
weight = defaultdict(dict)
for i in range(edges):
v1, v2, w = (int(n) for n in input().split(" "))
conn[v1] |= {v2}
conn[v2] |= {v1}
weight[v1][v2] = w
weight[v2][v1] = w
queue = []
heapq.heapify(queue)
heapq.heappush(queue, [0,0])
went = set()
went_vertices = 0
answer_weight = 0
while went_vertices < vertices:
here_weight, here_v = heapq.heappop(queue)
if here_v in went:
continue
went |= {here_v}
for c in conn[here_v]:
if c not in went:
heapq.heappush(queue,[weight[here_v][c], c])
answer_weight += here_weight
went_vertices += 1
print(answer_weight) | p02364 |
import sys
class UnionFind():
def __init__(self, n):
self.n = n
self.p = [i for i in range(n + 5)]
self.rank = [0 for i in range(n + 5)]
def find_set(self, x):
if self.p[x] != x:
self.p[x] = self.find_set(self.p[x])
return self.p[x]
def unite(self, x, y):
px, py = self.find_set(x), self.find_set(y)
if px == py:
return
if self.rank[px] > self.rank[py]:
self.p[py] = px
else:
self.p[px] = py
if self.rank[px] == self.rank[py]:
self.rank[py] += 1
def main():
sys.setrecursionlimit(int(1e5))
nvertices, nedges = list(map(int, input().split()))
E = []
uf = UnionFind(nvertices)
for i in range(nedges):
s, t, w = list(map(int, input().split()))
E.append((w, s, t))
E.sort()
ans = 0
for w, s, t in E:
if uf.find_set(s) != uf.find_set(t):
ans += w
uf.unite(s, t)
print(ans)
main() | import sys
class UnionFind:
def __init__(self, nvertices):
self.rank = [1] * (nvertices + 5)
self.p = [i for i in range(nvertices + 5)]
def find_set(self, u):
if u != self.p[u]:
self.p[u] = self.find_set(self.p[u])
return self.p[u]
def unite(self, u, v):
x = self.find_set(u)
y = self.find_set(v)
if x == y:
return
if self.rank[x] > self.rank[y]:
self.p[y] = x
else:
self.p[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def is_connected(self, u, v):
return self.find_set(u) == self.find_set(v)
def main():
sys.setrecursionlimit(int(1e5))
nvertices, nedges = list(map(int, input().split()))
edges = []
for i in range(nedges):
u, v, w = list(map(int, input().split()))
edges.append((w, u, v))
edges.sort(key=lambda e: e[0])
ans = 0
uf = UnionFind(nvertices)
for w, u, v in edges:
if not uf.is_connected(u, v):
uf.unite(u, v)
ans += w
print(ans)
main() | p02364 |
X, A = list(map(int, input().split()))
if X < A:
print('0')
else:
print('10') | X, A = list(map(int, input().split()))
if X < A:
print((0))
else:
print((10))
| p02999 |
x, a = list(map(int, input().split()))
if x < a:
print((0))
if x >= a:
print((10)) | def main():
x, a = list(map(int, input().split()))
if x < a:
print((0))
else:
print((10))
if __name__ == '__main__':
main() | p02999 |
x,a=list(map(int,input().split()));print(((x>=a)*10)) | x,a=input().split();print(((x>=a)*10)) | p02999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.