input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
def search_delete(data):
del_target = -1
max_count = 1
for i in range(len(data)):
count = 0
for j in range(i+1, len(data)):
if data[i][1] > data[j][0]:
count += 1
else:
break
if count >= max_count:
del_target = i
max_count = count
if del_target != -1:
data.pop(del_target)
return True
return False
def main():
n = int(eval(input()))
data = []
for i in range(n):
x, l = list(map(int, input().split()))
data.append([x-l, x+l])
data.sort(key=lambda x: x[0])
remove = []
for i in range(len(data)-1):
if data[i][1] < data[i+1][0]:
remove.append(data[i])
for x in remove[:]:
data.remove(x)
flg = True
while flg:
flg = search_delete(data)
print((len(remove)+len(data)))
main()
| def main():
n = int(eval(input()))
data = []
for i in range(n):
x, l = list(map(int, input().split()))
data.append([x-l, x+l])
data.sort(key=lambda x: x[1])
ans = 1
min_value = data[0][1]
for i in range(1, n):
if min_value <= data[i][0]:
ans += 1
min_value = data[i][1]
print(ans)
main()
| p02796 |
N = int(eval(input()))
P = [list(map(int, input().split())) for _ in range(N)]
P.sort(key=lambda x: x[0]+x[1])
leave = []
for i in range(N):
# ロボットpiが既に残すと決めたロボットに重ならないことをチェック
# print('Checking Robot P{}: {}'.format(i, P[i]))
# print('S:{} P:{} T:{}'.format(P[i][0]-P[i][1], P[i][0] , P[i][0]+P[i][1]))
if len(list([leave_ for leave_ in leave if leave_[0] + leave_[1] > P[i][0] - P[i][1]])) == 0:
leave.append(P[i])
#print(leave)
else:
#print('Not Added')
#print(leave)
continue
print((len(leave))) | N = int(eval(input()))
P = [list(map(int, input().split())) for _ in range(N)]
P.sort(key=lambda x: x[0]+x[1])
leave = [P[0]]
for i in range(1, N):
# leaveの最大を取得
leave_max = leave[-1][0] + leave[-1][1]
p_min = P[i][0] - P[i][1]
if leave_max <= p_min:
leave.append(P[i])
else:
continue
print((len(leave))) | p02796 |
n = int(eval(input()))
LeftEnd = [0 for i in range(n)]
Center = [0 for i in range(n)]
RightEnd = [0 for i in range(n)]
for i in range(n):
robot, arm = list(map(int, input().split()))
LeftEnd[i] = robot - arm
Center[i] = robot
RightEnd[i] = robot + arm
now_rightend = min(RightEnd)
for counter in range(n):
next_candidates = [RightEnd[i] for i, v in enumerate(LeftEnd) if v >= now_rightend]
if not next_candidates:
break
now_rightend = min(next_candidates)
print((counter+1)) | n = int(eval(input()))
List = [[0 for i in range(3)] for j in range(n)]
for i in range(n):
robot, arm = list(map(int, input().split()))
List[i][0] = robot - arm # LeftEnd
List[i][1] = robot # Center
List[i][2] = robot + arm # RightEnd
sorted_List = sorted(List, key=lambda x: x[2])
now_rightend = sorted_List[0][2]
counter = 1
for i in range(n):
if sorted_List[i][0] >= now_rightend:
now_rightend = sorted_List[i][2]
counter += 1
print(counter) | p02796 |
def find_dex(list,dex):
for j in range(len(list)):
if list[j][0] == dex:
return j
return 0
n = int(eval(input()))
d = []
left = []
right = []
for i in range(n):
x,l = list(map(int, input().split()))
# num , left , right
left.append([i,x-l+1,x+l-1])
right.append([i,x-l+1,x+l-1])
left.sort(key=lambda x:x[1],reverse=False)
right.sort(key=lambda x:x[2],reverse=False)
flag = True
p = 10**9 + 1
ans = 0
while len(left) > 0:
if flag:
i,l,r = left.pop(-1)
right.pop(find_dex(right,i))
flag = False
if r >= p:
ans += 1
p = l
else:
i,l,r = right.pop(-1)
left.pop(find_dex(left,i))
flag = True
if r >= p:
ans += 1
p = l
#print(i,l,r)
#print(left)
#print(right)
print((n-ans))
| n = int(eval(input()))
d = []
left = []
right = []
for i in range(n):
x,l = list(map(int, input().split()))
# num , left , right
d.append([x-l,x+l])
d.sort()
p = d[0][1]
ans = n
for i in range(1,n):
if d[i][0] < p:
ans -= 1
p = min(p,d[i][1])
else:
p = d[i][1]
print(ans)
| p02796 |
import sys
from operator import itemgetter
input = sys.stdin.readline
def main():
N = int(eval(input()))
LR = [None] * N
for i in range(N):
X, L = list(map(int, input().split()))
LR[i] = (X - L, X + L)
LR.sort(key=itemgetter(0))
ans = N
cur_R = LR[0][1]
for L, R in LR[1:]:
if L < cur_R:
ans -= 1
cur_R = min(cur_R, R)
else:
cur_R = R
print(ans)
if __name__ == "__main__":
main()
| import sys
from operator import itemgetter
input = sys.stdin.readline
def main():
N = int(eval(input()))
LR = [None] * N
for i in range(N):
X, L = list(map(int, input().split()))
LR[i] = (X - L, X + L)
LR.sort(key=itemgetter(0))
ans = N
cur_R = LR[0][1]
for L, R in LR[1:]:
if L < cur_R:
ans -= 1
if R < cur_R:
cur_R = R
else:
cur_R = R
print(ans)
if __name__ == "__main__":
main()
| p02796 |
N = int(eval(input()))
ts=[]
for i in range(N):
x, l = list(map(int,input().split()))
s = max(x-l,0)
t = min(10**9,x+l)
ts.append([t,s])
ts.sort()
count = 0
lastT = 0
for i in ts:
if i[1]>=lastT:
count+=1
lastT=i[0]
print(count) | N = int(eval(input()))
st = []
for i in range(N):
x,l=list(map(int,input().split()))
s = max(x-l,0)
t = min(x+l,10**9)
st.append([t,s])
st.sort()
count = 0
lastT=0
for i in range(N):
if st[i][1]>=lastT:
count+=1
lastT = st[i][0]
print(count) | p02796 |
n=int(eval(input()))
l=sorted([list(map(int,input().split())) for _ in range(n)])
c=0
x=[0]*n
def d_min(a,b):
return a-b
def d_max(a,b):
return a+b
for i in range(n-1):
if x[i] != 0:
continue
for k in range(1,n-i):
if d_max(*l[i]) > d_min(*l[i+k]):
c+=1
x[i+1]+=1
print((n-c)) | n=int(eval(input()))
r=[]
cnt=1
for _ in range(n):
x,l=list(map(int,input().split()))
s=x-l
t=x+l
r.append([s,t])
r=sorted(r,key=lambda x: x[1])
t0=r[0][1]
for s,t in r[1:]:
if t0<=s:
cnt+=1
t0=t
print(cnt) | p02796 |
import sys
from operator import itemgetter
read = sys.stdin.read
N, *XL = list(map(int, read().split()))
seq = []
for X, L in zip(*[iter(XL)] * 2):
seq.append((X - L, X + L))
seq.sort(key=itemgetter(1))
answer = 0
left = -10 ** 10
for i, j in seq:
if left <= i:
answer += 1
left = j
print(answer) | import sys
from operator import itemgetter
read = sys.stdin.read
N, *XL = list(map(int, read().split()))
seq = [(X - L, X + L) for X, L in zip(*[iter(XL)] * 2)]
seq.sort(key=itemgetter(1))
answer = 0
left = -10 ** 10
for i, j in seq:
if left <= i:
answer += 1
left = j
print(answer)
| p02796 |
#!/usr/bin/env python3
import sys
INF = float("inf")
def solve(N: int, X: "List[int]", L: "List[int]"):
# 区間に変換する
segs = [(x-l, x+l) for x, l in zip(X, L)]
segs.sort(key=lambda x: x[1]) # 尻でソート
# DP i個目の区間まで考えた時の残せる数
DP = [0]*N
DP[0] = 1
for i in range(1, N):
# 重なっていなければ
if segs[i-1][1] <= segs[i][0]:
DP[i] = DP[i-1]+1
else:
# 加えないか
DP[i] = DP[i-1]
# 重なるものを抜いた場合の個数+1
left = -1
right = i-1
while right-left > 1:
mid = (right+left)//2
if segs[mid][1] <= segs[i][0]:
left = mid
else:
right = mid
# すべて重なるケースは区別
if left == -1:
buf = 1
else:
buf = DP[left]+1
DP[i] = max(buf, DP[i-1])
print((DP[-1]))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
X = [int()] * (N) # type: "List[int]"
L = [int()] * (N) # type: "List[int]"
for i in range(N):
X[i] = int(next(tokens))
L[i] = int(next(tokens))
solve(N, X, L)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
INF = float("inf")
def solve(N: int, X: "List[int]", L: "List[int]"):
# 区間に変換する
segs = [(x-l, x+l) for x, l in zip(X, L)]
segs.sort(key=lambda x: x[1]) # 尻でソート
last = -INF
count = 0
for i in range(N):
if last <= segs[i][0]:
last = segs[i][1]
count += 1
print(count)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
X = [int()] * (N) # type: "List[int]"
L = [int()] * (N) # type: "List[int]"
for i in range(N):
X[i] = int(next(tokens))
L[i] = int(next(tokens))
solve(N, X, L)
if __name__ == '__main__':
main()
| p02796 |
N = int(eval(input()))
arr = [list(map(int,input().split())) for i in range(N)]
arr = sorted(arr)
F = [True]*N
P = [0]*N
for i in range(N):
P[i] = [arr[i][0]-arr[i][1], arr[i][0]+arr[i][1]]
for i in range(N):
for j in range(i+1,N):
if F[i]:
if P[i][1] > P[j][0]:
F[j] = False
else:
break
print((F.count(True)))
| N = int(eval(input()))
arr = [list(map(int,input().split())) for i in range(N)]
arr = sorted(arr, key=lambda x: x[0])
F = [True]*N
P = [0]*N
for i in range(N):
P[i] = [arr[i][0]-arr[i][1], arr[i][0]+arr[i][1]]
P = sorted(P,key=lambda x:x[1])
ind = 0
for i in range(1,N):
if P[i][0] < P[ind][1]:
F[i] = False
else:
ind = i
print((F.count(True))) | p02796 |
def main():
N = int(eval(input()))
X = []
L = []
for i in range(N):
x, l = [int(s) for s in input().split()]
X.append(x)
L.append(l)
ranges = []
for i in range(N):
ranges.append((X[i] - L[i], X[i] + L[i]))
ranges.sort(key=lambda x: x[0])
while True:
dup = [0 for i in range(len(ranges))]
for i in range(len(ranges) - 1):
if ranges[i][1] > ranges[i + 1][0]:
dup[i] += 1
dup[i + 1] += 1
remove_index = [(i, dup[i]) for i in range(len(dup)) if dup[i] > 0]
if len(remove_index) == 0:
break
remove_index.sort(key=lambda x: x[1], reverse=True)
ranges.pop(remove_index[0][0])
print((len(ranges)))
if __name__ == "__main__":
main()
| def main():
N = int(eval(input()))
X = []
L = []
for i in range(N):
x, l = [int(s) for s in input().split()]
X.append(x)
L.append(l)
ranges = []
for i in range(N):
ranges.append((X[i] - L[i], X[i] + L[i]))
ranges.sort(key=lambda x: x[1])
cnt = len(ranges)
end = ranges[0][1]
for i in range(1, len(ranges)):
if ranges[i][0] < end:
cnt -= 1
else:
end = ranges[i][1]
print(cnt)
if __name__ == "__main__":
main()
| p02796 |
n=int(eval(input()))
s=[]
t=[]
for i in range(n):
x,l=list(map(int,input().split()))
s.append(x-l)
t.append(x+l)
itv = []
for i in range(n):
itv.append([t[i],s[i]])
itv.sort()
ass=0
tt=-10000000000
for i in range(n):
if tt<=itv[i][1]:
ass+=1
tt=itv[i][0]
print(ass)
| n=int(eval(input()))
sec=[list(map(int,input().split())) for i in range(n)]
for i in range(n):
sec[i][0]+=sec[i][1]
sec[i][1]*=-2
sec[i][1]+=sec[i][0]
sec.sort()
ans=0
#-inf
t=-10000000000
for i in range(n):
#=をつけるのを忘れずに
if t<=sec[i][1]:#スタートがロボットアームのある最大の座標以上でなければならない
ans+=1#以上なら+1
t=sec[i][0]#ロボットアームのある最大の座標を更新
print(ans)
| p02796 |
N = int(eval(input()))
X = [0]*N
L = [0]*N
XpL = [0]*N
XmL = [0]*N
cnt = 0
for i in range(N):
X[i], L[i] = list(map(int, input().split()))
XpL[i] = X[i]+L[i]
XmL[i] = max(0, X[i]-L[i])
for j in range(i):
if(XmL[i] < XpL[j] and XmL[j] < XpL[i]):
cnt += 1
XpL[i] = XpL[j]
XmL[i] = XmL[j]
print((N-cnt)) | import sys
N = int(eval(input()))
a = sorted([(x+l, x-l) for x, l in (list(map(int, l.split())) for l in sys.stdin)])
last = a[0][0]
ans = 1
for r, l in a[1:]:
if(last <= l):
ans += 1
last = r
print(ans) | p02796 |
from functools import lru_cache
def prepare(n, MOD):
f = 1
factorials = [1] * (n + 1)
for m in range(1, n + 1):
f = f * m % MOD
factorials[m] = f
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv = inv * m % MOD
invs[m - 1] = inv
return factorials, invs
def get_nhr(n, facts, invs, MOD):
@lru_cache(maxsize=None)
def nhr(r):
return facts[n + r - 1] * invs[r] * invs[n - 1] % MOD
return nhr
def solve(n, m):
MOD = 998244353
facts, invs = prepare(n + 3 * m, MOD)
fn = facts[n]
nhr = get_nhr(n, facts, invs, MOD)
ans = 0
for odd in range(m % 2, min(m, n) + 1, 2):
tmp = nhr((3 * m - odd) // 2)
if odd > 0:
tmp -= odd * nhr((m - odd) // 2)
if odd < n and odd <= m - 2:
tmp -= (n - odd) * nhr((m - odd - 2) // 2)
ans = (ans + fn * invs[odd] * invs[n - odd] % MOD * tmp) % MOD
return ans
n, m = list(map(int, input().split()))
print((solve(n, m)))
| def prepare(n, MOD):
f = 1
factorials = [1] * (n + 1)
for m in range(1, n + 1):
f = f * m % MOD
factorials[m] = f
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv = inv * m % MOD
invs[m - 1] = inv
return factorials, invs
def get_nhr(n, facts, invs, MOD):
def nhr(r):
return facts[n + r - 1] * invs[r] * invs[n - 1] % MOD
return nhr
def solve(n, m):
MOD = 998244353
facts, invs = prepare(n + 3 * m, MOD)
fn = facts[n]
nhr = get_nhr(n, facts, invs, MOD)
nm2 = min(n, m - 1)
ans = 0
for odd in range(m % 2, min(m, n) + 1, 2):
tmp = nhr((3 * m - odd) // 2)
if odd > 0:
tmp -= odd * nhr((m - odd) // 2)
if odd < nm2:
tmp -= (n - odd) * nhr((m - odd - 2) // 2)
ans = (ans + fn * invs[odd] * invs[n - odd] % MOD * tmp) % MOD
return ans
n, m = list(map(int, input().split()))
print((solve(n, m)))
| p02965 |
import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 998244353
N, M = list(map(int, sys.stdin.readline().split()))
def get_factorials(max, mod=None):
"""
階乗 0!, 1!, 2!, ..., max!
:param int max:
:param int mod:
:return:
"""
ret = [1]
n = 1
if mod:
for i in range(1, max + 1):
n *= i
n %= mod
ret.append(n)
else:
for i in range(1, max + 1):
n *= i
ret.append(n)
return ret
factorials = get_factorials(M * 3 + N - 1, MOD)
def mod_inv(a, mod):
"""
a の逆元
:param int a:
:param int mod:
:return:
"""
return pow(a, mod - 2, mod)
def ncr(n, r, mod=None):
"""
scipy.misc.comb または scipy.special.comb と同じ
組み合わせの数 nCr
:param int n:
:param int r:
:param int mod: 3 以上の素数であること
:rtype: int
"""
if n < r:
return 0
return factorials[n] * mod_inv(factorials[r], mod) * mod_inv(factorials[n - r], mod) % mod
# 合計が M*3 となる数列の数
# c1 = ncr(M * 3 + N - 1, N - 1, MOD)
# (1) 合計が M*3 で、奇数の数が M 以下である数列の数
c1 = 0
for odds in range(M * 3 % 2, M + 1, 2):
half = (M * 3 - odds) // 2
# 合計が half の数列を 2 倍して、odds 個選んで 1 を足す
c1 += ncr(half + N - 1, N - 1, MOD) * ncr(N, odds, MOD)
c1 %= MOD
# (2) max が M*2 より大きく、奇数の数が M 以下である数列の数
# c2 = 0
# for mx in range(M * 2 + 1, M * 3 + 1):
# rem = M * 3 - mx
# oddmax = M if mx % 2 == 0 else M - 1
# for odds in range(rem % 2, min(oddmax, rem) + 1, 2):
# half = (rem - odds) // 2
# c2 += ncr(half + N - 2, N - 2, MOD) * ncr(N - 1, odds, MOD) * N
# c2 %= MOD
# print((c1 - c2) % MOD)
# (2) max が M*2 より大きく、奇数の数が M 以下である数列の数
# => 合計が M で、1 要素目が 0 より大きい、奇数が M 以下である数列の数 * N
# 1 要素目に M*2 を足せば (2) になる
# a. 合計が M で奇数が M 以下
c2a = 0
# b. 1 要素目が 0 である数列の数
c2b = 0
for odds in range(M % 2, M + 1, 2):
half = (M - odds) // 2
c2a += ncr(half + N - 1, N - 1, MOD) * ncr(N, odds, MOD)
c2a %= MOD
c2b += ncr(half + N - 2, N - 2, MOD) * ncr(N - 1, odds, MOD)
c2b %= MOD
c2 = (c2a - c2b) * N
print(((c1 - c2) % MOD))
| import os
import sys
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 998244353
N, M = list(map(int, sys.stdin.readline().split()))
def get_factorials(max, mod=None):
"""
階乗 0!, 1!, 2!, ..., max!
:param int max:
:param int mod:
:return:
"""
ret = [1]
n = 1
if mod:
for i in range(1, max + 1):
n *= i
n %= mod
ret.append(n)
else:
for i in range(1, max + 1):
n *= i
ret.append(n)
return ret
def mod_invs(max, mod):
"""
逆元のリスト 0 から max まで
:param max:
:param mod:
:return:
"""
invs = [1] * (max + 1)
for x in range(2, max + 1):
invs[x] = (-(mod // x) * invs[mod % x]) % mod
return invs
factorials = get_factorials(M * 3 // 2 + N, MOD)
finvs = []
inv = 1
for i in mod_invs(M * 3 // 2 + N, MOD):
inv = inv * i % MOD
finvs.append(inv)
def ncr(n, r, mod=None):
"""
scipy.misc.comb または scipy.special.comb と同じ
組み合わせの数 nCr
:param int n:
:param int r:
:param int mod: 3 以上の素数であること
:rtype: int
"""
if n < r:
return 0
# return factorials[n] * mod_inv(factorials[r], mod) * mod_inv(factorials[n - r], mod) % mod
return factorials[n] * finvs[r] * finvs[n - r] % mod
# 合計が M*3 となる数列の数
# c1 = ncr(M * 3 + N - 1, N - 1, MOD)
# (1) 合計が M*3 で、奇数の数が M 以下である数列の数
c1 = 0
for odds in range(M * 3 % 2, M + 1, 2):
half = (M * 3 - odds) // 2
# 合計が half の数列を 2 倍して、odds 個選んで 1 を足す
c1 += ncr(half + N - 1, N - 1, MOD) * ncr(N, odds, MOD)
c1 %= MOD
# (2) max が M*2 より大きく、奇数の数が M 以下である数列の数
# c2 = 0
# for mx in range(M * 2 + 1, M * 3 + 1):
# rem = M * 3 - mx
# oddmax = M if mx % 2 == 0 else M - 1
# for odds in range(rem % 2, min(oddmax, rem) + 1, 2):
# half = (rem - odds) // 2
# c2 += ncr(half + N - 2, N - 2, MOD) * ncr(N - 1, odds, MOD) * N
# c2 %= MOD
# print((c1 - c2) % MOD)
# (2) max が M*2 より大きく、奇数の数が M 以下である数列の数
# => 合計が M で、1 要素目が 0 より大きい、奇数が M 以下である数列の数 * N
# 1 要素目に M*2 を足せば (2) になる
# a. 合計が M で奇数が M 以下
c2a = 0
# b. 1 要素目が 0 である数列の数
c2b = 0
for odds in range(M % 2, M + 1, 2):
half = (M - odds) // 2
c2a += ncr(half + N - 1, N - 1, MOD) * ncr(N, odds, MOD)
c2a %= MOD
c2b += ncr(half + N - 2, N - 2, MOD) * ncr(N - 1, odds, MOD)
c2b %= MOD
c2 = (c2a - c2b) * N
print(((c1 - c2) % MOD))
| p02965 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 998244353
n, m = LI()
total = m * 3
fac = [1] * (total + n)
inv = [1] * (total + n)
i = 1
for j in range(1, total + n):
i = i * j % mod
fac[j] = i
inv[j] = pow(i, mod - 2, mod)
def comb(n, r):
if r > n:
return 0
return fac[n] * inv[n - r] * inv[r] % mod
ans = comb(total + n - 1, n - 1)
for i in range(m + 2, min(n + 1, total + 1)):
if (total - i) % 2 == 0:
ans -= comb(n, i) * comb(n + (total - i) // 2 - 1, n - 1) % mod
ans %= mod
ret = 0
for i in range(m):
ret = (ret + comb(i + n - 2, n - 2)) % mod
ans -= (ret * n) % mod
print((ans % mod)) | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 998244353
n, m = LI()
total = m * 3
fac = [1] * (total+n+1)
inv = [1] * (total+n+1)
for i in range(total+n):
fac[i+1] = fac[i]*(i+1)%mod
inv[total+n]=pow(fac[-1], mod-2, mod)
for j in range(total+n-1, -1, -1):
inv[j]=inv[j+1]*(j+1)%mod
def comb(n, r):
if r > n:
return 0
return fac[n] * inv[n - r] * inv[r] % mod
ans = comb(total+n-1, n-1)
for i in range(m + 2, min(n + 1, total + 1)):
if (total - i) % 2 == 0:
ans -= comb(n, i) * comb(n + (total - i) // 2 - 1, n - 1) % mod
ans %= mod
ret = 0
for i in range(m):
ret = (ret + comb(i + n - 2, n - 2)) % mod
ans -= (ret * n) % mod
print((ans % mod)) | p02965 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string
INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 998244353
n, m = LI()
total = m * 3
fac = [1] * (total+n+1)
inv = [1] * (total+n+1)
for i in range(total+n):
fac[i+1] = fac[i]*(i+1)%mod
inv[total+n]=pow(fac[-1], mod-2, mod)
for j in range(total+n-1, -1, -1):
inv[j]=inv[j+1]*(j+1)%mod
def comb(n, r):
if r > n:
return 0
return fac[n] * inv[n - r] * inv[r] % mod
ans = comb(total+n-1, n-1)
for i in range(m + 2, min(n + 1, total + 1)):
if (total - i) % 2 == 0:
ans -= comb(n, i) * comb(n + (total - i) // 2 - 1, n - 1) % mod
ans %= mod
ret = 0
for i in range(m):
ret = (ret + comb(i + n - 2, n - 2)) % mod
ans -= (ret * n) % mod
print((ans % mod)) | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
from pprint import pprint
from copy import deepcopy
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
from pprint import pprint
sys.setrecursionlimit(2147483647)
INF = 10 ** 15
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 998244353
n, m = LI()
a = n + 3 * m
fac = [1] * (a + 1)
inv = [1] * (a + 1)
for j in range(1, a + 1):
fac[j] = fac[j-1] * j % mod
inv[a] = pow(fac[a], mod-2, mod)
for j in range(a-1, -1, -1):
inv[j] = inv[j+1] * (j+1) % mod
def comb(x, y):
if y > x or x < 0 or y < 0:
return 0
return fac[x] * inv[x - y] * inv[y] % mod
ans = 0
for i in range(min(m + 1, n + 1)):
if (m - i) % 2:
continue
ans += comb(n, i) * comb((m * 3 - i) // 2 + n - 1, n - 1)
ans %= mod
print(((ans - n * comb(m - 1 + n - 1, n - 1)) % mod)) | p02965 |
import sys
input=sys.stdin.readline
N,M=list(map(int,input().split()))
mod=998244353
#階乗テーブル
g1=[1,1]
for i in range(2,3*M//2+N+2):
g1.append(g1[-1]*i%mod)
def cmb(n,r):
return g1[n]*pow(g1[r],mod-2,mod)*pow(g1[n-r],mod-2,mod)%mod
#奇数の和で場合分け
#iは奇数の数
ans=0
for i in range(min(N+1,M+1)):
if M%2!=i%2:
continue
m=(3*M-i)//2
num=(cmb(m+N-1,N-1)-i*cmb(m-M+N-1,N-1))%mod
if m>=M+1:
num=(num-(N-i)*cmb(m-M+N-2,N-1))%mod
ans=(ans+cmb(N,i)*num)%mod
print(ans) | import sys
input=sys.stdin.readline
N,M=list(map(int,input().split()))
mod=998244353
inv=[0]*(3*M//2+N+2)
inv[1]=1
for i in range(2,3*M//2+N+2):
inv[i]=-(mod//i)*inv[mod%i]%mod
#階乗テーブル
g1=[1,1]
g2=[1,1]
for i in range(2,3*M//2+N+2):
num_1=g1[-1]*i%mod
g1.append(num_1)
g2.append(g2[-1]*inv[i]%mod)
def cmb(n,r):
return g1[n]*g2[r]*g2[n-r]%mod
#奇数の和で場合分け
#iは奇数の数
ans=0
for i in range(min(N+1,M+1)):
if M%2!=i%2:
continue
m=(3*M-i)//2
num=(cmb(m+N-1,N-1)-i*cmb(m-M+N-1,N-1))%mod
if m>=M+1:
num=(num-(N-i)*cmb(m-M+N-2,N-1))%mod
ans=(ans+cmb(N,i)*num)%mod
print(ans) | p02965 |
o=998244353
r=2500100
f=[1]
for i in range(1,r):f.append(f[-1]*i%o)
def c(n,k):return f[n]*pow(f[n-k],o-2,o)*pow(f[k],o-2,o)%o
n,m=list(map(int,input().split()))
w=3*m
a=(c(n+w-1,n-1)-n*c(n+m-2,n-1))%o
if n>m+1:
for i in range(m+1,min(w,n)+1):
if w-i&1:continue
a=(a-c(n,i)*c((w-i)//2+n-1,n-1))%o
print(a) | o=998244353
f=[1]
for i in range(1,2500100):f.append(f[-1]*i%o)
def c(n,k):return f[n]*pow(f[n-k],o-2,o)*pow(f[k],o-2,o)%o
n,m=list(map(int,input().split()))
w=3*m
u=n-1
a=c(w+u,u)-n*c(n+m-2,u)
if u>m:
for i in range(m+1,min(w,n)+1):
if w-i+1&1:a=(a-c(n,i)*c((w-i)//2+u,u))%o
print((a%o)) | p02965 |
o=998244353
f=[1]
for i in range(1,2500100):f.append(f[-1]*i%o)
def c(n,k):return f[n]*pow(f[n-k],o-2,o)*pow(f[k],o-2,o)
n,m=list(map(int,input().split()))
w=3*m
u=n-1
a=c(w+u,u)-n*c(n+m-2,u)
if u>m:
for i in range(m+1,min(w,n)+1):
if w-i+1&1:a=(a-c(n,i)*c((w-i)//2+u,u))%o
print((a%o)) | o=998244353
f=[1]
for i in range(1,2500100):f.append(f[-1]*i%o)
def c(n,k):return f[n]*pow(f[n-k],o-2,o)*pow(f[k],o-2,o)
n,m=list(map(int,input().split()))
w=3*m
u=n-1
a=c(w+u,u)-n*c(n+m-2,u)
if u>m:
for i in range(m+1,min(w,n)+1):
if w-i+1&1:a-=c(n,i)*c((w-i)//2+u,u)
print((a%o)) | p02965 |
o,f=998244353,[1]
for i in range(1,2500100):f.append(f[-1]*i%o)
def c(n,k):return f[n]*pow(f[n-k],o-2,o)*pow(f[k],o-2,o)
n,m=list(map(int,input().split()))
w,u=3*m,n-1
a=c(w+u,u)-n*c(n+m-2,u)
if u>m:
for i in range(m+1,min(w,n)+1):
if w-i+1&1:a-=c(n,i)*c((w-i)//2+u,u)
print((a%o)) | o,f=998244353,[1]
for i in range(1,2500100):f.append(f[-1]*i%o)
c=lambda n,k:f[n]*pow(f[n-k],o-2,o)*pow(f[k],o-2,o)
n,m=list(map(int,input().split()))
w,u=3*m,n-1
a=c(w+u,u)-n*c(n+m-2,u)
if u>m:
for i in range(m+1,min(w,n)+1):
if w-i+1&1:a-=c(n,i)*c((w-i)//2+u,u)
print((a%o)) | p02965 |
o,f,i=998244353,[1],1
while i<o/399:f+=[f[-1]*i%o];i+=1
c=lambda n,k:f[n]*pow(f[n-k],o-2,o)*pow(f[k],o-2,o)
n,m=list(map(int,input().split()))
w,u=3*m,n-1
a=c(w+u,u)-n*c(n+m-2,u)
if u>m:
for i in range(m+1,min(w,n)+1):
if w-i+1&1:a-=c(n,i)*c((w-i)//2+u,u)
print((a%o)) | o,f,i=998244353,[1],1
while i<o/399:f+=[f[-1]*i%o];i+=1
c=lambda n,k:f[n]*pow(f[n-k],o-2,o)*pow(f[k],o-2,o)
n,m=list(map(int,input().split()))
w,u,j=3*m,n-1,m+1
a=c(w+u,u)-n*c(n+m-2,u)
if w-j&1:j+=1
while j<=min(w,n):a-=c(n,j)*c((w-j)//2+u,u);j+=2
print((a%o)) | p02965 |
o,f,i=998244353,[1],1
while i<o>>8:f+=[f[-1]*i%o];i+=1
c=lambda n,k:f[n]*pow(f[n-k],o-2,o)*pow(f[k],o-2,o)
n,m=list(map(int,input().split()));w,u=3*m,n-1;a=c(w+u,u)-n*c(n+m-2,u)
while-~m<min(w,n):m+=2;a-=c(n,m)*c(2*u+w-m>>1,u)
print((a%o)) | n,m=list(map(int,input().split()))
w,u=3*m,n-1
o,f,i=998244353,[1],1
while i<w+n:f+=[f[-1]*i%o];i+=1
c=lambda n,k:f[n]*pow(f[n-k],o-2,o)*pow(f[k],o-2,o)
a=c(w+u,u)-n*c(n+m-2,u)
while-~m<min(w,n):m+=2;a-=c(n,m)*c(2*u+w-m>>1,u)
print((a%o)) | p02965 |
n,m=list(map(int,input().split()))
w,u=3*m,n-1
o,f,i=998244353,[1],1
while i<w+n:f+=[f[-1]*i%o];i+=1
c=lambda n,k=u:f[n]*pow(f[n-k],o-2,o)*pow(f[k],o-2,o)
a=c(w+u)-n*c(n+m-2)
while~-n>m<w:m+=2;a-=c(n,m)*c(2*u+w-m>>1)
print((a%o)) | n,m=list(map(int,input().split()))
o,f,i=998244353,[1],1
while i<3*m+n:f+=[f[-1]*i%o];i+=1
c=lambda x,y=n-1:f[x]*pow(f[x-y]*f[y]%o,o-2,o)
a=c(-1)-n*c(n+m-2)
while~-n>m<i-n:m+=2;a-=c(n,m)*c(n-1+i-m>>1)
print((a%o)) | p02965 |
graph = []
def init():
global graph
graph = [[False] * 26 + [True] for _ in range(27)]
graph[26][26] = False
def atoi(c):#index
if c == "#":
return 26
return ord(c) - ord("a")
def make_graph(L):
global graph, count
cur = 0
L = [L[0]] + [L[i] for i in range(1, len(L)) if L[i] != L[i-1]]
tmp = []
for s1, s2 in zip(L, L[1:]):
if s1[0] == s2[0]:
tmp += [s1[1:], s2[1:]]
else:
if not tmp == []:
make_graph(tmp)
tmp = []
graph[atoi(s2[0])][atoi(s1[0])] = True
if not tmp == []:
make_graph(tmp)
def check(start):
stack = set([start])
visited = [False] * 27
while len(stack) != 0:
cur = stack.pop()
visited[cur] = True
if graph[cur][start]:
return False
for i in range(27):
if graph[cur][i] and not visited[i]:
stack.add(i)
return True
while True:
n = eval(input())
if n == 0:
break
L = [input() + "#" for _ in range(n)]
init()
make_graph(L)
for i in range(27):
if not check(i):
print("no")
break
else:
print("yes") | graph = []
def init():
global graph
graph = [[False] * 26 + [True] for _ in range(27)]
graph[26][26] = False
def atoi(c):#index
if c == "#":
return 26
return ord(c) - ord("a")
def make_graph(L):
global graph
cur = 0
L = [L[0]] + [L[i] for i in range(1, len(L)) if L[i] != L[i-1]]
tmp = []
for s1, s2 in zip(L, L[1:]):
if s1[0] == s2[0]:
tmp += [s1[1:], s2[1:]]
else:
if not tmp == []:
make_graph(tmp)
tmp = []
graph[atoi(s2[0])][atoi(s1[0])] = True
if not tmp == []:
make_graph(tmp)
def check(start):
stack = set([start])
visited = [False] * 27
while len(stack) != 0:
cur = stack.pop()
visited[cur] = True
if graph[cur][start]:
return False
for i in range(27):
if graph[cur][i] and not visited[i]:
stack.add(i)
return True
while True:
n = eval(input())
if n == 0:
break
L = [input() + "#" for _ in range(n)]
init()
make_graph(L)
for i in range(27):
if not check(i):
print("no")
break
else:
print("yes") | p01646 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
X,Y = MI()
print(('Alice' if abs(X-Y) >= 2 else 'Brown'))
| import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
X,Y = MI()
print(('Alice' if abs(X-Y) >= 2 else 'Brown'))
| p03740 |
X, Y = list(map(int, input().split()))
memo = [[[-1, -1] for _ in range(X + Y + 1)] for _ in range(X + Y + 1)]
def search(x, y, person):
if x <= 1 and y <= 1:
return False if person == 0 else True
if x == 2 and y == 0 or x == 0 and y == 2:
return True if person == 0 else False
if memo[y][x][person] != -1:
return memo[y][x][person]
ret = False
for i in range(2, x + 1, 2):
ret |= search(x - i, y + i // 2, 1 if person == 0 else 0)
for i in range(2, y + 1, 2):
ret |= search(x + i // 2, y - i, 1 if person == 0 else 0)
memo[y][x][person] = ret
return ret
ans = search(X, Y, 0)
print(('Alice' if ans else 'Brown')) | X, Y = list(map(int, input().split()))
if abs(X - Y) <= 1:
print('Brown')
else:
print('Alice') | p03740 |
import sys
sys.setrecursionlimit(10**9)
X, Y = list(map(int, input().split()))
def rec(x, y) :
flg = False
for i in range(2, x + 1, 2) :
flg = flg or not rec(x-i, y+i//2)
for i in range(2, y + 1, 2) :
flg = flg or not rec(x+i//2, y-i)
return flg
if rec(X, Y) :
print('Alice')
else :
print('Brown') | X, Y = list(map(int, input().split()))
if abs(X-Y) <= 1 :
print('Brown')
else :
print('Alice') | p03740 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
A, B = list(map(int, input().split()))
while True:
if A == 0 and B == 0:
print("Brown")
break
while A > 1:
A -= 2
B += 1
while B > 1:
B -= 2
A += 1
if A == 1 and B == 0:
print("Brown")
break
elif A == 0 and B == 1:
print("Alice")
break
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
A, B = list(map(int, input().split()))
if abs(A - B) < 2:
print("Brown")
else:
print("Alice")
| p03740 |
import sys
from collections import deque
readline = sys.stdin.readline
n = int(readline())
li = list(map(int, readline().split()))
def square(P):
G = []
L = deque()
for i, v in enumerate(P):
if not L:
L.append((i, v))
continue
if v > L[-1][1]:
L.append((i, v))
elif v < L[-1][1]:
k = i - 1
while L and v < L[-1][1]:
a = L.pop()
G.append((k - a[0] + 1) * a[1])
L.append((a[0], v))
while L:
a = L.pop()
G.append((len(P) - a[0]) * a[1])
return max(G)
print((square(li))) | import sys
from collections import deque
readline = sys.stdin.readline
n = int(readline())
li = list(map(int, readline().split()))
def square(P):
G = []
L = deque()
for i, v in enumerate(P):
if not L:
L.append((i, v))
continue
if v > L[-1][1]:
L.append((i, v))
elif v < L[-1][1]:
k = i - 1
while L and v < L[-1][1]:
a = L.pop()
G.append((k - a[0] + 1) * a[1])
L.append((a[0], v))
while L:
a = L.pop()
G.append((n - a[0]) * a[1])
return max(G)
print((square(li))) | p02328 |
n = int(eval(input()))
hs = list(map(int, input().split()))
maxh = max(hs)
dp = [-1] * (maxh + 1)
ans = 0
for i, h in enumerate(hs):
for j in range(h + 1):
if dp[j] == -1:
dp[j] = i
for j in range(h + 1, maxh + 1):
if dp[j] != -1:
ans = max(ans, j * (i - dp[j]))
dp[j] = -1
ans = max(ans, max((n - i) * j for j, i in enumerate(dp) if i != -1))
print(ans) | n = int(eval(input()))
hs = list(map(int, input().split()))
stack = []
ans = 0
for i, h in enumerate(hs):
j = -1
while stack and stack[-1][1] > h:
j, h2 = stack.pop()
ans = max(ans, (i - j) * h2)
if not stack or stack[-1][1] < h:
stack.append((i if j == -1 else j, h))
ans = max(ans, max((n - j) * h2 for j, h2 in stack))
print(ans) | p02328 |
import sys
def solve(N, R):
print((R if N >= 10 else R + 100 * (10 - N)))
if __name__ == '__main__':
N, R = list(map(int, sys.stdin.readline().strip().split(" ")))
solve(N, R) | import sys
N, R = list(map(int, sys.stdin.readline().split()))
print((R if 10 <= N else R + 100 * (10 - N))) | p02765 |
N, R = list(map(int, input().split()))
if N >= 10:
print(R)
else:
print((R+(100*(10-N)))) | N, R= list(map(int, input().split()))
if N <= 10:
print((R+(100*(10-N))))
else:
print(R) | p02765 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N,R = MI()
print((R if N >= 10 else R+100*(10-N)))
| import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,R = MI()
print((R if N >= 10 else R+100*(10-N)))
| p02765 |
n, r = list(map(int, input().split()))
if n >= 10:
print(r)
else:
print((r + 100*(10-n)))
| import sys
stdin = sys.stdin
ni = lambda: int(ns())
ns = lambda: stdin.readline().rstrip()
na = lambda: list(map(int, stdin.readline().split()))
# code here
N, R = na()
if N >= 10:
print(R)
else:
print((R + 100*(10-N)))
| p02765 |
n,r = list(map(int,input().split()))
rate = 100*(10 - n)
if n >= 10:
print(r)
elif n < 10:
rate2 = rate + r
print((str(rate2))) | n,r = list(map(int,input().split()))
rate = 100*(10 - n)
if n >= 10:
print(r)
else:
rate2 = rate + r
print((str(rate2))) | p02765 |
#!/usr/bin/env python3
k,n = list(map(int,input().split()))
if k >= 10:
print(n)
else:
print((n+100*(10-k))) | #!/usr/bin/env python3
n,r = list(map(int,input().split()))
print((r+100*max(0,10-n))) | p02765 |
n,r=list(map(int,input().split()))
if n<10:
print((r+100*(10-n)))
else:
print(r) | n,r=list(map(int,input().split()));print((r+(n<10)*100*(10-n))) | p02765 |
N, R = list(map(int, input().split()))
print((R+max(0, 10-N)*100))
| N, R = list(map(int, input().split()))
if N >= 10:
print(R)
else:
print((R+100*(10-N)))
| p02765 |
import math
import itertools
import fractions
import heapq
import collections
import bisect
import sys
import copy
sys.setrecursionlimit(10**9)
mod = 10**7+9
inf = 10**20
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
n,r = LI()
if n<10:
print((r+(100*(10-n))))
else:
print(r) | n,r = list(map(int,input().split()))
if n>=10:
print(r)
else:
t = 100*(10-n)
print((r+t)) | p02765 |
n, r = list(map(int, input().split()))
ans = r
if n < 10:
ans += 100*(10-n)
print(ans) | n, r = list(map(int, input().split()))
if n >= 10:
ans = r
else:
# r = ans - 100 * (10 - n)
ans = r + 100 * (10 - n)
print(ans) | p02765 |
n,r=list(map(int,input().split()))
if n>=10:
print(r)
else:
ans=r+100*(10-n)
print(ans) | n, r = list(map(int, input().split()))
if n >= 10:
print(r)
else:
print((r + 100 * (10 - n)))
| p02765 |
#!/usr/bin/env python3
import sys
import itertools
def solve(N: int, C: int, D: "List[List[int]]", c: "List[List[int]]"):
c_list = list(itertools.permutations(list(range(C)),3))
answer = 10**9
for zero,one,two in c_list:
a = 0
for i in range(N):
for j in range(N):
color = c[i][j]
if (i+j) % 3 == 0:
a+= D[color-1][zero]
elif (i+j) % 3 == 1:
a+= D[color-1][one]
elif (i+j) % 3 == 2:
a+= D[color-1][two]
answer = min(answer,a)
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
C = int(next(tokens)) # type: int
D = [[int(next(tokens)) for _ in range(C)] for _ in range(C)] # type: "List[List[int]]"
c = [[int(next(tokens)) for _ in range(N)] for _ in range(N)] # type: "List[List[int]]"
solve(N, C, D, c)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
import itertools
def solve(N: int, C: int, D: "List[List[int]]", c: "List[List[int]]"):
answer = 10**9
cost = [[0 for _ in range(C)] for _ in range(3)]
for i in range(1,N+1):
for j in range(1,N+1):
cost[(i+j)%3][c[i-1][j-1]-1] += 1
for i in range(C):
for j in range(C):
for k in range(C):
if i==j or j==k or k==i:
continue
a = 0
for index in range(C):
a += cost[0][index]*D[index][i]
a += cost[1][index]*D[index][j]
a += cost[2][index]*D[index][k]
answer = min(a,answer)
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
C = int(next(tokens)) # type: int
D = [[int(next(tokens)) for _ in range(C)] for _ in range(C)] # type: "List[List[int]]"
c = [[int(next(tokens)) for _ in range(N)] for _ in range(N)] # type: "List[List[int]]"
solve(N, C, D, c)
if __name__ == '__main__':
main()
| p03330 |
import sys
from itertools import permutations
N, C = list(map(int, sys.stdin.readline().rstrip().split()))
d = []
for _ in range(C):
d.append(tuple(map(int, sys.stdin.readline().rstrip().split())))
r_0 = []
r_1 = []
r_2 = []
for i in range(N):
g = list(map(int, sys.stdin.readline().rstrip().split()))
for j in range(N):
if (i + j + 2) % 3 == 0:
r_0.append(g[j])
elif (i + j + 2) % 3 == 1:
r_1.append(g[j])
else:
r_2.append(g[j])
ans = 10**18
for c_1, c_2, c_3 in permutations(list(range(1, C + 1)), 3):
total = 0
for r in r_0:
total += d[r - 1][c_1 - 1]
for r in r_1:
total += d[r - 1][c_2 - 1]
for r in r_2:
total += d[r - 1][c_3 - 1]
ans = min(ans, total)
print(ans) | import sys
from itertools import permutations
N, C = list(map(int, sys.stdin.readline().rstrip().split()))
d = []
for _ in range(C):
d.append(tuple(map(int, sys.stdin.readline().rstrip().split())))
r_0 = []
r_1 = []
r_2 = []
for i in range(N):
g = list(map(int, sys.stdin.readline().rstrip().split()))
for j in range(N):
if (i + j) % 3 == 0:
r_0.append(g[j])
elif (i + j) % 3 == 1:
r_1.append(g[j])
else:
r_2.append(g[j])
def get_cost(r):
cost = [0] * (C + 1)
for c in range(1, C + 1):
for i in r:
cost[c] += d[i - 1][c - 1]
return cost
cost_0 = get_cost(r_0)
cost_1 = get_cost(r_1)
cost_2 = get_cost(r_2)
ans = 10**18
for c_0, c_1, c_2 in permutations(list(range(1, C + 1)), 3):
total = cost_0[c_0] + cost_1[c_1] + cost_2[c_2]
ans = min(ans, total)
print(ans) | p03330 |
n,c = list(map(int,input().split()))
D_list = [[int(i) for i in input().split()] for _ in range(c)]
c_list = [[int(i) for i in input().split()] for _ in range(n)]
ans = 10 ** 10
for i in range(1,c**3):
x=i%c
y=(i%c**2)//c
z=i//c**2
if x==y or y==z or z==x:
continue
else:
color=[x,y,z]
count = 0
for a in range(n):
for b in range(n):
if color[(a+b+2)%3] != c_list[b][a]-1:
count+=D_list[c_list[b][a]-1][color[(a+b+2)%3]]
if count < ans:
ans = count
print(ans)
| n,c = list(map(int,input().split()))
D_list = [[int(i) for i in input().split()] for _ in range(c)]
c_list = [[int(i) for i in input().split()] for _ in range(n)]
c_num=[[0 for _ in range(3)] for __ in range(c)]
for a in range(n):
for b in range(n):
c_num[c_list[b][a]-1][(a+b+2)%3] += 1
ans = 10 ** 10
for i in range(1,c**3):
x=i%c
y=(i%c**2)//c
z=i//c**2
if x==y or y==z or z==x:
continue
else:
color=[x,y,z]
count = 0
for s in range(3):
for t in range(c):
count += c_num[t][s] *D_list[t][color[s]]
if count < ans:
ans = count
print(ans)
| p03330 |
# divide this matrix into 3 groups according to the remainder
# then consider the cost
from itertools import permutations
N, C = [int(elem) for elem in input().split(' ')]
D_matrix = [[int(elem) for elem in input().split(' ')] for _ in range(C)]
assert len(D_matrix) == C
assert len(D_matrix[0]) == C
c_matrix = [[int(elem) for elem in input().split(' ')] for _ in range(N)]
assert len(c_matrix) == N
assert len(c_matrix[0]) == N
# grouping
# O(N^2)
mod_0, mod_1, mod_2 = [], [], []
for i in range(N):
for j in range(N):
if (i + j) % 3 == 0:
mod_0.append((i, j))
elif (i + j) % 3 == 1:
mod_1.append((i, j))
else:
mod_2.append((i, j))
# O(C^3 * N^2)
# muda
# only considering top 3 transitions is enough?
min_cost = float('inf')
for colors in permutations(list(range(C)), 3):
total_cost = 0
for idx_color, mod in enumerate((mod_0, mod_1, mod_2)):
for i, j in mod:
color = c_matrix[i][j] - 1
total_cost += D_matrix[color][colors[idx_color] - 1]
min_cost = min(min_cost, total_cost)
print(min_cost) | from itertools import permutations
N, C = [int(elem) for elem in input().split(' ')]
D_matrix = [[int(elem) for elem in input().split(' ')] for _ in range(C)]
assert len(D_matrix) == C
assert len(D_matrix[0]) == C
c_matrix = [[int(elem) for elem in input().split(' ')] for _ in range(N)]
assert len(c_matrix) == N
assert len(c_matrix[0]) == N
# grouping
# O(N^2)
mod_list = [[] for _ in range(3)]
for i in range(N):
for j in range(N):
mod_list[(i + j) % 3].append((i, j))
# O(N^2)
mod_color_list = [[0] * C for _ in range(3)]
for k, mod in enumerate(mod_list):
for i, j in mod:
mod_color_list[k][c_matrix[i][j] - 1] += 1
# O(C^3 * N^2) -> O(C^4)
min_cost = float('inf')
for colors in permutations(list(range(C)), 3):
total_cost = 0
for color, mod_color in zip(colors, mod_color_list):
total_cost += sum([D_matrix[X][color] * mod_color[X] for X in range(C)])
min_cost = min(min_cost, total_cost)
print(min_cost)
| p03330 |
# ABC099D - Good Grid
import sys
input = sys.stdin.readline
from collections import Counter
from itertools import product
def main():
N, C = list(map(int, input().split()))
D = [0] + list([0] + list(map(int, input().split())) for _ in range(C))
grid = tuple(tuple(map(int, input().split())) for _ in range(N))
cost = [Counter() for _ in range(3)]
for i, g in enumerate(grid):
for j in range(3):
cost[j].update(g[(j - i) % 3 :: 3])
dist = [[] for _ in range(3)]
for i, target in product(list(range(3)), list(range(1, C + 1))):
cur = sum(D[source][target] * cnt for source, cnt in list(cost[i].items()))
dist[i].append(cur)
ans = 1 << 60
for i, j in product(list(range(C)), repeat=2):
if i == j:
continue
cur = dist[0][i] + dist[1][j]
cur += min(x for k, x in enumerate(dist[2]) if k not in (i, j))
ans = min(ans, cur)
print(ans)
if __name__ == "__main__":
main() | # ABC099D - Good Grid
import sys
readline = sys.stdin.buffer.readline
from collections import Counter
from itertools import product
def main():
N, C = list(map(int, readline().split()))
D = [0] + list([0] + list(map(int, readline().split())) for _ in range(C))
grid = tuple(tuple(map(int, readline().split())) for _ in range(N))
cost = [Counter() for _ in range(3)]
for i, g in enumerate(grid):
for j in range(3):
cost[j].update(g[(j - i) % 3 :: 3])
dist = [[] for _ in range(3)]
for i, tgt in product(list(range(3)), list(range(1, C + 1))):
cur = sum(D[src][tgt] * cnt for src, cnt in list(cost[i].items()))
dist[i].append(cur)
ans = 1 << 60
for i, j in product(list(range(C)), repeat=2):
if i == j:
continue
cur = dist[0][i] + dist[1][j]
cur += min(x for k, x in enumerate(dist[2]) if k not in (i, j))
ans = min(ans, cur)
print(ans)
if __name__ == "__main__":
main() | p03330 |
# ABC099D - Good Grid
import sys
input = sys.stdin.readline
from collections import defaultdict
from itertools import product
def main():
N, C = list(map(int, input().split()))
D = [0] + list([0] + list(map(int, input().split())) for _ in range(C))
grid = tuple(tuple(map(int, input().split())) for _ in range(N))
cost = {i: defaultdict(int) for i in range(3)}
for i, g in enumerate(grid):
for j, x in enumerate(g):
cost[(i + j) % 3][x] += 1
dist = [[] for _ in range(3)]
for i, tgt in product(list(range(3)), list(range(1, C + 1))):
cur = sum(D[src][tgt] * cnt for src, cnt in list(cost[i].items()))
dist[i].append(cur)
ans = 1 << 60
for i, j in product(list(range(C)), repeat=2):
if i == j:
continue
cur = dist[0][i] + dist[1][j]
cur += min(x for k, x in enumerate(dist[2]) if k not in (i, j))
ans = min(ans, cur)
print(ans)
if __name__ == "__main__":
main() | # ABC099D - Good Grid
import sys
input = sys.stdin.readline
from collections import Counter
from itertools import product
def main():
N, C = list(map(int, input().split()))
D = [0] + list([0] + list(map(int, input().split())) for _ in range(C))
grid = tuple(tuple(map(int, input().split())) for _ in range(N))
cost = [Counter() for _ in range(3)]
for i, g in enumerate(grid): # classify each cell by mod3
for j in range(3):
cost[(i + j) % 3].update(g[j::3])
dist = [[] for _ in range(3)]
# compute the actual cost to change color
for i, tgt in product(list(range(3)), list(range(1, C + 1))):
cur = sum(D[src][tgt] * cnt for src, cnt in list(cost[i].items()))
dist[i].append(cur)
ans = 1 << 60
# fix two colors and compute the minimum cost
for i, j in product(list(range(C)), repeat=2):
if i == j:
continue
cur = dist[0][i] + dist[1][j]
cur += min(x for k, x in enumerate(dist[2]) if k not in (i, j))
ans = min(ans, cur)
print(ans)
if __name__ == "__main__":
main() | p03330 |
N,C = list(map(int,input().split()))
D = [[int(i) for i in input().split()] for _ in range(C)]
c = [[int(i) for i in input().split()] for _ in range(N)]
D_sum = [[0]*C for _ in range(3)]
for i in range(C):
for j in range(N):
for k in range(N):
D_sum[(j+k)%3][i] += D[c[j][k]-1][i]
ans = 1000*500*500
for i in range(C):
for j in range(C):
for k in range(C):
if i==j or j==k or k==i:
continue
else:
ans = min(ans, D_sum[0][i]+D_sum[1][j]+D_sum[2][k])
print(ans) | N,C = list(map(int,input().split()))
D = [[int(i) for i in input().split()] for j in range(C)]
c = [[int(i) for i in input().split()] for j in range(N)]
c_sum = [[0]*C for _ in range(3)]
for i in range(N):
for j in range(N):
c_sum[(i+j)%3][c[i][j]-1] += 1
D_sum = [[0]*C for _ in range(3)]
for i in range(C):
for j in range(C):
for k in range(3):
D_sum[k][j] += D[i][j] * c_sum[k][i]
ans = 1000*500*500
for i in range(C):
for j in range(C):
for k in range(C):
if i==j or j==k or k==i:
continue
else:
ans = min(ans, D_sum[0][i]+D_sum[1][j]+D_sum[2][k])
print(ans) | p03330 |
# 1. 入出力 (二次元配列)
N, C = list(map(int, input().split()))
D = [ list(map(int, input().split())) for _ in range(C) ]
col = [ list(map(int, input().split())) for _ in range(N) ]
ans = 1 << 60
for i in range(C):
for j in range(C):
for k in range(C):
if i == j or j == k or k == i:
continue
temp = 0
lst = [i, j, k]
for x in range(N):
for y in range(N):
mod = (x + y) % 3
temp += D[ col[x][y] - 1 ][ lst[mod] ]
ans = min(ans, temp)
# print(lst, temp)
print(ans) | # 1. 入出力 (二次元配列)
N, C = list(map(int, input().split()))
D = [ list(map(int, input().split())) for _ in range(C) ]
col = [ list(map(int, input().split())) for _ in range(N) ]
ans = 1 << 60
info = [ [0 for j in range(C)] for i in range(3) ]
for i in range(N):
for j in range(N):
mod = (i + j) % 3
info[mod][ col[i][j] - 1 ] += 1
for i in range(C):
for j in range(C):
for k in range(C):
if i == j or j == k or k == i:
continue
temp = 0
lst = [i, j, k]
for x in range(3):
for y in range(C):
temp += D[y][ lst[x] ] * info[x][y]
ans = min(ans, temp)
# print(lst, temp)
print(ans) | p03330 |
from collections import Counter
from itertools import permutations
import sys
input = sys.stdin.buffer.readline
N, C = list(map(int, input().split()))
D = [[int(x) for x in input().split()] for _ in range(C)]
cnt = [Counter() for _ in range(3)]
for i in range(N):
c = [int(x)-1 for x in input().split()]
for j in range(3):
cnt[j].update(c[(3-(i+2)+j)%3::3])
ans = 1000*500*500+5
for p in permutations(list(range(C)), 3):
s = 0
for j in range(3):
for k, v in list(cnt[j].items()):
s += D[k][p[j]] * v
ans = min(ans, s)
print(ans) | from collections import Counter
from itertools import permutations
def main():
N, C = list(map(int, input().split()))
D = [[int(x) for x in input().split()] for _ in range(C)]
cnt = [Counter() for _ in range(3)]
for i in range(N):
c = [int(x)-1 for x in input().split()]
for j in range(3):
cnt[j].update(c[(3-(i+2)+j)%3::3])
ans = 1000*500*500+5
for p in permutations(list(range(C)), 3):
s = 0
for j in range(3):
for k, v in list(cnt[j].items()):
s += D[k][p[j]] * v
ans = min(ans, s)
print(ans)
main() | p03330 |
from itertools import product, permutations
n, c = list(map(int, input().split()))
d = [list(map(int, input().split())) for _ in range(c)]
grid = [list(map(int, input().split())) for _ in range(n)]
cost = [[0] * c for _ in range(3)]
for i, j, k in product(list(range(n)), list(range(n)), list(range(c))):
# cost[0][k] -> 余りが0になる場所の色をkに変えるときのコスト
cost[(i + j + 2) % 3][k] += d[grid[i][j] - 1][k]
ans = []
for s, t, u in permutations(list(range(c)), r=3):
ans.append(cost[0][s] + cost[1][t] + cost[2][u])
print((min(ans))) | #%% D
from itertools import product, permutations
n, c = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(c)]
C = [list(map(int, input().split())) for _ in range(n)]
X = [[0] * c for i in range(3)]
for i in range(n):
for j in range(n):
X[(i + j + 2) % 3][C[i][j] - 1] += 1
cost = [[0] * c for i in range(3)]
for i in range(c):
for j in range(c):
cost[0][j] += X[0][i] * D[i][j]
cost[1][j] += X[1][i] * D[i][j]
cost[2][j] += X[2][i] * D[i][j]
ans = []
for s, t, u in permutations(list(range(c)), r=3):
ans.append(cost[0][s] + cost[1][t] + cost[2][u])
print((min(ans))) | p03330 |
import sys
input = sys.stdin.buffer.readline
def main():
n, c = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(c)]
C_ = [list(map(int, input().split())) for _ in range(n)]
C = [0]*n
for i, c_ in enumerate(C_):
c_ = [x-1 for x in c_]
C[i] = c_
#print(C)
L = [[0]*c for _ in range(3)]
for k in range(c):
for i in range(n):
for j in range(n):
m = (i+j)%3
x = C[i][j]
L[m][k] += D[x][k]
X = [[] for _ in range(3)]
for j in range(3):
for i, x in enumerate(L[j]):
X[j].append((x, i))
for i, x in enumerate(X):
x.sort()
x = x[0:3]
X[i] = x
#print(X)
import itertools
ans = 10**18
for p in itertools.product(list(range(3)), repeat=3):
used_col = set()
temp = 0
for j in range(3):
x, i =X[j][p[j]]
if i in used_col:
break
else:
temp += x
used_col.add(i)
else:
ans = min(temp, ans)
print(ans)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.buffer.readline
def main():
n, c = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(c)]
C_ = [list(map(int, input().split())) for _ in range(n)]
C = [0]*n
for i, c_ in enumerate(C_):
c_ = [x-1 for x in c_]
C[i] = c_
X = [[0]*c for _ in range(3)]
for i in range(n):
for j in range(n):
m = (i+j)%3
X[m][C[i][j]] += 1
#print(C)
import itertools
ans = 10**18
for p in itertools.permutations(list(range(c)), 3):
temp = 0
for i in range(3):
for j in range(c):
temp += D[j][p[i]]*X[i][j]
ans = min(ans, temp)
print(ans)
if __name__ == '__main__':
main()
| p03330 |
n, c = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(c)]
C = [list(map(int, input().split())) for _ in range(n)]
for i, l in enumerate(C):
l = [x-1 for x in l]
C[i] = l
import itertools
ans = 10**18
for p in itertools.permutations(list(range(c)), 3):
temp = 0
for i in range(n):
for j in range(n):
x = C[i][j]
y = p[(i+j)%3]
temp += D[x][y]
ans = min(temp, ans)
print(ans)
| n, c = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(c)]
C = [list(map(int, input().split())) for _ in range(n)]
for i, l in enumerate(C):
l = [x-1 for x in l]
C[i] = l
import itertools
ans = 10**18
X = [[0]*3 for _ in range(c)]
for i in range(n):
for j in range(n):
x = C[i][j]
X[x][(i+j)%3] += 1
for p in itertools.permutations(list(range(c)), 3):
temp = 0
for i in range(3):
for j in range(c):
temp += X[j][i]*(D[j][p[i]])
ans = min(temp, ans)
print(ans)
| p03330 |
N,C=list(map(int,input().split()))
D=[list(map(int,input().split())) for i in range(C)]
grid=[list(map(int,input().split())) for i in range(N)]
a=[[0]*C for i in range(3)]
for i in range(N):
tmp=i%3
for j in range(N):
a[tmp][grid[i][j]-1]+=1
tmp=(tmp+1)%3
b=[[0]*C for i in range(3)]
for i in range(3):
for j in range(C):
b[i][j]=sum([ D[k][j] * a[i][k] for k in range(C)])
b=[ sorted([ [b[i][j],j] for j in range(C)]) for i in range(3)]
ans=10**15
for i in range(3):
for j in range(3):
for k in range(3):
if b[0][i][1]!=b[1][j][1] and b[1][j][1]!=b[2][k][1] and b[2][k][1]!=b[0][i][1]:
ans=min(ans,b[0][i][0]+b[1][j][0]+b[2][k][0])
print(ans) | N,C=list(map(int,input().split()))
D=[list(map(int,input().split())) for i in range(C)]
grid=[list(map(int,input().split())) for i in range(N)]
a=[[0]*C for i in range(3)]
for i in range(N):
for j in range(N):
a[(i+j)%3][grid[i][j]-1]+=1
b=[[0]*C for i in range(3)]
for i in range(3):
for j in range(C):
b[i][j]=[ sum([ D[k][j] * a[i][k] for k in range(C)]), j]
b=[ sorted(b[i]) for i in range(3)]
ans=10**10
for i in range(3):
for j in range(3):
for k in range(3):
if b[0][i][1]!=b[1][j][1] and b[1][j][1]!=b[2][k][1] and b[2][k][1]!=b[0][i][1]:
ans=min(ans,b[0][i][0]+b[1][j][0]+b[2][k][0])
print(ans) | p03330 |
N,C=list(map(int,input().split()))
D=[list(map(int,input().split())) for i in range(C)]
grid=[list(map(int,input().split())) for i in range(N)]
a=[[0]*C for i in range(3)]
for i in range(N):
for j in range(N):
a[(i+j)%3][grid[i][j]-1]+=1
b=[[0]*C for i in range(3)]
for i in range(3):
for j in range(C):
b[i][j]=[ sum([ D[k][j] * a[i][k] for k in range(C)]), j]
b=[ sorted(b[i]) for i in range(3)]
ans=10**10
for i in range(3):
for j in range(3):
for k in range(3):
if b[0][i][1]!=b[1][j][1] and b[1][j][1]!=b[2][k][1] and b[2][k][1]!=b[0][i][1]:
ans=min(ans,b[0][i][0]+b[1][j][0]+b[2][k][0])
print(ans) | N,C=list(map(int,input().split()))
D=[list(map(int,input().split())) for i in range(C)]
grid=[list(map(int,input().split())) for i in range(N)]
a=[[0]*C for i in range(3)]
for i in range(N):
tmp=i%3
for j in range(N):
a[tmp][grid[i][j]-1]+=1
tmp=(tmp+1)%3
b=[[0]*C for i in range(3)]
for i in range(3):
for j in range(C):
b[i][j]=sum([ D[k][j] * a[i][k] for k in range(C)])
b=[ sorted([ [b[i][j],j] for j in range(C)]) for i in range(3)]
ans=1000000000
for i in range(3):
for j in range(3):
for k in range(3):
if b[0][i][1]!=b[1][j][1] and b[1][j][1]!=b[2][k][1] and b[2][k][1]!=b[0][i][1]:
ans=min(ans,b[0][i][0]+b[1][j][0]+b[2][k][0])
print(ans) | p03330 |
#!/usr/bin/env python3
import sys
def calc(order, groups, D):
ret = 0
for i, G in enumerate(groups):
target = order[i]
for elm in G:
#print(elm, target)
ret += D[elm - 1][target]
return ret
def dfs(idx, current, used, groups, D):
if idx == 3:
ret = calc(current, groups, D)
return ret
ret = float('inf')
for i, u in enumerate(used):
if not u:
used[i] = True
tmp = dfs(idx + 1, current + [i], used, groups, D)
ret = min(ret, tmp)
used[i] = False
return ret
def solve(N: int, C: int, D: "List[List[int]]", c: "List[List[int]]"):
groups = [[] for _ in range(3)]
for i in range(N):
for j in range(N):
cc = c[i][j]
groups[(i + j) % 3].append(cc)
#print(groups)
ret = dfs(0, [], [False] * C, groups, D)
print(ret)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
C = int(next(tokens)) # type: int
D = [ [ int(next(tokens)) for _ in range(C) ] for _ in range(C) ] # type: "List[List[int]]"
c = [ [ int(next(tokens)) for _ in range(N) ] for _ in range(N) ] # type: "List[List[int]]"
solve(N, C, D, c)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def calc_(order, d):
ret = 0
for i in range(3):
target = order[i]
ret += d[i][target]
return ret
def calc(G, target, D):
ret = 0
for elm in G:
ret += D[elm - 1][target]
return ret
def dfs(idx, current, used, d):
if idx == 3:
ret = calc_(current, d)
return ret
ret = float('inf')
for i, u in enumerate(used):
if not u:
used[i] = True
tmp = dfs(idx + 1, current + [i], used, d)
ret = min(ret, tmp)
used[i] = False
return ret
def solve(N: int, C: int, D: "List[List[int]]", c: "List[List[int]]"):
groups = [[] for _ in range(3)]
for i in range(N):
for j in range(N):
cc = c[i][j]
groups[(i + j) % 3].append(cc)
#print(groups)
d = [[] for _ in range(3)]
for i, G in enumerate(groups):
for j in range(C):
d[i].append(calc(G, j, D))
ret = dfs(0, [], [False] * C, d)
print(ret)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
C = int(next(tokens)) # type: int
D = [ [ int(next(tokens)) for _ in range(C) ] for _ in range(C) ] # type: "List[List[int]]"
c = [ [ int(next(tokens)) for _ in range(N) ] for _ in range(N) ] # type: "List[List[int]]"
solve(N, C, D, c)
if __name__ == '__main__':
main()
| p03330 |
N,C=list(map(int,input().split()))
Dmat=[]
for i in range(C):
array=list(map(int,input().split()))
Dmat.append(array)
#print(Dmat)
cmat=[]
for i in range(N):
array=list(map(int,input().split()))
cmat.append(array)
#print(cmat)
grid_list=[{},{},{}]
for i in range(N):
for j in range(N):
c=cmat[i][j]-1
mod=(i+j)%3
if c in grid_list[mod]:
grid_list[mod][c]+=1
else:
grid_list[mod][c]=1
#print(grid_list)
min_cost=10**9
for i in range(C):
for j in range(C):
if i==j:
continue
for k in range(C):
if i==k or j==k:
continue
cost=0
for c in grid_list[0]:
num=grid_list[0][c]
cost+=Dmat[c][i]*num
for c in grid_list[1]:
num=grid_list[1][c]
cost+=Dmat[c][j]*num
for c in grid_list[2]:
num=grid_list[2][c]
cost+=Dmat[c][k]*num
if cost<min_cost:
#print(i,j,k,cost)
min_cost=cost
print(min_cost) | N,C=list(map(int,input().split()))
Dmat=[]
for i in range(C):
array=list(map(int,input().split()))
Dmat.append(array)
#print(Dmat)
grid_list=[{},{},{}]
for i in range(N):
array=list(map(int,input().split()))
for j in range(N):
c=array[j]-1
mod=(i+j)%3
if c in grid_list[mod]:
grid_list[mod][c]+=1
else:
grid_list[mod][c]=1
#print(grid_list)
min_cost=10**9
for i in range(C):
for j in range(C):
if i==j:
continue
for k in range(C):
if i==k or j==k:
continue
cost=0
for c,num in list(grid_list[0].items()):
cost+=Dmat[c][i]*num
for c,num in list(grid_list[1].items()):
cost+=Dmat[c][j]*num
for c,num in list(grid_list[2].items()):
cost+=Dmat[c][k]*num
if cost<min_cost:
#print(i,j,k,cost)
min_cost=cost
print(min_cost) | p03330 |
from collections import defaultdict
from itertools import permutations
n, c = list(map(int, input().split()))
d = [list(map(int, input().split())) for _ in range(c)]
cmat = [list(map(int, input().split())) for _ in range(n)]
dcnt = [defaultdict(int) for _ in range(3)]
for i, ci in enumerate(cmat):
for j, cij in enumerate(ci):
mod = (i + j) % 3
dcnt[mod][cij - 1] += 1
ans = 10 ** 9
for color in permutations(list(range(c)), 3):
tmp = 0
for tgt, cnt in zip(color, dcnt):
tmp += sum(d[k][tgt] * cnt[k] for k in cnt)
ans = min(ans, tmp)
print(ans)
| from itertools import permutations
n, c = list(map(int, input().split()))
d = [list(map(int, input().split())) for _ in range(c)]
cmat = [list(map(int, input().split())) for _ in range(n)]
dcnt = [[0] * c for _ in range(3)]
for i, ci in enumerate(cmat):
for j, cij in enumerate(ci):
mod = (i + j) % 3
dcnt[mod][cij - 1] += 1
ans = 10 ** 9
for color in permutations(list(range(c)), 3):
tmp = 0
for tgt, cnt in zip(color, dcnt):
tmp += sum(d[i][tgt] * cnt[i] for i in range(c))
ans = min(ans, tmp)
print(ans)
| p03330 |
N, C = list(map(int, input().split()))
D = [list(map(int, input().split())) for i in range(C)]
c = [list(map(int, input().split())) for i in range(N)]
col = [[0]*3 for i in range(C)]
for i in range(N):
for j in range(N):
p = c[i][j]-1
for k in range(C):
col[k][(i+j)%3] += D[p][k]
ans = 10**18
for i in range(C):
for j in range(C):
if i == j:
continue
for k in range(C):
if i == k or j == k:
continue
ans = min(ans, col[i][0] + col[j][1] + col[k][2])
print(ans) | N, C = list(map(int, input().split()))
D = [list(map(int, input().split())) for i in range(C)]
c = [list(map(int, input().split())) for i in range(N)]
col = [[0]*C for i in range(3)]
for i in range(N):
ci = c[i]
for j in range(N):
cc = col[(i+j)%3]
dd = D[ci[j]-1]
for k in range(C):
cc[k] += dd[k]
ans = 10**18
c0 = col[0]
c1 = col[1]
c2 = col[2]
for i in range(C):
for j in range(C):
if i == j:
continue
for k in range(C):
if i == k or j == k:
continue
ans = min(ans, c0[i] + c1[j] + c2[k])
print(ans) | p03330 |
from itertools import permutations
n, c = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(c)]
C = [list(map(int, input().split())) for _ in range(n)]
colors = [[0]*c for _ in range(3)]
for i in range(n):
for j in range(n):
c_ij = C[i][j]-1
index = (i+j)%3
for col in range(c):
colors[index][col] += D[c_ij][col]
ans = 1000*500**2
for c0, c1, c2 in permutations(list(range(c)), 3):
diff = colors[0][c0] + colors[1][c1] + colors[2][c2]
ans = min(ans, diff)
print(ans)
| from itertools import permutations
n, c = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in range(c)]
C = [list(map(int, input().split())) for _ in range(n)]
colors = [[0]*c for _ in range(3)]
for i in range(n):
for j in range(n):
c_ij = C[i][j]-1
index = (i+j)%3
colors[index][c_ij] += 1
costs = [[0]*c for _ in range(3)]
for i in range(3):
for c_cur in range(c):
for c_tar in range(c):
costs[i][c_tar] += D[c_cur][c_tar]*colors[i][c_cur]
ans = 1000*500**2
for c0, c1, c2 in permutations(list(range(c)), 3):
diff = costs[0][c0] + costs[1][c1] + costs[2][c2]
ans = min(ans, diff)
print(ans)
| p03330 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, C = MAP()
D = [LIST() for _ in range(C)]
c = [LIST() for _ in range(N)]
group0 = []
group1 = []
group2 = []
for i in range(N):
for j in range(N):
if (i+j)%3 == 0:
group0.append(c[i][j]-1)
elif (i+j)%3 == 1:
group1.append(c[i][j]-1)
elif (i+j)%3 == 2:
group2.append(c[i][j]-1)
# print(group0)
# print(group1)
# print(group2)
color_0 = []
for i in range(C):
tmp = 0
for item0 in group0:
tmp += D[item0][i]
color_0.append((tmp, i))
color_0 = sorted(color_0)[0:3]
color_0_lis = [x[1] for x in color_0]
color_1 = []
for i in range(C):
tmp = 0
for item1 in group1:
tmp += D[item1][i]
color_1.append((tmp, i))
color_1 = sorted(color_1)[0:3]
color_1_lis = [x[1] for x in color_1]
color_2 = []
for i in range(C):
tmp = 0
for item2 in group2:
tmp += D[item2][i]
color_2.append((tmp, i))
color_2 = sorted(color_2)[0:3]
color_2_lis = [x[1] for x in color_2]
# print(color_0)
# print(color_0_lis)
# print(color_1)
# print(color_1_lis)
# print(color_2)
# print(color_2_lis)
ans = INF
for i in color_0_lis:
for j in color_1_lis:
for k in color_2_lis:
tmp = 0
if i == j or j == k or k == i:
continue
else:
for item0 in group0:
tmp += D[item0][i]
for item1 in group1:
tmp += D[item1][j]
for item2 in group2:
tmp += D[item2][k]
ans = min(ans, tmp)
print(ans)
| import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, C = MAP()
D = [LIST() for _ in range(C)]
c = [LIST() for _ in range(N)]
group0 = []
group1 = []
group2 = []
for i in range(N):
for j in range(N):
if (i+j)%3 == 0:
group0.append(c[i][j]-1)
elif (i+j)%3 == 1:
group1.append(c[i][j]-1)
elif (i+j)%3 == 2:
group2.append(c[i][j]-1)
# print(group0)
# print(group1)
# print(group2)
color_0 = []
inv_0 = {}
for i in range(C):
tmp = 0
for item0 in group0:
tmp += D[item0][i]
color_0.append((tmp, i))
inv_0[i] = tmp
color_0 = sorted(color_0)[0:3]
color_0_lis = [x[1] for x in color_0]
color_1 = []
inv_1 = {}
for i in range(C):
tmp = 0
for item1 in group1:
tmp += D[item1][i]
color_1.append((tmp, i))
inv_1[i] = tmp
color_1 = sorted(color_1)[0:3]
color_1_lis = [x[1] for x in color_1]
color_2 = []
inv_2 = {}
for i in range(C):
tmp = 0
for item2 in group2:
tmp += D[item2][i]
color_2.append((tmp, i))
inv_2[i] = tmp
color_2 = sorted(color_2)[0:3]
color_2_lis = [x[1] for x in color_2]
# print(color_0)
# print(color_0_lis)
# print(color_1)
# print(color_1_lis)
# print(color_2)
# print(color_2_lis)
ans = INF
for i in color_0_lis:
for j in color_1_lis:
for k in color_2_lis:
tmp = 0
if i == j or j == k or k == i:
continue
else:
tmp += inv_0[i]
tmp += inv_1[j]
tmp += inv_2[k]
ans = min(ans, tmp)
print(ans)
| p03330 |
N,C = list(map(int,input().split()))
D = []
for i in range(C):
d = list(map(int,input().split()))
D.append(d)
A = []
for i in range(N):
a = list(map(int,input().split()))
A.append(a)
X0,X1,X2 = [],[],[]
for i in range(N):
for j in range(N):
if (i+j)%3 == 0:
X0.append(A[i][j])
elif (i+j)%3 == 1:
X1.append(A[i][j])
else:
X2.append(A[i][j])
# それぞれの集合を塗り替える場合のコストを計算
Xn = [X0,X1,X2]
cost = [[0 for _ in range(C)] for _ in range(3)]
for i in range(3):
for c in range(1,C+1):
Ans = 0
for x in Xn[i]:
if x != c:
Ans += D[x-1][c-1]
cost[i][c-1] = Ans
Y0 = cost[0]
Y1 = cost[1]
Y2 = cost[2]
Ans = 1000000000000000
for i in range(C):
for j in range(C):
for k in range(C):
if i != j and j != k and k != i:
Ans = min(Ans, Y0[i]+Y1[j]+Y2[k])
print(Ans)
| # Python3 (3.4.3)
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
# 入力の C は M とする
N,M = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(M)]
C = [list(map(int,input().split())) for _ in range(N)]
# X[x][y] : (i+j)%3 == x の, 初期状態での色が y(0-indexed) のマスの数
X = [[0 for _ in range(M)] for _ in range(3)]
for i in range(N):
for j in range(N):
x = (i+1 + j+1)%3
y = C[i][j] - 1
X[x][y] += 1
# Y[x][y] : (i+j)%3 == x の領域を y で塗る場合に必要なコスト
Y = [[0 for _ in range(M)] for _ in range(3)]
for i in range(3):
for c_to in range(M):
total = 0
for c_from in range(M):
total += X[i][c_from] * D[c_from][c_to]
Y[i][c_to] = total
ans = 10**10
# 塗る色の組み合わせで全探索
for i in range(M):
for j in range(M):
for k in range(M):
# 全ての色が異なる場合のみ考える
if i != j and j != k and k != i:
ans = min(ans, Y[0][i] +Y[1][j] + Y[2][k] )
print(ans) | p03330 |
n,c = list(map(int, input().split()))
color, grid = [], []
for _ in range(c):
color.append(list(map(int, input().split())))
grid = {i:{} for i in range(3)}
for i in range(n):
for j,t in enumerate(map(int, input().split())):
t -= 1
if t not in grid[(i+j + 2) % 3]:
grid[(i+j + 2) % 3][t] = 0
grid[(i+j + 2) % 3][t] += 1
costs = [[0 for _ in range(c)],[0 for _ in range(c)],[0 for _ in range(c)]]
for cc in range(c):
for i in range(3):
for d,cnt in list(grid[i].items()):
costs[i][cc] += color[d][cc] * cnt
x = sorted(list(range(c)), key=lambda x: costs[0][x])[:3]
y = sorted(list(range(c)), key=lambda x: costs[1][x])[:3]
z = sorted(list(range(c)), key=lambda x: costs[2][x])[:3]
mn = 10**9
for i in x:
for j in y:
for k in z:
if i == j or j == k or k == i:
continue
if mn > costs[0][i] + costs[1][j] + costs[2][k]:
mn = costs[0][i] + costs[1][j] + costs[2][k]
print(mn) | import sys
input = sys.stdin.readline
n,c = list(map(int, input().split()))
color = []
for _ in range(c):
color.append(list(map(int, input().split())))
grid = {i:{} for i in range(3)}
for i in range(n):
for j,t in enumerate(map(int, input().split())):
t -= 1
if t not in grid[(i+j + 2) % 3]:
grid[(i+j + 2) % 3][t] = 0
grid[(i+j + 2) % 3][t] += 1
costs = [[0 for _ in range(c)],[0 for _ in range(c)],[0 for _ in range(c)]]
for cc in range(c):
for i in range(3):
for d,cnt in list(grid[i].items()):
costs[i][cc] += color[d][cc] * cnt
rc = list(range(c))
x = sorted(list(rc), key=lambda x: costs[0][x])[:3]
y = sorted(list(rc), key=lambda x: costs[1][x])[:3]
z = sorted(list(rc), key=lambda x: costs[2][x])[:3]
mn = 10**9
for i in x:
for j in y:
for k in z:
if i == j or j == k or k == i:
continue
if mn > costs[0][i] + costs[1][j] + costs[2][k]:
mn = costs[0][i] + costs[1][j] + costs[2][k]
print(mn) | p03330 |
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [eval(input()) for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [int(eval(input())) for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def roundUp(a, b):
return -(-a // b)
@staticmethod
def toUpperMultiple(a, x):
return Math.roundUp(a, x) * x
@staticmethod
def toLowerMultiple(a, x):
return (a // x) * x
@staticmethod
def nearPow2(n):
if n <= 0:
return 0
if n & (n - 1) == 0:
return n
ret = 1
while(n > 0):
ret <<= 1
n >>= 1
return ret
@staticmethod
def sign(n):
if n == 0:
return 0
if n < 0:
return -1
return 1
@staticmethod
def isPrime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
class PriorityQueue:
def __init__(self, l=[]):
self.__q = l
heapq.heapify(self.__q)
return
def push(self, n):
heapq.heappush(self.__q, n)
return
def pop(self):
return heapq.heappop(self.__q)
sys.setrecursionlimit(1000000)
MOD = int(1e09) + 7
INF = int(1e30)
def main():
# sys.stdin = open("Sample.txt")
N, C = Scanner.map_int()
D = Scanner.int_list_list(C)
colors = Scanner.int_list_list(N)
for i in range(N):
for j in range(N):
colors[i][j] -= 1
ans = INF
for i in range(6):
tmp = [[0 for _ in range(N)] for _ in range(N)]
for h in range(N):
for w in range(N):
if (h + w) % 3 == i // 2:
tmp[h][w] = 0
elif (h + w) % 3 == (i // 2 + (i % 2+1)) % 3:
tmp[h][w] = 1
else:
tmp[h][w] = 2
for a in range(C):
for b in range(C):
if a == b:
continue
for c in range(C):
if a == c or b == c:
continue
now = 0
for h in range(N):
for w in range(N):
if tmp[h][w] == 0:
now += D[colors[h][w]][a]
elif tmp[h][w] == 1:
now += D[colors[h][w]][b]
else:
now += D[colors[h][w]][c]
ans = min(ans, now)
print(ans)
return
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [eval(input()) for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [int(eval(input())) for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def roundUp(a, b):
return -(-a // b)
@staticmethod
def toUpperMultiple(a, x):
return Math.roundUp(a, x) * x
@staticmethod
def toLowerMultiple(a, x):
return (a // x) * x
@staticmethod
def nearPow2(n):
if n <= 0:
return 0
if n & (n - 1) == 0:
return n
ret = 1
while(n > 0):
ret <<= 1
n >>= 1
return ret
@staticmethod
def sign(n):
if n == 0:
return 0
if n < 0:
return -1
return 1
@staticmethod
def isPrime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
class PriorityQueue:
def __init__(self, l=[]):
self.__q = l
heapq.heapify(self.__q)
return
def push(self, n):
heapq.heappush(self.__q, n)
return
def pop(self):
return heapq.heappop(self.__q)
sys.setrecursionlimit(1000000)
MOD = int(1e09) + 7
INF = int(1e30)
def main():
# sys.stdin = open("Sample.txt")
N, C = Scanner.map_int()
D = Scanner.int_list_list(C)
colors = Scanner.int_list_list(N)
for i in range(N):
for j in range(N):
colors[i][j] -= 1
T = [[0 for _ in range(C)] for _ in range(3)]
for h in range(N):
for w in range(N):
T[(h+w) % 3][colors[h][w]] += 1
ans = INF
for a in range(C):
for b in range(C):
for c in range(C):
if a == b or a == c or b == c:
continue
now = 0
for d in range(C):
now += T[0][d] * D[d][a]
now += T[1][d] * D[d][b]
now += T[2][d] * D[d][c]
ans = min(ans, now)
print(ans)
return
if __name__ == "__main__":
main()
| p03330 |
# ContestName
# URL
import sys
#import numpy as np
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in ss]
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
def main():
N, C = i2nn()
D = ii2nnn(C)
c = ii2nnn(N)
def main2(afters):
#print('step %d' % cl)
n = 0
for i in range(N):
for j in range(N):
before = c[i][j]
after = afters[(i + j) % 3]
if before == after:
continue
iwakan = D[before-1][after-1]
n += iwakan
return n
iwakan = N * N * 1000
for c1 in range(C):
for c2 in range(C):
for c3 in range(C):
if c1 == c2 or c2 == c3 or c3 == c1:
continue
n = main2((c1+1, c2+1, c3+1))
if n < iwakan:
iwakan = n
print(iwakan)
main()
| # ContestName
# URL
import sys
#import numpy as np
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in ss]
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
def main():
N, C = i2nn()
D = ii2nnn(C)
c = ii2nnn(N)
E = [[0] * C for _ in range(3)]
for i in range(N):
for j in range(N):
before = c[i][j]
e = (i+j) % 3
for after in range(1, C+1):
E[e][after-1] += D[before-1][after-1]
iwakan = N * N * 1000
for c1 in range(C):
for c2 in range(C):
for c3 in range(C):
if c1 == c2 or c2 == c3 or c3 == c1:
continue
n = E[0][c1] + E[1][c2] + E[2][c3]
if n < iwakan:
iwakan = n
print(iwakan)
main()
| p03330 |
n,m=list(map(int,input().split()))
d=[list(map(int,input().split())) for _ in range(m)]
c=[list(map(int,input().split())) for _ in range(n)]
ans0=[0]
ans1=[0]
ans2=[0]
for k in range(1,m+1):
a0=0
a1=0
a2=0
for i in range(n):
for j in range(n):
if (i+j+2)%3==0:
a0+=d[c[i][j]-1][k-1]
elif (i+j+2)%3==1:
a1+=d[c[i][j]-1][k-1]
else:
a2+=d[c[i][j]-1][k-1]
ans0.append(a0)
ans1.append(a1)
ans2.append(a2)
ans=float("inf")
import itertools
for x,y,z in itertools.permutations(list(range(1,m+1)),3):
ans=min(ans,ans0[x]+ans1[y]+ans2[z])
print(ans)
| N,C=list(map(int,input().split()))
d=[list(map(int,input().split())) for _ in range(C)]
c=[list(map(int,input().split())) for _ in range(N)]
x=[[0]*(C+1) for _ in range(3)]
for i in range(N):
for j in range(N):
x[(i+j+2)%3][c[i][j]]+=1
from itertools import permutations
ans=1<<32
for ch in permutations(list(range(1,C+1)),3):
ans1=0
for i in range(3):
for j in range(1,C+1):
ans1+=x[i][j]*d[j-1][ch[i]-1]
ans=min(ans,ans1)
print(ans)
| p03330 |
from itertools import*
import sys
input=sys.stdin.readline
n,c=list(map(int,input().split()))
cost=[list(map(int,input().split()))for i in range(c)]
d=[[],[],[]]
for i in range(n):
for j,v in enumerate(map(int,input().split())):
d[(i+j+2)%3].append(v-1)
ans=[]
for cmb in permutations(list(range(c)),3):
ans.append(sum(sum(cost[i][cmb[dindex]]for i in d[dindex])for dindex in range(3)))
print((min(ans))) | from itertools import*
n,c=list(map(int,input().split()))
cost=[list(map(int,input().split()))for i in range(c)]
d=[[0]*c for i in range(3)]
for i in range(n):
for j,v in enumerate(map(int,input().split())):
d[(i+j)%3][v-1]+=1
print((min(sum(cost[j][cmb[i]]*d[i][j]for j in range(c)for i in range(3))for cmb in permutations(list(range(c)),3)))) | p03330 |
n,c = [int(i) for i in input().split()]
d = []
for i in range(c):
d.append(list(map(int, input().split())))
color = []
for i in range(n):
color.append(list(map(int, input().split())))
wrongfeeling = [[0 for i in range(3)] for j in range(c)]
for a in range(c):
for l in range(n):
for row in range(n):
wrongfeeling[a][(l+row)%3] += d[color[row][l]-1][a]
D = wrongfeeling[0][0]+wrongfeeling[1][1]+wrongfeeling[2][2]
for c0 in range (c):
for c1 in range (c):
if c1 == c0:
continue
for c2 in range (c):
if c2 == c1 or c2 == c0:
continue
D = min(D,wrongfeeling[c0][0]+wrongfeeling[c1][1]+wrongfeeling[c2][2])
print(D) | n,c = [int(i) for i in input().split()]
d = [[int(i) for i in input().split()]for i in range(c)]
#d[A][B] はAからBになるときの違和感
color = [[int(i) for i in input().split()]for i in range(n)]
devcol = [[0 for i in range(3)] for j in range(c)]
for l in range(n):
for row in range(n):
devcol[color[l][row]-1][(l+row)%3] += 1
Dsum = [[0 for i in range(3)] for j in range(c)]
for i in range(c):
for j in range(c):
for k in range(3):
Dsum[i][k] += d[j][i]*devcol[j][k]
D = Dsum[0][0]+Dsum[1][1]+Dsum[2][2]
for c0 in range (c):
for c1 in range (c):
if c1 == c0:
continue
for c2 in range (c):
if c2 == c1 or c2 == c0:
continue
D = min(D,Dsum[c0][0]+Dsum[c1][1]+Dsum[c2][2])
#O(c^3)のつもり
print(D) | p03330 |
from itertools import permutations
# use faster method than input()
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N, C = list(map(int, input().split()))
D = []
for _ in range(C):
D.append(list(map(int, input().split())))
# それぞれのグループで、color_iが何個あるかをカウント
mod_0 = [0]*C
mod_1 = [0]*C
mod_2 = [0]*C
for i in range(N):
l = list(map(int, input().split()))
for j in range(N):
m = i+j
color = l[j]-1
if m % 3 == 0:
mod_0[color] += 1
elif m % 3 == 1:
mod_1[color] += 1
else:
mod_2[color] += 1
# もしかしたら、貪欲かも
# 書き換え方を全通ためして、min
def brute_force():
ans = float('inf')
per = permutations(list(range(C)), 3)
for c1, c2, c3 in per:
cost = 0
for i in range(C):
cost += D[i][c1]*mod_0[i]
for i in range(C):
cost += D[i][c2]*mod_1[i]
for i in range(C):
cost += D[i][c3]*mod_2[i]
ans = min(ans, cost)
return ans
print((brute_force()))
| from itertools import permutations
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
N, C = list(map(int, input().split()))
D = []
for _ in range(C):
D.append(list(map(int, input().split())))
# それぞれのグループで、color_iが何個あるかをカウント
mod_0 = [0]*C
mod_1 = [0]*C
mod_2 = [0]*C
for i in range(N):
l = list(map(int, input().split()))
for j in range(N):
m = i+j
color = l[j]-1
if m % 3 == 0:
mod_0[color] += 1
elif m % 3 == 1:
mod_1[color] += 1
else:
mod_2[color] += 1
# 書き換え方を全通ためして、min
def solve():
ans = float('inf')
per = permutations(list(range(C)), 3)
for c1, c2, c3 in per:
cost = 0
for i in range(C):
cost += D[i][c1]*mod_0[i]
for i in range(C):
cost += D[i][c2]*mod_1[i]
for i in range(C):
cost += D[i][c3]*mod_2[i]
ans = min(ans, cost)
return ans
print((solve()))
| p03330 |
N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(C)]
c = [list([int(x)-1 for x in input().split()]) for _ in range(N)]
ans = 10000*N*N
for i in range(C):
cur_score = 0
for x in range(N):
for y in range((-x)%3,N,3):
cur_score += D[c[x][y]][i]
if cur_score>ans:
continue
for j in range(C):
cur_score2 = 0
if j == i:
continue
for x in range(N):
for y in range((1-x)%3,N,3):
cur_score2 += D[c[x][y]][j]
if cur_score+cur_score2>ans:
continue
for k in range(C):
cur_score3 = 0
if k == j or k == i:
continue
for x in range(N):
for y in range((2-x)%3,N,3):
cur_score3 += D[c[x][y]][k]
ans = min(ans,cur_score+cur_score2+cur_score3)
print(ans) | N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(C)]
c = [list([int(x)-1 for x in input().split()]) for _ in range(N)]
n = [[0]*C for _ in range(3)]
for i in range(N):
for j in range(N):
n[(i+j)%3][c[i][j]] += 1
ans = 500*500*1000
for c0 in range(C):
for c1 in range(C):
if c1 == c0:
continue
for c2 in range(C):
if c2 in (c0,c1):
continue
score = 0
for a in range(C):
score += n[0][a] * D[a][c0] + n[1][a] * D[a][c1] + n[2][a] * D[a][c2]
ans = min(ans,score)
print(ans) | p03330 |
s=input().split()
N=int(s[0])
C=int(s[1])
d=[]
for i in range(C):
s=input().split()
temp=[]
for item in s:
temp.append(int(item))
d.append(temp)
if N==1:
print("0")
else:
c=[[],[],[]]
cost=[[],[],[]]
for j in range(N):
s=input().split()
for i in range(len(s)):
c[(i+j)%3].append(int(s[i])-1)
for i in range(C):
s=0
for col in c[0]:
s+=d[col][i]
cost[0].append((s,i))
s=0
for col in c[1]:
s+=d[col][i]
cost[1].append((s,i))
s=0
for col in c[2]:
s+=d[col][i]
cost[2].append((s,i))
res=100000000000
for i in range(C):
for j in range(C):
for k in range(C):
if cost[0][i][1]!=cost[1][j][1] and cost[1][j][1]!=cost[2][k][1] and cost[2][k][1]!=cost[0][i][1]:
res=min(res,cost[0][i][0]+cost[1][j][0]+cost[2][k][0])
print(res)
| s=input().split()
n=int(s[0])
c=int(s[1])
d=[[0 for i in range(c+1)] for j in range(c+1)]
for i in range(c):
s=input().split()
for j in range(c):
d[i+1][j+1]=int(s[j])
cnt=[[0 for i in range(c+1)],[0 for i in range(c+1)],[0 for i in range(c+1)]]
for i in range(n):
s=input().split()
for j in range(n):
cnt[(i+j)%3][int(s[j])]+=1
cnt[(i+j)%3][0]+=1
iwa=[[0 for i in range(c+1)],[0 for i in range(c+1)],[0 for i in range(c+1)]]
for i in range(1,c+1):
for j in range(1,c+1):
for k in range(3):
iwa[k][i]+=d[j][i]*cnt[k][j]
m=10**9
for i in range(1,1+c):
for j in range(1,1+c):
for k in range(1,1+c):
if i==j or j==k or k==i:
continue
m=min(m,iwa[0][i]+iwa[1][j]+iwa[2][k])
print(m) | p03330 |
N,C = list(map(int,input().split()))
D = []
for i in range(C):
D.append(list(map(int,input().split())))
c = []
for i in range(N):
c.append(list(map(int,input().split())))
current_minimum = 1000 * 500 * 500 + 1
import itertools
for (c0,c1,c2) in itertools.permutations(list(range(C)), 3):
color = [c0,c1,c2]
tmp = 0
for (i,j) in itertools.product(list(range(N)),list(range(N))):
current_color = c[i][j]
target_color = color[((i+1)+(j+1)) % 3]
tmp += D[current_color - 1][target_color-1]
if current_minimum >= tmp:
current_minimum = tmp
print(current_minimum) | N,C = list(map(int,input().split()))
D = []
for i in range(C):
D.append(list(map(int,input().split())))
c = []
for i in range(N):
c.append(list(map(int,input().split())))
import itertools
current_minimum = 1000 * 500 * 500 + 1
Z = []
Z.append([0]*C)
Z.append([0]*C)
Z.append([0]*C)
#print(Z)
for (i,j) in itertools.product(list(range(N)),list(range(N))):
cur_mod = ((i+1)+(j+1)) % 3
cur_color = c[i][j]
#print(cur_mod)
#print(cur_color)
Z[cur_mod][cur_color-1] += 1
current_minimum = 1000 * 500 * 500 + 1
for (c0,c1,c2) in itertools.permutations(list(range(C)), 3):
tmp = 0
color = [c0,c1,c2]
for cur_mod in range(3):
target_color = color[cur_mod]
for cur_color in range(C):
tmp += Z[cur_mod][cur_color] * D[cur_color][target_color]
if current_minimum >= tmp:
current_minimum = tmp
print(current_minimum)
| p03330 |
N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(C)]
G = [list(map(int,input().split())) for _ in range(N)]
g1 = []
g2 = []
g3 = []
for i in range(N):
for j in range(N):
G[i][j] -= 1
if (i+j)%3 == 0:
g1.append(G[i][j])
if (i+j)%3 == 1:
g2.append(G[i][j])
if (i+j)%3 == 2:
g3.append(G[i][j])
# print(g1) # グループ1の色リスト
# print(g2)
# print(g3)
# for k in range(C):
# for i in range(C):
# for j in range(C):
# D[i][j] = min(D[i][j], D[i][k] + D[k][j])
ans = float('inf')
for c1 in range(C):
for c2 in range(C):
for c3 in range(C):
temp = 0
if c1 == c2 or c2 == c3 or c3 == c1:
continue
temp += sum(D[clr_g1][c1] for clr_g1 in g1)
temp += sum(D[clr_g2][c2] for clr_g2 in g2)
temp += sum(D[clr_g3][c3] for clr_g3 in g3)
ans = min(ans,temp)
print(ans) | N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(C)]
G = [list(map(int,input().split())) for _ in range(N)]
g1 = []
g2 = []
g3 = []
for i in range(N):
for j in range(N):
G[i][j] -= 1
if (i+j)%3 == 0:
g1.append(G[i][j])
if (i+j)%3 == 1:
g2.append(G[i][j])
if (i+j)%3 == 2:
g3.append(G[i][j])
cost = [[0]*3 for _ in range(C)]
for c in range(C):
for g in range(3):
if g == 0:
cost[c][0] = sum(D[clr_g1][c] for clr_g1 in g1)
if g == 1:
cost[c][1] = sum(D[clr_g2][c] for clr_g2 in g2)
if g == 2:
cost[c][2] = sum(D[clr_g3][c] for clr_g3 in g3)
ans = float('inf')
for c1 in range(C):
for c2 in range(C):
for c3 in range(C):
temp = 0
if c1 == c2 or c2 == c3 or c3 == c1:
continue
# temp += sum(D[clr_g1][c1] for clr_g1 in g1)
# temp += sum(D[clr_g2][c2] for clr_g2 in g2)
# temp += sum(D[clr_g3][c3] for clr_g3 in g3)
temp = cost[c1][0] + cost[c2][1] + cost[c3][2]
ans = min(ans,temp)
print(ans) | p03330 |
N,C = list(map(int,input().split()))
D = [[int(i) for i in input().split()] for _ in range(C)]
c = [[int(i) for i in input().split()] for _ in range(N)]
modl = [[] for i in range(3)]
for i in range(N):
for j in range(N):
modl[((i+1)+(j+1))%3].append(c[i][j])
ans = float('inf')
for i in range(C):
total = 0
tmp1 = 0
for e in modl[0]:
tmp1 += D[e-1][i]
total += tmp1
for j in range(C):
if i!=j:
tmp2 = 0
for e in modl[1]:
tmp2 += D[e-1][j]
total += tmp2
for k in range(C):
tmp3 = 0
if i!=k and j!=k:
for e in modl[2]:
tmp3 += D[e-1][k]
total += tmp3
ans = min(ans,total)
total -= tmp3
total -= tmp2
print(ans)
| N,C = list(map(int,input().split()))
D = [[int(i) for i in input().split()] for _ in range(C)]
c = [[int(i) for i in input().split()] for _ in range(N)]
modl = [[0 for i in range(C)] for i in range(3)]
for i in range(N):
for j in range(N):
modl[((i+1)+(j+1))%3][c[i][j]-1] += 1
ans = float('inf')
for i in range(C):
for j in range(C):
for k in range(C):
if i==j or i==k or j==k:
continue
total = 0
for l in range(C):
total += D[l][i]*modl[0][l]+D[l][j]*modl[1][l]+D[l][k]*modl[2][l]
ans = min(ans,total)
print(ans)
| p03330 |
lngN, lngC = list(map(int, input().split()))
## lstD[x][y]
## 1 オリジン の C × C グリッド として扱うために、[False] * lngC を第一行と第一列に追加
## x -> y に塗り替えたときの違和感
## x, y: 0 ... lngC - 1
lstD = []
lstD.append([False] * lngC)
for i in range(lngC):
lstD.append([False] + list(map(int, input().split())))
## lstC[i][j]
## 1 オリジン の N × N グリッド として扱うために、[False] * lngN を第一行と第一列に追加
## マス(i, j)の初期色
## 1 から C までの値を取る
lstC = []
lstC.append([False] * lngN)
for i in range(lngN):
lstC.append([False] + list(map(int, input().split())))
## lstDSum[r][c]
## 剰余 r のグループを 色 c で塗るときの違和感の和
## [c]を 1 オリジン として扱うために、[False] * lngC を第一行に追加
## r: 0, 1, 2
## c: 1 ... lngC
lstDSum = [False] * 3
for r in range(3):
lstDSum[r] = [False] * (lngC + 1)
for c in range(1, lngC + 1):
lstDSum[r][c] = 0##違和感の初期値
for i in range(1, lngN + 1):
for j in range(1, lngN + 1):
for c in range(1, lngC + 1):
r = (i + j) % 3## 剰余
oriC = lstC[i][j]##初期色
lstDSum[r][c] += lstD[oriC][c]
ans = float('inf')
for i in range(1, lngC + 1):
for j in range(1, lngC + 1):
if (i != j):
for k in range(1, lngC + 1):
if (i != k) and (j != k):
ans = min(ans, lstDSum[0][i] + lstDSum[1][j] + lstDSum[2][k])
print(ans)
##グリッドのマス(i, j)とすると,
##(i + j) % 3 の値によって, マスは 3 グループに分かれる (0, 1, 2)
##各グループの色分けの仕方は, itertools.permutations(c, 3) 通り
##内訳は次の通り
##(0)色 1 から C までの C 通りに色分け
##(1)色 1 から C までの (C - 1) 通りに色分け ((0) 分を除外)
##(2)色 1 から C までの (C - 2) 通りに色分け ((0, 1) 分を除外)
##各グループについて
##色 1 から C までの C 通りに色分けしたときの違和感の和を配列化
##lstDSum[グループ番号][色]
##グループ番号: 0, 1, 2
##色: 1 から C まで
##for 文で, 各グループを塗る色を全探索
##(グループ番号, 色) = (0, i), (1, j), (2, k)とするときの違和感の和
##lstDSum[0][i] + lstDSum[1][j] + lstDSum[2][k]
##これの最小値を取ればよい
| n, c = list(map(int, input().split()))
arrD = list(list(map(int, input().split())) for i in range(c))
arrC = list(list(map(int, input().split())) for i in range(n))
##剰余r=0,1,2で、
##色の出現数を確認する -> いずれかの色に統一する
##どの色に統一するか全パターンを実施して、違和感を算出
##和を取る
## arrCCnt[r][c]: 剰余rグループにおける初期色cのマス数
arrCCnt = []
for r in range(3):
arrCCnt.append([0] * (c + 1))
for i in range(1, n + 1):
for j in range(1, n + 1):
r = (i + j) % 3
oriC = arrC[i - 1][j - 1]
arrCCnt[r][oriC] += 1
ret = float('inf')
for c0 in range(1, c + 1):
for c1 in range(1, c + 1):
if (c0 != c1):
for c2 in range(1, c + 1):
if (c1 != c2) and (c2 != c0):
arrToC = [c0, c1, c2]
buf = 0
for r in range(3):
for oriC in range(1, c + 1):
buf += arrD[oriC - 1][arrToC[r] - 1] * arrCCnt[r][oriC]
ret = min(ret, buf)
print(ret) | p03330 |
def iin(): return int(eval(input()))
def nl(): return list(map(int, input().split()))
def ary(r, c, v): return [[v for _ in range(c)] for _ in range(r)]
N, C = nl()
d = [nl() for _ in range(C)]
c = [nl() for _ in range(N)]
ans = float('inf')
for c0 in range(1, C + 1):
for c1 in range(1, C + 1):
if c0 == c1:
continue
for c2 in range(1, C + 1):
if c0 == c2 or c1 == c2:
continue
cost = 0
for i in range(N):
for j in range(N):
next_color = [c0, c1, c2][(i + j) % 3]
cost += d[c[i][j] - 1][next_color - 1]
ans = min(ans, cost)
print(ans) | def iin(): return int(eval(input()))
def nl(): return list(map(int, input().split()))
def ary(r, c, v): return [[v for _ in range(c)] for _ in range(r)]
N, C = nl()
d = [nl() for _ in range(C)]
c = [nl() for _ in range(N)]
color_count_by_r = []
for i in range(3):
color_count_by_r.append(dict())
for i in range(N):
for j in range(N):
color_count_by_r[(i + j) % 3][c[i][j]] = color_count_by_r[(i + j) % 3].get(c[i][j], 0) + 1
ans = float('inf')
for c0 in range(1, C + 1):
for c1 in range(1, C + 1):
if c0 == c1:
continue
for c2 in range(1, C + 1):
if c0 == c2 or c1 == c2:
continue
cost = 0
for i in range(3):
for j in range(1, C + 1):
next_color = [c0, c1, c2][i]
cost += color_count_by_r[i].get(j, 0) * d[j - 1][next_color - 1]
ans = min(ans, cost)
print(ans) | p03330 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = I()
return l
def LIR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = LI()
return l
def SR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = S()
return l
def LSR(n):
l = [None for i in range(n)]
for i in range(n):l[i] = SR()
return l
mod = 1000000007
#A
def A():
return
#B
def B():
return
#C
def C():
n = I()
ans = float("inf")
for i in range(n+1):
m = 0
k = i
while k > 0:
m += k%6
k //= 6
k = n-i
while k > 0:
m += k%9
k //= 9
ans = min(ans,m)
print(ans)
#D
def D():
n,C = LI()
f = LIR(C)
c = LIR(n)
d = [defaultdict(int) for i in range(3)]
for i in range(n):
for j in range(n):
d[(i+j+2)%3][c[i][j]-1] += 1
ans = float("inf")
for i in range(C):
for j in range(C):
if i != j:
for k in range(C):
if k != i and k != j:
m = 0
for a in list(d[0].keys()):
m += d[0][a]*f[a][i]
for a in list(d[1].keys()):
m += d[1][a]*f[a][j]
for a in list(d[2].keys()):
m += d[2][a]*f[a][k]
ans = min(ans,m)
print(ans)
#E
def E():
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == "__main__":
D()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,C = LI()
d = LIR(C)
c = LIR(n)
ans = 0
s = [[0]*C for i in range(3)]
for i in range(n):
for j in range(n):
s[(i+j)%3][c[i][j]-1] += 1
ans = float("inf")
for x in range(C):
bx = 1<<x
for y in range(C):
if x == y:
continue
by = 1<<y
for z in range(C):
if z == x or z == y:
continue
cost = 0
for j in range(C):
cost += s[0][j]*d[j][x]
cost += s[1][j]*d[j][y]
cost += s[2][j]*d[j][z]
if cost < ans:
ans = cost
print(ans)
return
#Solve
if __name__ == "__main__":
solve()
| p03330 |
# -*- coding: utf-8 -*-
from itertools import permutations
N, C = list(map(int, input().split()))
D = [int(_) for c in range(C) for _ in input().split()]
G = [int(_) for n in range(N) for _ in input().split()]
table = [0] * C * 3
for row in range(N):
for col in range(N):
i = (row + col) % 3
for c in range(C):
table[i * C + c] += D[C * (G[N * row + col] - 1) + c]
def cost(comb):
return table[C * 0 + comb[0]] + table[C * 1 + comb[1]] + table[C * 2
+ comb[2]]
combs = permutations(list(range(C)), 3)
min_cst = cost(min(combs, key=lambda comb: cost(comb)))
print(min_cst)
| # -*- coding: utf-8 -*-
N, C = list(map(int, input().split()))
D = []
for c in range(C):
D.append([int(d) for d in input().split()])
Gmod = [[0 for i in range(C)] for i in range(3)]
for n in range(N):
for m, g in enumerate(input().split()):
Gmod[(n + m) % 3][int(g) - 1] += 1
K = []
for c0 in range(C):
d0 = sum([Gmod[0][c] * D[c][c0] for c in range(C)])
for c1 in [i for i in range(C) if not i == c0]:
d1 = sum([Gmod[1][c] * D[c][c1] for c in range(C)])
for c2 in [i for i in range(C) if (not i == c0) and (not i == c1)]:
d2 = sum([Gmod[2][c] * D[c][c2] for c in range(C)])
K.append(d0 + d1 + d2)
print((min(K)))
| p03330 |
from itertools import permutations
n,m=list(map(int,input().split()))
cost=[]
for i in range(m):
cost.append([int(i) for i in input().split()])
clr=[]
for i in range(n):
clr.append([int(i) for i in input().split()])
l=[i for i in range(m)]
ind=[[] for i in range(4)]
for i in range(n):
for j in range(n):
curr=(i+1+j+1)%3
ind[curr].append(clr[i][j]-1)
mini=10**9
for i in range(m):
for j in range(m):
for k in range(m):
if i==j or i==k or j==k:
continue
curr=0
for x in ind[0]:
curr+=cost[x][i]
for x in ind[1]:
curr+=cost[x][j]
for x in ind[2]:
curr+=cost[x][k]
mini=min(mini,curr)
print(mini)
| from itertools import permutations
n,m=list(map(int,input().split()))
cost=[]
for i in range(m):
cost.append([int(i) for i in input().split()])
clr=[]
for i in range(n):
clr.append([int(i) for i in input().split()])
l=[i for i in range(m)]
ind=[[0 for j in range(m)] for i in range(4)]
for i in range(n):
for j in range(n):
curr=(i+1+j+1)%3
ind[curr][clr[i][j]-1]+=1
mini=10**9
for i in range(m):
for j in range(m):
for k in range(m):
if i==j or i==k or j==k:
continue
curr=0
for it in range(3):
for it1 in range(m):
if it==0:
k1=i
elif it==1:
k1=j
else:
k1=k
curr+=ind[it][it1]*cost[it1][k1]
mini=min(mini,curr)
print(mini)
| p03330 |
N, C = [int(x) for x in input().split()]
D = [[0] * C for _ in range(C)]
c = [[0] * N for _ in range(N)]
for i in range(C):
D[i] = [int(x) for x in input().split()]
for i in range(N):
c[i] = [int(x) for x in input().split()]
I = [[0, 0, 0] for _ in range(C)]
for i in range(N):
for j in range(N):
pattern = (i + j) % 3
for toC in range(C):
I[toC][pattern] += D[c[i][j] - 1][toC]
ans = 99999999999999999999
for p1 in range(C):
for p2 in range(C):
if p1 == p2:
continue
a = I[p1][0] + I[p2][1]
for p3 in range(C):
if p1 == p3 or p2 == p3:
continue
ans = min(ans, a + I[p3][2])
print(ans)
| N, C = [int(x) for x in input().split()]
D = [[0] * C for _ in range(C)]
c = [[0] * N for _ in range(N)]
for i in range(C):
D[i] = [int(x) for x in input().split()]
for i in range(N):
c[i] = [int(x) for x in input().split()]
I = [[0, 0, 0] for _ in range(C)]
COL = [[0, 0, 0] for _ in range(C)]
for i in range(N):
for j in range(N):
COL[c[i][j] - 1][(i + j) % 3] += 1
for p in range(3):
for toC in range(C):
for fromC in range(C):
I[toC][p] += D[fromC][toC] * COL[fromC][p]
# I[toC][pattern] += D[c[i][j] - 1][toC]
ans = 99999999999999999999
for p1 in range(C):
for p2 in range(C):
if p1 == p2:
continue
a = I[p1][0] + I[p2][1]
for p3 in range(C):
if p1 == p3 or p2 == p3:
continue
ans = min(ans, a + I[p3][2])
print(ans)
| p03330 |
from itertools import *
N, C = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in [0]*C]
c = [list(map(int, input().split())) for _ in [0]*N]
tri = [[] for _ in [0]*3]
for i in range(1, N+1):
for j in range(1, N+1):
tri[(i+j) % 3] += [c[i-1][j-1] - 1]
incom = [[0]*C for _ in [0]*3]
for i in range(3):
for color in range(C):
incom[i][color] = sum(D[x][color] for x in tri[i])
ans = 1<<30
for p in permutations(list(range(C)), 3):
t = sum(incom[x][y]for x,y in enumerate(p))
if t < ans: ans = t
print(ans) | from itertools import *
N, C = list(map(int, input().split()))
D = [list(map(int, input().split())) for _ in [0]*C]
tri = [[0]*C for _ in [0]*3]
for i in range(N):
for j,x in enumerate(map(int, input().split())):
tri[(i+j)%3][x-1] += 1
res = 1<<30
for p in permutations(list(range(C)), 3):
tt = sum(D[l][p[m]] * tri[m][l] for l in range(C) for m in range(3))
if tt < res: res = tt
print(res) | p03330 |
def run(N, C, D, c):
'''
マス番号に応じて3色に塗る必要がある
(i+j)%3が0, 1, 2それぞれに対して、ある色に塗るコストを計算する
0, 1, 2それぞれのC色のコストのパターンができる
上記コストに対してC色から3色を選択する全パターンのうち最小のコストを求める
'''
cost0 = {}
cost1 = {}
cost2 = {}
for k in range(C):
cost0[k] = 0
cost1[k] = 0
cost2[k] = 0
for i in range(N):
for j in range(N):
if (i+j+2) % 3 == 0:
color = c[i][j] - 1
cost = D[color][k]
cost0[k] += cost
elif (i+j+2) % 3 == 1:
color = c[i][j] - 1
cost = D[color][k]
cost1[k] += cost
elif (i+j+2) % 3 == 2:
color = c[i][j] - 1
cost = D[color][k]
cost2[k] += cost
ret = max(cost0.values()) + max(cost1.values()) + max(cost2.values())
for i in range(C):
for j in range(C):
for k in range(C):
if i == j or j == k or k == i:
continue
else:
ret = min(ret, cost0[i]+cost1[j]+cost2[k])
return ret
def main():
N, C = list(map(int, input().split()))
D = []
for i in range(C):
D.append(list(map(int, input().split())))
c = []
for i in range(N):
c.append(list(map(int, input().split())))
print((run(N, C, D, c)))
if __name__ == '__main__':
main() | def run(N, C, D, c):
'''
マス番号に応じて3色に塗る必要がある
(i+j)%3が0, 1, 2それぞれに対して、何色が何個あるか計算しておく
ある色に塗るコストを計算する
0, 1, 2それぞれのC色のコストのパターンができる
上記コストに対してC色から3色を選択する全パターンのうち最小のコストを求める
'''
color0 = {}
color1 = {}
color2 = {}
for k in range(C):
color0[k] = 0
color1[k] = 0
color2[k] = 0
for i in range(N):
for j in range(N):
color = c[i][j] - 1
if (i+j+2) % 3 == 0:
color0[color] += 1
elif (i+j+2) % 3 == 1:
color1[color] += 1
elif (i+j+2) % 3 == 2:
color2[color] += 1
cost0 = {}
cost1 = {}
cost2 = {}
for k in range(C):
cost0[k] = 0
cost1[k] = 0
cost2[k] = 0
for i in range(C):
cost = D[i][k]
cost0[k] += cost * color0[i]
cost1[k] += cost * color1[i]
cost2[k] += cost * color2[i]
ret = max(cost0.values()) + max(cost1.values()) + max(cost2.values())
for i in range(C):
for j in range(C):
for k in range(C):
if i == j or j == k or k == i:
continue
else:
ret = min(ret, cost0[i]+cost1[j]+cost2[k])
return ret
def main():
N, C = list(map(int, input().split()))
D = []
for i in range(C):
D.append(list(map(int, input().split())))
c = []
for i in range(N):
c.append(list(map(int, input().split())))
print((run(N, C, D, c)))
if __name__ == '__main__':
main()
| p03330 |
from collections import Counter,defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
n,C = inpl()
d = []
c = []
for i in range(C):
d.append(inpl())
for i in range(n):
c.append(inpl())
d0 = defaultdict(int)
d1 = defaultdict(int)
d2 = defaultdict(int)
for y in range(n):
for x in range(n):
if (x+y+2) % 3 == 0:
d0[c[x][y]] += 1
elif (x+y+2) % 3 == 1:
d1[c[x][y]] += 1
else:
d2[c[x][y]] += 1
# print(d0)
# print(d1)
# print(d2)
res0 = []
res1 = []
res2 = []
for i in range(C):
tmp = 0
for key in list(d0.keys()):
tmp += d[key-1][i] * d0[key]
res0.append([i,tmp])
tmp = 0
for key in list(d1.keys()):
tmp += d[key-1][i] * d1[key]
res1.append([i,tmp])
tmp = 0
for key in list(d2.keys()):
tmp += d[key-1][i] * d2[key]
res2.append([i,tmp])
res0.sort(key=lambda x:x[1])
res1.sort(key=lambda x:x[1])
res2.sort(key=lambda x:x[1])
# print(res0)
# print(res1)
# print(res2)
ans = mod
for i in range(3):
for j in range(3):
for k in range(3):
if res0[i][0] == res1[j][0] or res0[i][0] == res2[k][0] or res2[k][0] == res1[j][0]:
continue
ans = min(res0[i][1]+res1[j][1]+res2[k][1], ans)
print(ans) | from collections import Counter,defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
n,C = inpl()
d = []
c = []
for i in range(C):
d.append(inpl())
for i in range(n):
c.append(inpl())
d0 = defaultdict(int)
d1 = defaultdict(int)
d2 = defaultdict(int)
dd = [d0,d1,d2]
for y in range(n):
for x in range(n):
t = (x+y+2) % 3
dd[t][c[x][y]] += 1
# print(dd)
res = [[] for i in range(3)]
for i in range(C):
for j in range(3):
tmp = 0
for key in list(dd[j].keys()):
tmp += d[key-1][i] * dd[j][key]
res[j].append([i,tmp])
for i in range(3):
res[i].sort(key=lambda x:x[1])
# print(res)
ans = mod
for i in range(3):
for j in range(3):
for k in range(3):
if res[0][i][0] == res[1][j][0] or res[0][i][0] == res[2][k][0] or res[2][k][0] == res[1][j][0]:
continue
ans = min(res[0][i][1]+res[1][j][1]+res[2][k][1], ans)
print(ans) | p03330 |
def main():
N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(C)]
c = [list(map(int,input().split())) for _ in range(N)]
mod_0 = [0 for _ in range(C)]
mod_1 = [0 for _ in range(C)]
mod_2 = [0 for _ in range(C)]
for i in range(N):
for j in range(N):
if (i+j)%3 == 0:
mod_2[c[i][j]-1] += 1
if (i+j)%3 == 1:
mod_0[c[i][j]-1] += 1
if (i+j)%3 == 2:
mod_1[c[i][j]-1] += 1
INF = 10**10
ans = INF
for i in range(C):
for j in range(C):
if i == j:
continue
for k in range(C):
if i == k or j == k:
continue
ans = min(ans,sum(mod_0[n]*D[n][i] for n in range(C))+\
sum(mod_1[n]*D[n][j] for n in range(C))+\
sum(mod_2[n]*D[n][k] for n in range(C)))
print(ans)
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
def main():
N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(C)]
c = [list(map(int,input().split())) for _ in range(N)]
mod_0 = [0 for _ in range(C)]
mod_1 = [0 for _ in range(C)]
mod_2 = [0 for _ in range(C)]
for i in range(N):
for j in range(N):
if (i+j)%3 == 0:
mod_2[c[i][j]-1] += 1
if (i+j)%3 == 1:
mod_0[c[i][j]-1] += 1
if (i+j)%3 == 2:
mod_1[c[i][j]-1] += 1
INF = 10**10
ans = INF
for i in range(C):
for j in range(C):
if i == j:
continue
for k in range(C):
if i == k or j == k:
continue
ans = min(ans,sum(mod_0[n]*D[n][i] for n in range(C))+\
sum(mod_1[n]*D[n][j] for n in range(C))+\
sum(mod_2[n]*D[n][k] for n in range(C)))
print(ans)
if __name__ == "__main__":
main() | p03330 |
import sys
input = sys.stdin.buffer.readline
from itertools import permutations
def main():
N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(C)]
col = [list(map(int,input().split())) for _ in range(N)]
mod_color = [[],[],[]]
for i in range(N):
for j in range(N):
mod_color[(i+j)%3].append(col[i][j]-1)
ans = 10**10
for x,y,z in permutations(list(range(C)),3):
ret = 0
for num in mod_color[0]:
ret += D[num][x]
for num in mod_color[1]:
ret += D[num][y]
for num in mod_color[2]:
ret += D[num][z]
ans = min(ans,ret)
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline
from itertools import permutations
def main():
N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(C)]
col = [list(map(int,input().split())) for _ in range(N)]
mod_color = [[0]*C,[0]*C,[0]*C]
for i in range(N):
for j in range(N):
mod_color[(i+j)%3][col[i][j]-1] += 1
ans = 10**10
for x,y,z in permutations(list(range(C)),3):
ret = 0
ret += sum(mod_color[0][i]*D[i][x] for i in range(C))
ret += sum(mod_color[1][i]*D[i][y] for i in range(C))
ret += sum(mod_color[2][i]*D[i][z] for i in range(C))
ans = min(ans,ret)
print(ans)
if __name__ == "__main__":
main()
| p03330 |
n,C = list(map(int,input().split()))
d = [[int(i) for i in input().split()] for _ in range(C)]
c = [[int(i)-1 for i in input().split()] for _ in range(n)]
cnt = [[0]*C for _ in range(3)]
for i in range(n):
for j in range(n):
for k in range(C):
for r in range(3):
if (i+j)%3 == r: cnt[r][k] += d[c[i][j]][k]
ans = float("inf")
for i in range(C):
for j in range(C):
if i == j: continue
for k in range(C):
if i == k or j == k: continue
ans = min(ans, cnt[0][i] + cnt[1][j] + cnt[2][k])
print(ans) | n,C = list(map(int,input().split()))
d = [[int(i) for i in input().split()] for _ in range(C)]
c = [[int(i)-1 for i in input().split()] for _ in range(n)]
cnt = [[0]*C for _ in range(3)]
for i in range(n):
for j in range(n):
for k in range(C):
cnt[(i+j)%3][k] += d[c[i][j]][k]
ans = float("inf")
for i in range(C):
for j in range(C):
if i == j: continue
for k in range(C):
if i == k or j == k: continue
ans = min(ans, cnt[0][i] + cnt[1][j] + cnt[2][k])
print(ans) | p03330 |
N,C=list(map(int,input().split()))
D=[[int(x) for x in input().split()] for y in range(C)]
c=[[int(x)-1 for x in input().split()] for y in range(N)]
a=10**9
for c0 in range(C):
for c1 in range(c0+1,C):
for c2 in range(c1+1,C):
s1,s2,s3=0,0,0
for i in range(N):
for j in range(N):
m = (i+j+2)%3
if m==0:
s1 += D[c[i][j]][c0]
s2 += D[c[i][j]][c1]
s3 += D[c[i][j]][c2]
elif m==1:
s1 += D[c[i][j]][c1]
s2 += D[c[i][j]][c2]
s3 += D[c[i][j]][c0]
else:
s1 += D[c[i][j]][c2]
s2 += D[c[i][j]][c0]
s3 += D[c[i][j]][c1]
a=min(a,s1,s2,s3)
print(a)
| N,C=list(map(int,input().split()))
D=[[int(x) for x in input().split()] for y in range(C)]
c=[[int(x)-1 for x in input().split()] for y in range(N)]
d=[[0 for x in range(C)] for y in range(3)]
for i in range(N):
for j in range(N):
d[(i+j)%3][c[i][j]] += 1
a=10**9
for c0 in range(C):
for c1 in range(c0+1,C):
for c2 in range(c1+1,C):
s1,s2,s3,s4,s5,s6=0,0,0,0,0,0
for c in range(C):
s1 += d[0][c]*D[c][c0]+d[1][c]*D[c][c1]+d[2][c]*D[c][c2]
s2 += d[0][c]*D[c][c0]+d[1][c]*D[c][c2]+d[2][c]*D[c][c1]
s3 += d[0][c]*D[c][c1]+d[1][c]*D[c][c0]+d[2][c]*D[c][c2]
s4 += d[0][c]*D[c][c1]+d[1][c]*D[c][c2]+d[2][c]*D[c][c0]
s5 += d[0][c]*D[c][c2]+d[1][c]*D[c][c0]+d[2][c]*D[c][c1]
s6 += d[0][c]*D[c][c2]+d[1][c]*D[c][c1]+d[2][c]*D[c][c0]
a=min(a,s1,s2,s3,s4,s5,s6)
print(a)
| p03330 |
N,C=list(map(int,input().split()))
D=[[int(x) for x in input().split()] for y in range(C)]
c=[[int(x)-1 for x in input().split()] for y in range(N)]
d=[[0 for x in range(C)] for y in range(3)]
for i in range(N):
for j in range(N):
d[(i+j)%3][c[i][j]] += 1
a=10**9
for c0 in range(C):
for c1 in range(C):
for c2 in range(C):
if c0==c1 or c1==c2 or c0==c2:
continue
s=0
for c in range(C):
s += d[0][c]*D[c][c0]+d[1][c]*D[c][c1]+d[2][c]*D[c][c2]
a=min(a,s)
print(a)
| N,C=list(map(int,input().split()))
D=[[int(x) for x in input().split()] for y in range(C)]
c=[[int(x)-1 for x in input().split()] for y in range(N)]
d=[[0 for x in range(C)] for y in range(3)]
for i in range(N):
for j in range(N):
d[(i+j)%3][c[i][j]]+=1
a=10**9
for c0 in range(C):
for c1 in range(C):
for c2 in range(C):
if c0!=c1 and c1!=c2 and c0!=c2:
a=min(a,sum([d[0][c]*D[c][c0]+d[1][c]*D[c][c1]+d[2][c]*D[c][c2] for c in range(C)]))
print(a)
| p03330 |
n,c = list(map(int,input().split()))
d = [list(map(int,input().split())) for i in range(c)]
g = [list(map(int,input().split())) for i in range(n)]
# mod=0,1,2について、色iに変えた時のコストをまとめておく
cost = [[0]*c for i in range(3)]
for i in range(3):
for j in range(c):
cost[i][j] = sum([d[g[a][b]-1][j] for a in range(n) for b in range(n) if (a+b)%3==i])
# mod=0,1,2について、どの色で塗るか全探索
ret=10**10
for i in range(c):
for j in range(c):
for k in range(c):
if i==j or j==k or k==i:
continue
ret=min(ret, cost[0][i]+cost[1][j]+cost[2][k])
print(ret) | n,c = list(map(int,input().split()))
d = [list(map(int,input().split())) for i in range(c)]
g = [list(map(int,input().split())) for i in range(n)]
# mod=0,1,2について、色iに変えた時のコストをまとめておく
cost = [[0]*c for i in range(3)]
for i in range(3):
for j in range(c):
for a in range(n):
for b in range(n):
if (a+b)%3==i:
cost[i][j]+=d[g[a][b]-1][j]
# mod=0,1,2について、どの色で塗るか全探索
ret=10**10
for i in range(c):
for j in range(c):
for k in range(c):
if i==j or j==k or k==i:
continue
ret=min(ret, cost[0][i]+cost[1][j]+cost[2][k])
print(ret) | p03330 |
import itertools
N,C=list(map(int,input().split()))
D=[None]*C
for i in range(C):
D[i]=list(map(int,input().split()))
c=[None]*N
for i in range(N):
c[i]=list(map(int,input().split()))
c_0=[]
c_1=[]
c_2=[]
for i in range(N):
for j in range(N):
if (i+j+2)%3==0:
c_0+=[c[i][j]]
elif (i+j+2)%3==1:
c_1+=[c[i][j]]
else:
c_2+=[c[i][j]]
L=[]
for i in range(C):
L+=[i+1]
ROOP=list(itertools.permutations(L,3))
ANS=float("inf")
for i in range(len(ROOP)):
IWA=0
for j in c_0:
IWA+=D[j-1][ROOP[i][0]-1]
for j in c_1:
IWA+=D[j-1][ROOP[i][1]-1]
for j in c_2:
IWA+=D[j-1][ROOP[i][2]-1]
if ANS>IWA:
ANS=IWA
print(ANS)
| import itertools
N,C=list(map(int,input().split()))
D=[None]*C
for i in range(C):
D[i]=list(map(int,input().split()))
c=[None]*N
for i in range(N):
c[i]=list(map(int,input().split()))
c_0=[]
c_1=[]
c_2=[]
for i in range(N):
for j in range(N):
if (i+j+2)%3==0:
c_0+=[c[i][j]]
elif (i+j+2)%3==1:
c_1+=[c[i][j]]
else:
c_2+=[c[i][j]]
clist_0=[0]*(C+1)
clist_1=[0]*(C+1)
clist_2=[0]*(C+1)
for i in c_0:
clist_0[i]+=1
for i in c_1:
clist_1[i]+=1
for i in c_2:
clist_2[i]+=1
L=[]
for i in range(C):
L+=[i+1]
ROOP=list(itertools.permutations(L,3))
ANS=float("inf")
for i in range(len(ROOP)):
IWA=0
for j in range(1,C+1):
IWA+=D[j-1][ROOP[i][0]-1]*clist_0[j]+D[j-1][ROOP[i][1]-1]*clist_1[j]+D[j-1][ROOP[i][2]-1]*clist_2[j]
if ANS>IWA:
ANS=IWA
print(ANS) | p03330 |
import itertools
n, cs = list(map(int, input().split()))
d = [list(map(int, input().split())) for i in range(cs)]
c = [list(map(int, input().split())) for i in range(n)]
for i, j in itertools.product(list(range(n)), repeat=2):
c[i][j] -= 1
ans = 10**20
for i, j, k in itertools.permutations(list(range(cs)), 3):
s = 0
for l, m in itertools.product(list(range(n)), repeat=2):
if (l + m) % 3 == 0:
s += d[c[l][m]][i]
elif (l + m) % 3 == 1:
s += d[c[l][m]][j]
else:
s += d[c[l][m]][k]
ans = min(ans, s)
print(ans)
| import itertools
n, cs = list(map(int, input().split()))
d = [list(map(int, input().split())) for i in range(cs)]
c = [list(map(int, input().split())) for i in range(n)]
color_count = [[0] * cs for i in range(3)]
for i, j in itertools.product(list(range(n)), repeat=2):
color_count[(i + j) % 3][c[i][j] - 1] += 1
ans = 10**20
for t in itertools.permutations(list(range(cs)), 3):
s = 0
for l in range(3):
for m in range(cs):
s += color_count[l][m] * d[m][t[l]]
ans = min(ans, s)
print(ans)
| p03330 |
import itertools
N, C = list(map(int, input().split()))
d = [list(map(int, input().split())) for _ in range(C)]
c = [list(map(int, input().split())) for _ in range(N)]
memo = [[0 for i in range(C)]for j in range(3)]
for i in range(N):
for j in range(N):
cij = c[i][j]
a = (i + j + 2) % 3
for k in range(C):
memo[a][k] += d[cij-1][k]
ans = float('inf')
for c1, c2, c3 in itertools.permutations(list(range(C)), 3):
ans = min(ans, memo[0][c1] + memo[1][c2] + memo[2][c3])
print(ans) | import itertools
N, C = list(map(int, input().split()))
d = [list(map(int, input().split())) for _ in range(C)]
c = [list(map(int, input().split())) for _ in range(N)]
memo = [[0 for i in range(C)]for j in range(3)]
for i in range(N):
for j in range(N):
cij = c[i][j]
a = (i + j + 2) % 3
for k in range(C):
memo[a][k] += d[cij-1][k]
ans = 250000001
for c1, c2, c3 in itertools.permutations(list(range(C)), 3):
ans = min(ans, memo[0][c1] + memo[1][c2] + memo[2][c3])
print(ans) | p03330 |
import itertools
N, C = list(map(int, input().split()))
D = []
for _ in range(C):
D.append(list(map(int, input().split())))
c = []
for _ in range(N):
c.append(list([int(x) - 1 for x in input().split()]))
min_diff = float("inf")
for ccs in itertools.permutations(list(range(C)), 3):
diff = 0
for i in range(N):
for j in range(N):
diff += D[c[i][j]][ccs[(i + j) % 3]]
min_diff = min(min_diff, diff)
print(min_diff)
| import itertools
N, C = list(map(int, input().split()))
# N, C = 500, 30
D = []
for _ in range(C):
D.append(list(map(int, input().split())))
# D.append([100] * C)
diff_by_pos_color_pair = [[0 for _ in range(C)] for _ in range(3)]
for i in range(N):
for j, color_from in enumerate([int(x) - 1 for x in input().split()]):
# for j, color_from in enumerate([0] * N):
pos = (i + j) % 3
for color_to in range(C):
diff_by_pos_color_pair[pos][color_to] += D[color_from][color_to]
min_diff = float("inf")
for ccs in itertools.permutations(list(range(C)), 3):
diff = 0
for pos, color in enumerate(ccs):
diff += diff_by_pos_color_pair[pos][color]
min_diff = min(min_diff, diff)
print(min_diff)
| p03330 |
N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(C)]
c = [list(map(int,input().split())) for _ in range(N)]
cst = [[0,0,0] for i in range(C)]
for clr in range(1,C+1):
for i in range(N):
for j in range(N):
cst[clr-1][(i+j+2)%3] += D[c[i][j]-1][clr-1]
ans = 10**10
for i in range(C):
for j in range(C):
for k in range(C):
if i == j or i == k or j == k:
continue
ans = min(ans,cst[i][0]+cst[j][1]+cst[k][2])
print(ans)
| N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(C)]
c = [list(map(int,input().split())) for _ in range(N)]
cst = [[0,0,0] for i in range(C)]
for i in range(N):
for j in range(N):
cst[c[i][j]-1][(i+j)%3] += 1
ans = 10**10
for i in range(C):
for j in range(C):
for k in range(C):
if i == j or i == k or j == k:
continue
x = [i,j,k]
a = 0
for l in range(3):
for m in range(C):
a += D[m][x[l]]*cst[m][l]
ans = min(ans,a)
print(ans)
| p03330 |
# your code goes here
N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for i in range(C)]
c = [list(map(int,input().split())) for i in range(N)]
ans = 1145141919810
for i in range(C):
for j in range(C):
if j == i:
continue
for k in range(C):
if k == i or k == j:
continue
tmp = 0
for x in range(N):
for y in range(N):
if (x+y+2)%3==2:
tmp+= D[c[x][y]-1][i]
elif (x+y+2)%3==0:
tmp+= D[c[x][y]-1][j]
else:
tmp+= D[c[x][y]-1][k]
ans = min(ans,tmp)
print(ans)
| # your code goes here
N,C = list(map(int,input().split()))
D = [list(map(int,input().split())) for i in range(C)]
c = [list(map(int,input().split())) for i in range(N)]
Color = [[0 for i in range(C)] for j in range(3)]
for x in range(N):
for y in range(N):
Color[(x+y+2)%3][c[x][y]-1] += 1
ans = 1145141919810
for i in range(C):
for j in range(C):
if j == i:
continue
for k in range(C):
if k == i or k == j:
continue
tmp = 0
for x in range(3):
for y in range(C):
if x == 0:
tmp += Color[x][y]*D[y][i]
elif x == 1:
tmp += Color[x][y]*D[y][j]
else:
tmp += Color[x][y]*D[y][k]
ans = min(ans,tmp)
print(ans)
| p03330 |
N,C=list(map(int,input().split(' ')))
D=[]
for _ in range(C):
D.append([ x for x in map(int,input().split(' '))])
c=[]
for _ in range(N):
c.append([ x for x in map(int,input().split(' '))])
x=float('inf')
for seq in [[0,1,2],[0,2,1],[1,0,2],[1,2,0],[2,0,1],[2,1,0]]:
counter=[[0]*C for _ in range(3)]
for i in range(N):
for j in range(N):
b=i%3
cur=c[i][j]
counter[seq[(j+b)%3]][cur-1]+=1
#s+=D[cur-1][seq[(j+b)%3]]
for c0 in range(C):
for c1 in range(C):
if c1==c0:
continue
for c2 in range(C):
if c2==c0 or c2==c1:
continue
s=0
for i, cx in enumerate(counter[0]):
s+=D[i][c0]*cx
for i, cx in enumerate(counter[1]):
s+=D[i][c1]*cx
for i, cx in enumerate(counter[2]):
s+=D[i][c2]*cx
if s<x:
x=s
print(x)
| N,C=list(map(int,input().split(' ')))
D=[]
for _ in range(C):
D.append([ x for x in map(int,input().split(' '))])
c=[]
for _ in range(N):
c.append([ x for x in map(int,input().split(' '))])
x=float('inf')
memo={}
counter=[[0]*C for _ in range(3)]
for i in range(N):
for j in range(N):
b=i%3
cur=c[i][j]
counter[(j+b)%3][cur-1]+=1
#s+=D[cur-1][seq[(j+b)%3]]
for c0 in range(C):
for c1 in range(C):
if c1==c0:
continue
for c2 in range(C):
if c2==c0 or c2==c1:
continue
s=0
for i, cx in enumerate(counter[0]):
s+=D[i][c0]*cx
for i, cx in enumerate(counter[1]):
s+=D[i][c1]*cx
for i, cx in enumerate(counter[2]):
s+=D[i][c2]*cx
if s<x:
x=s
print(x)
| p03330 |
from itertools import *
N,C=list(map(int,input().split()))
D=[list(map(int,input().split())) for i in range(C)]
c=[list(map(int,input().split())) for i in range(N)]
lst=[[],[],[]]
for y in range(N):
for x in range(N):
lst[(y+x)%3].append(c[y][x])
Revalue=10**18
for Color1,Color2,Color3 in list(permutations(list(range(1,C+1)),3)):
value=0
for i in lst[0]:
value+=D[i-1][Color1-1]
for i in lst[1]:
value+=D[i-1][Color2-1]
for i in lst[2]:
value+=D[i-1][Color3-1]
Revalue=min(Revalue,value)
print(Revalue)
| from itertools import *
N,C=list(map(int,input().split()))
D=[list(map(int,input().split())) for i in range(C)]
c=[list(map(int,input().split())) for i in range(N)]
lst=[[],[],[]]
for y in range(N):
for x in range(N):
lst[(y+x)%3].append(c[y][x])
Revalue=10**18
valuelst=[[0 for i in range(C)] for i in range(3)]
for v in range(3):
for Color in range(1,C+1):
value=0
for i in lst[v]:
value+=D[i-1][Color-1]
valuelst[v][Color-1]=value
for Color1,Color2,Color3 in list(permutations(list(range(1,C+1)),3)):
value=valuelst[0][Color1-1]+valuelst[1][Color2-1]+valuelst[2][Color3-1]
Revalue=min(Revalue,value)
print(Revalue)
| p03330 |
N,C = list(map(int,input().split()))
D = []
for i in range(C):
D.append(list(map(int,input().split())))
G = []
for i in range(N):
G.append(list(map(int,input().split())))
X = [[] for i in range(3)]
for i in range(N):
for j in range(N):
X[(i+j+2)%3].append(G[i][j])
ans = float('inf')
for c1 in range(C):
for c2 in range(C):
if c1 == c2:
continue
for c3 in range(C):
if c1 == c3 or c2 == c3:
continue
cost = 0
for i,x in enumerate(X):
for e in x:
if i == 0:
cost += D[e-1][c1]
elif i == 1:
cost += D[e-1][c2]
else:
cost += D[e-1][c3]
ans = min(cost,ans)
print(ans)
| N,C = list(map(int,input().split()))
D = []
for i in range(C):
D.append(list(map(int,input().split())))
G = []
for i in range(N):
G.append(list(map(int,input().split())))
X = [[] for i in range(3)]
for i in range(N):
for j in range(N):
X[(i+j+2)%3].append(G[i][j])
ans = float('inf')
Costs = [[0 for i in range(C)] for j in range(3)]
for c in range(C):
for i in range(3):
for e in X[i]:
Costs[i][c] += D[e-1][c]
for c1 in range(C):
for c2 in range(C):
if c1 == c2:
continue
for c3 in range(C):
if c1 == c3 or c2 == c3:
continue
cost = 0
for i,e in enumerate([c1,c2,c3]):
cost += Costs[i][e]
ans = min(cost,ans)
print(ans)
| p03330 |
from itertools import*
from math import*
from collections import*
from heapq import*
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf = 10**18
mod = 10**9+7
from functools import reduce
import sys
sys.setrecursionlimit(10**7)
n,c = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(c)]
C = [list(map(int,input().split())) for _ in range(n)]
ans = inf
for (a,b,c) in permutations(list(range(c)),3):
cur = 0
for i in range(n):
for j in range(n):
if (i+j)%3 == 0:
cur += D[C[i][j]-1][a]
elif (i+j)%3 == 1:
cur += D[C[i][j]-1][b]
else:
cur += D[C[i][j]-1][c]
ans = min(ans,cur)
print(ans)
| from itertools import*
from math import*
from collections import*
from heapq import*
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf = 10**18
mod = 10**9+7
from functools import reduce
import sys
sys.setrecursionlimit(10**7)
n,c = list(map(int,input().split()))
D = [list(map(int,input().split())) for _ in range(c)]
C = [list(map(int,input().split())) for _ in range(n)]
C0,C1,C2 = [0]*c,[0]*c,[0]*c
for i in range(n):
for j in range(n):
if (i+j)%3 == 0:
C0[C[i][j]-1] += 1
elif (i+j)%3 == 1:
C1[C[i][j]-1] += 1
else:
C2[C[i][j]-1] += 1
ans = inf
for (i,j,k) in permutations(list(range(c)),3):
cur = 0
for l in range(c):
cur += D[l][i]*C0[l]+D[l][j]*C1[l]+D[l][k]*C2[l]
ans = min(ans,cur)
print(ans) | p03330 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.