input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from bisect import bisect_right
n = int(eval(input()))
l = [1]
i = 1
while 6 ** i <= 100000:
l.append(6 ** i)
i += 1
i = 1
while 9 ** i <= 100000:
l.append(9 ** i)
i += 1
l.sort()
dp = [float('inf')] * (n+1)
dp[0] = 0
for i in range(1, n+1):
for v in l:
if v > i:
break
dp[i] = min(dp[i], dp[i-v] + 1)
print((dp[n])) | n = int(eval(input()))
l = [1]
i = 1
while 6 ** i <= 100000:
l.append(6 ** i)
i += 1
i = 1
while 9 ** i <= 100000:
l.append(9 ** i)
i += 1
l.sort()
dp = [float('inf')] * (n+1)
dp[0] = 0
for i in range(1, n+1):
for v in l:
if v > i:
break
dp[i] = min(dp[i], dp[i-v] + 1)
print((dp[n])) | p03329 |
lis = [1]
cou = 1
n = int(eval(input()))
while 6 ** cou <= n:
lis.append(6**cou)
cou += 1
cou = 1
while 9 ** cou <= n:
lis.append(9**cou)
cou += 1
lis.sort(reverse = True)
now = {0}
for i in range(n):
gone = set()
for num in now:
for k in range(len(lis)):
gone.add(num + lis[k])
if n in gone:
print((i+1))
exit()
now = gone | n = int(eval(input()))
lis = [1, 6, 36, 216, 1296, 7776, 46656,9, 81, 729, 6561, 59049]
lis.sort(reverse=True)
dp = [10 ** 10 for i in range(n+1)]
dp[0] = 0
for i in range(n):
for num in lis:
try:
dp[i+num] = min(dp[i+num],dp[i]+1)
except:
continue
print((dp[n])) | p03329 |
n = int(eval(input()))
possible = [1]
i=1
while i <= 100000:
i = i*6
possible+=[i]
i=1
while i <= 100000:
i = i*9
possible+=[i]
possible.sort(reverse =1)
ans = 1
table = set(possible)
while True:
if n in table:
print(ans)
break
ans+=1
nexttable = set()
for num in table:
for p in possible:
if num + p <100000:
nexttable.add(num+p)
table = table | nexttable | n = int(eval(input()))
possible = [1]
i=1
while i <= 100000:
i = i*6
possible+=[i]
i=1
while i <= 100000:
i = i*9
possible+=[i]
possible.sort(reverse =1)
ans = 0
table = set([n])
while True:
if 0 in table:
print(ans)
break
ans+=1
nexttable = set()
for num in table:
for p in possible:
if num - p >= 0:
nexttable.add(num-p)
table =nexttable | p03329 |
n = int(eval(input()))
dp = [10**9]*30000000
dp[0] = 0
pow6 = [6**i for i in range(10) if 6**i <= n]
pow9 = [9**i for i in range(10) if 9**i <= n]
for i in range(n):
for p6 in pow6:
dp[i+p6] = min(dp[i+p6], dp[i]+1)
for p9 in pow9:
dp[i+p9] = min(dp[i+p9], dp[i]+1)
print((dp[n]))
| from bisect import bisect_right
n = int(eval(input()))
MX = 100010
dp = [float('inf') for _ in range(MX)]
dp[0] = 0
pow_6, pow_9 = [6], [9]
while True:
flg = False
if pow_6[-1]*6 <= MX:
pow_6.append(pow_6[-1]*6)
flg = True
if pow_9[-1]*9 <= MX:
pow_9.append(pow_9[-1]*9)
flg = True
if flg == False:
break
for i in range(1, MX):
tmp = [1]
if i >= 6:
x = bisect_right(pow_6, i)
tmp.append(pow_6[x-1])
if i >= 9:
y = bisect_right(pow_9, i)
tmp.append(pow_9[y-1])
for t in tmp:
dp[i] = min(dp[i], dp[i-t]+1)
print((dp[n])) | p03329 |
n = int(eval(input()))
max_n = 10 ** 5
dp = [int(i) for i in range(max_n + 1)]
for i in (6,9):
v = i
while v < max_n:
for j in range(len(dp)):
if j + v < max_n+1:
dp[j+v] = min(dp[j+v],dp[j]+1)
v *= i
print((dp[n])) | n = int(eval(input()))
dp = [int(i) for i in range(10 ** 5 + 1)]
for i in [6,9]:
v = i
while v < 10 ** 5:
for j in range(len(dp)):
if j+v <= 10 ** 5:
dp[j+v] =min(dp[j]+1,dp[j+v])
v *= i
print((dp[n])) | p03329 |
l_6 = []
_ = 1
while 6**_ < 100000:
l_6.append(6**_)
_ += 1
l_6.sort(reverse = 1)
l_9= []
_ = 1
while 9**_ < 100000:
l_9.append(9**_)
_ += 1
l_9.sort(reverse = 1)
n = int(eval(input()))
w = 0
z = []
for i in range(n+1):
x = i
for j in range(len(l_6)):
while l_6[j] <= x:
x -= l_6[j]
w += 1
else:
w += x
y = n-i
for k in range(len(l_9)):
while l_9[k] <= y:
y -= l_9[k]
w += 1
else:
w += y
z.append(w)
w = 0
print((min(z)))
| n = int(eval(input()))
dp = [0] + [100000]*n
ptn = [1]
_ = 1
while 6**_ < 100000:
ptn.append(6**_)
_ += 1
_ = 1
while 9**_ < 100000:
ptn.append(9**_)
_ += 1
for i in range(1,n+1):
for j in ptn:
if i-j >= 0:
dp[i] = min(dp[i], dp[i-j]+1)
print((dp[-1])) | p03329 |
n_max = 100000
bs = [(6 ** i, 6) for i in range (1, 10)]
bs.extend([(9 ** i, 9) for i in range (1, 10)])
bs = list(sorted([x for x in bs if x[0] <= n_max]))
bms = []
s = 5
for b, i in bs:
s += b * (i - 1)
bms.append((b, i, s))
#print(bs)
#print(bms, len(bms))
#m = 44852
m = int(eval(input()))
stack = [(m, 0, len(bms) - 1)]
#print("search start!")
result = 10000
while stack:
m, n, bms_i = stack.pop()
b, i, s = bms[bms_i]
#print(m, n, bms_i, b, i, s)
if n > result:
#print("skip!", m, n, bms_i)
continue
if bms_i < 0:
if m <= 6 and m + n < result:
result = m + n
# print('get result!', result)
continue
for j in range(i):
next_m = m - b * j
if next_m >= 0 and n + j < result:
stack.append((next_m, n + j, bms_i - 1))
print(result)
| n_max = 100000
bs = [(6 ** i, 6) for i in range (1, 10)]
bs.extend([(9 ** i, 9) for i in range (1, 10)])
bs = list(sorted([x for x in bs if x[0] <= n_max]))
bms = []
s = 5
for b, i in bs:
s += b * (i - 1)
bms.append((b, i, s))
#print(bs)
#print(bms, len(bms))
#m = 44852
m = int(eval(input()))
stack = [(m, 0, len(bms) - 1)]
#print("search start!")
result = 10000
while stack:
m, n, bms_i = stack.pop()
b, i, s = bms[bms_i]
#print(m, n, bms_i, b, i, s)
if n > result:
#print("skip!", m, n, bms_i)
continue
if m > s:
continue
if bms_i < 0:
if m <= 6 and m + n < result:
result = m + n
# print('get result!', result)
continue
for j in range(i):
next_m = m - b * j
if next_m >= 0 and n + j < result:
stack.append((next_m, n + j, bms_i - 1))
print(result)
| p03329 |
import bisect
n = int(eval(input()))
add_num = 1
draw_money = []
while add_num <= 10 ** 5:
draw_money.append(add_num)
add_num *= 6
add_num = 1
while add_num <= 10 ** 5:
draw_money.append(add_num)
add_num *= 9
#重複を削除
draw_money = list(set(draw_money))
ans = 0
draw_money.sort()
# dp[i] = i円引き出すのに必要な最小操作
dp = [10000000] * (n + 1)
dp[0] = 0
for i in range(1,n + 1):
for j in draw_money:
if i - j >= 0:
dp[i] = min(dp[i - 1] + 1, dp[i - j] + 1,dp[i])
else:
dp[i] = min(dp[i-1] + 1, dp[i])
print((dp[n]))
| n = int(eval(input()))
inf = 10**9
dp = [inf for i in range(n+1)]
dp[0] = 0
for i in range(n):
if dp[i] != inf:
#1円引き出す場合
dp[i+1] = min(dp[i] + 1, dp[i+1])
num = 6
while i + num <= n:
dp[i + num] = min(dp[i] + 1, dp[i+num])
num *= 6
num = 9
while i + num <= n:
dp[i + num] = min(dp[i] + 1, dp[i+num])
num *= 9
print((dp[n]))
| p03329 |
INF=9999999
n=int(eval(input()))
dp=[INF for i in range(n+1)]
dp[-1]=0
for i in range(n,0,-1):
e6=1
while 6**e6<=i:
dp[i-6**e6]=min(dp[i]+1,dp[i-6**e6])
e6+=1
e9=1
while 9**e9<=i:
dp[i-9**e9]=min(dp[i]+1,dp[i-9**e9])
e9+=1
ans=INF
for i in range(n):
if dp[i]==0:
continue
ans=min(ans,i+dp[i])
if ans==INF:
ans=n
print(ans)
| #補助関数
def convert(num,radix):
res = 0
while num > 0:
res += num % radix
num //= radix
return res
#入力
INF = (1 << 31)
N = int(eval(input()))
ans = INF
#計算
for i in range(N + 1):
dec6 = i
dec9 = N - i
ans = min(ans , convert(dec6,6) + convert(dec9,9))
#出力
print(ans)
| p03329 |
N=int(eval(input()))
X=[1]+[6**i for i in range(1,7)]+[9**i for i in range(1,6)]
X.sort()
X.reverse()
DP=[i for i in range(100001)]
def dpmin(i):
Y=i
for j in X:
if i-j>=0:
Y=min(Y,DP[i-j]+1)
return Y
for i in range(100001):
DP[i]=dpmin(i)
print((DP[N]))
| N=int(eval(input()))
X=[1]+[6**i for i in range(1,7)]+[9**i for i in range(1,6)]
X.sort()
X.reverse()
ANS=1000000
i=4
for i_0 in range(max(N//X[0]-i,0),N//X[0]+1):
N_0=N-X[0]*i_0
for i_1 in range(max(N_0//X[1]-i,0),N_0//X[1]+1):
N_1=N_0-X[1]*i_1
for i_2 in range(max(N_1//X[2]-i,0),N_1//X[2]+1):
N_2=N_1-X[2]*i_2
for i_3 in range(max(N_2//X[3]-i,0),N_2//X[3]+1):
N_3=N_2-X[3]*i_3
for i_4 in range(max(N_3//X[4]-i,0),N_3//X[4]+1):
N_4=N_3-X[4]*i_4
for i_5 in range(max(N_4//X[5]-i,0),N_4//X[5]+1):
N_5=N_4-X[5]*i_5
for i_6 in range(max(N_5//X[6]-i,0),N_5//X[6]+1):
N_6=N_5-X[6]*i_6
for i_7 in range(max(N_6//X[7]-i,0),N_6//X[7]+1):
N_7=N_6-X[7]*i_7
for i_8 in range(max(N_7//X[8]-i,0),N_7//X[8]+1):
N_8=N_7-X[8]*i_8
for i_9 in range(max(N_8//X[9]-i,0),N_8//X[9]+1):
N_9=N_8-X[9]*i_9
i_10=N_9//6
N_10=N_9-X[10]*i_10
if ANS>i_0+i_1+i_2+i_3+i_4+i_5+i_6+i_7+i_8+i_9+i_10+N_10:
ANS=i_0+i_1+i_2+i_3+i_4+i_5+i_6+i_7+i_8+i_9+i_10+N_10
print(ANS)
| p03329 |
bank = [1]
N = int(eval(input()))
for i in range(20):
if 100000 >= 6**i:
bank.append(6**i)
if 100000 >= 9**i:
bank.append(9**i)
# print(bank)
dp = [[10**10]*(N+1) for _ in range(len(bank)+1)]
dp[0][0] = 0
# i番目の引き出し方法を使う
for i in range(len(bank)):
for j in range(N+1):
# 使わない場合
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
# 使う場合
if j + bank[i] > N: # Nを超えるならcontinue
continue
dp[i+1][j+bank[i]] = min(dp[i][j]+1, dp[i+1][j]+1)
print((dp[len(bank)][N]))
| # from math import log
n = int(eval(input()))
# def make_list(n, x):
# return [x ** i for i in range(1, int(log(n, x))+1)]
nums = [1]
# N = int(input())
for i in range(20):
if 100000 >= 6**i:
nums.append(6**i)
if 100000 >= 9**i:
nums.append(9**i)
# sixes = make_list(n, 6)
# nines = make_list(n, 9)
# nums = [1] + sixes + nines
dp = [float('inf')] * (n+1)
for num in nums:
for i in range(1, n+1): # 1~nまでのn円について調べる
if i == num:
dp[i] = 1
elif i > num:
dp[i] = min(dp[i], dp[i-num]+1)
print((dp[n]))
| p03329 |
n=int(eval(input()))
l=[1]
for i in [6,9]:
x=i
while x<=n:
l.append(x)
x*=i
dp=[10**9]*(n+1)
dp[0]=0
for x in l:
for i in range(n):
if i+x<=n:dp[i+x]=min(dp[i+x],dp[i]+1)
print((dp[n]))
| n=int(eval(input()))
l=[1]
for i in [6,9]:
x=i
while x<=n:
l.append(x)
x*=i
dp=[10**9]*(n+1)
dp[0]=0
for x in l:
for i in range(n):
if i+x<=n:dp[i+x]=min(dp[i+x],dp[i]+1)
else:break
print((dp[n]))
| p03329 |
N = int(eval(input()))
ans = N
for v9 in range(N + 1):
cnt = 0
t = v9
w = 9 ** 5
while t >= 9:
if t >= w:
cnt9, t = divmod(t, w)
cnt += cnt9
w //= 9
t = N - (v9 - t)
w = 6 ** 7
while t >= 6:
if t >= w:
cnt6, t = divmod(t, w)
cnt += cnt6
w //= 6
ans = min(ans, cnt + t)
print(ans)
| N = int(eval(input()))
ans = N
for i in range(N + 1):
cnt = 0
t = i
while t > 0:
cnt += t % 9
t //= 9
t = N - i
while t > 0:
cnt += t % 6
t //= 6
ans = min(ans, cnt)
print(ans)
| p03329 |
def s(n,c):
if n<6:return c+n
a=b=1
while a*6<=n:a*=6
while b*9<=n:b*=9
return min(s(n-a,c+1),s(n-b,c+1))
print((s(int(eval(input())),0))) | def s(n,p):
while n>0:yield n%p;n//=p
c=lambda*a:sum(s(*a));n=int(eval(input()));print((min(c(i,6)+c(n-i,9)for i in range(n+1)))) | p03329 |
n = int(eval(input()))
m = [1, 6, 9, 36, 81, 216, 729, 1296, 6561, 7776, 46656, 59049]
dp = [10**6 for i in range(100001)]
for mi in m:
dp[mi] = 1
for i in range(1,100001):
for mi in m:
if i+mi <= 100000:
dp[i+mi] = min(dp[i+mi],dp[i]+1)
else:
break
print((dp[n]))
| N = int(eval(input()))
li = [1]
six = 1
while six <= N:
six = six*6
li.append(six)
nine = 1
while nine <= N:
nine = nine*9
li.append(nine)
INF = 10**10
dp = [INF for i in range(N+1)]
dp[0] = 0
for i in range(N):
for num in li:
if i+num <= N:
dp[i+num] = min(dp[i+num], dp[i] + 1)
print((dp[N]))
| p03329 |
N = int(eval(input()))
def six(n):
count = 0
while n > 5:
x = n
a = 0
while x >= 1:
x = x / 6
a += 1
a -= 1
n -= 6 ** a
count += 1
count += n
return count
def nine(n):
count = 0
while n > 8:
x = n
a = 0
while x >= 1:
x = x / 9
a += 1
a -= 1
n -= 9 ** a
count += 1
#print(n)
count += n
return count
#print(six(41), nine(41))
ans = 10 ** 7
for i in range(N + 1):
x = six(i) + nine(N - i)
ans = min(ans, x)
print(ans)
| import bisect
N = int(eval(input()))
six = []
nine = []
now = 6
while now < 100001:
six.append(now)
now *= 6
now = 9
while now < 100001:
nine.append(now)
now *= 9
#print(six, nine)
#[6, 36, 216, 1296, 7776, 46656] [9, 81, 729, 6561, 59049]
def coin(n):
if n < 6:
return n
else:
index_six = bisect.bisect_right(six, n)
index_nine = bisect.bisect_right(nine, n)
#print(n, index_six, index_nine, count)
#print(n, n - six[index_six - 1], n - nine[index_nine - 1])
if n - six[index_six - 1] >= 0:
alpha = coin(n - six[index_six - 1]) + 1
else:
alpha = 10 ** 7
if n - nine[index_nine - 1] >= 0:
beta = coin(n - nine[index_nine - 1]) + 1
else:
beta = 10 ** 7
return min(alpha, beta)
print((coin(N)))
| p03329 |
N = int(eval(input()))
r = N
for i in range(N+1):
c=0;t=i
while t>0:c+=t%6;t//=6
t=N-i
while t>0:c+=t%9;t//=9
r=min(r,c)
print(r) | N = int(eval(input()))
a = N
for n in range(N+1):
c = 0
t = n
while t>0:
c+=t%6
t//=6
t = N-n
while t>0:
c+=t%9
t//=9
a = min(a,c)
print(a) | p03329 |
N = int(eval(input()))
s = set()
a = 1
while a <= 100000:
s.add(a)
a *= 6
a = 1
while a <= 100000:
s.add(a)
a *= 9
s = sorted(s)
INF = float('inf')
dp = [INF] * (N+1)
dp[0] = 0
for i in range(N):
for a in s:
if i+a > N: break
dp[i+a] = min(dp[i+a], dp[i] + 1)
print((dp[N])) | import sys
sys.setrecursionlimit(10**8)
N = int(eval(input()))
ss = set()
n = 6
while n <= 10**5:
ss.add(n)
n *= 6
n = 9
while n <= 10**5:
ss.add(n)
n *= 9
dp = [None] * (N+1)
def rec(n):
if dp[n] is not None:
return dp[n]
tmp = n
for s in ss:
if s > n: continue
if s == n:
tmp = 1
break
tmp = min(tmp, 1 + rec(n-s))
dp[n] = tmp
return tmp
print((rec(N))) | p03329 |
def main():
N = int(eval(input()))
dp = [float('inf')] * (N + 10)
dp[0] = 0
for i in range(1, N+1):
power = 1
while(power <= i):
dp[i] = min(dp[i], dp[i-power] + 1)
power *= 6
power = 1
while(power <= i):
dp[i] = min(dp[i], dp[i-power] + 1)
power *= 9
print((dp[N]))
main() | def main():
N = int(eval(input()))
cand = [1]
dp = [float('inf')] * (N + 5)
tmp = 6
cnt = 1
while tmp**cnt <= N:
cand.append(tmp**cnt)
cnt += 1
tmp = 9
cnt = 1
while tmp**cnt <= N:
cand.append(tmp**cnt)
cnt += 1
cand.sort()
dp[0] = 0
for i in range(N+1):
for c in cand:
if i + c <= N:
dp[i+c] = min(dp[i+c], dp[i] + 1)
print((dp[N]))
if __name__ == "__main__":
main() | p03329 |
N = int(eval(input()))
# DPだと思ったけど、2次元じゃなくて1次元だった
# けんちょんさん曰く、1次元でできないときに2次元で考える
sixes = [6 ** i for i in range(1, 7)]
nines = [9 ** i for i in range(1, 6)]
coin = [1] + sixes + nines
INF = 10**6
dp = [INF] * 100010
dp[0] = 0 # dp[i]:i円引き出すのに必要な回数
for money in range(1, N + 1):
dp_candidate = []
for coin_ in coin:
if money < coin_:
continue
else:
dp_candidate.append(dp[money-coin_] + 1)
dp[money] = min(dp_candidate)
print((dp[N]))
| N = int(eval(input()))
sixes = [6 ** i for i in range(1, 7)]
nines = [9 ** i for i in range(1, 6)]
coin = [1] + sixes + nines
INF = 10**6
dp = [INF] * 100010
dp[0] = 0 # dp[i]:i円引き出すのに必要な回数
for money in range(1, N + 1):
dp[money] = min([dp[money-i] + 1 for i in coin if i <= money])
print((dp[N]))
| p03329 |
N = int(eval(input()))
A = [1, 6, 6**2, 6**3, 6**4, 6**5, 6**6, 9, 9**2, 9**3, 9**4, 9**5]
dp = [1000000] * 300000
dp[0] = 0
for i in range(N):
for a in A:
d = dp[i] + 1
dp[i + a] = min(dp[i + a], d)
print((dp[N])) | N = int(eval(input()))
INF = 10 ** 9
dp = [INF] * (N + 1)
dp[0] = 0
M = set()
M.add(1)
i = 1
while True:
if 6 ** i > N:
break
M.add(6 ** i)
i += 1
i = 1
while True:
if 9 ** i > N:
break
M.add(9 ** i)
i += 1
for i in range(N):
for m in M:
if i + m > N:
continue
dp[i + m] = min(dp[i + m], dp[i] + 1)
print((dp[N])) | p03329 |
n = int(eval(input()))
INF = 10**5
answer = INF
for i in range(n+1):
cost = i
ans = 0
for p in range(8):
ans += (cost // 6**p) % 6
cost = n-i
for q in range(7):
ans += (cost // 9**q) % 9
if answer > ans:
answer = ans
print(answer)
| n = int(eval(input()))
INF = 10**5
answer = INF
for i in range(n+1):
money = i
cnt = 0
while money > 0:
cnt += money % 6
money //= 6
money = n-i
while money > 0:
cnt += money % 9
money //= 9
if answer > cnt:
answer = cnt
print(answer) | p03329 |
N = int(eval(input()))
def main():
ans = N
for i in range(N + 1):
num = 0
cur = i
while 0 < cur:
num += cur % 6
cur //= 6
cur = N - i
while 0 < cur:
num += cur % 9
cur //= 9
if num < ans:
ans = num
print(ans)
return
main()
| def f(num, base):
# calc max Pth Power
ret = 1
while ret <= num:
ret *= base
return ret // base
def main():
N = int(eval(input()))
st = {N}
ans = 0
while (all(st)):
st = {x - f(x, 6) for x in st} | {x - f(x, 9) for x in st}
ans += 1
print(ans)
return
main()
| p03329 |
def f(num, base):
# calc max Pth Power
ret = 1
while ret <= num:
ret *= base
return ret // base
def main():
N = int(eval(input()))
st = {N}
ans = 0
while (all(st)):
st = {x - f(x, 6) for x in st} | {x - f(x, 9) for x in st}
ans += 1
print(ans)
return
main()
| def f(num, base):
# calc max Pth Power
ret = 1
while ret <= num:
ret *= base
return ret // base
def main():
N = {int(eval(input()))}
ans = 0
while (all(N)):
N = {x - f(x, 6) for x in N} | {x - f(x, 9) for x in N}
ans += 1
print(ans)
return
main()
| p03329 |
from heapq import *
N = int(eval(input()))
result = 100000
ns = [1, 6, 9, 36, 81, 216, 729, 1296, 6561, 7776, 46656, 59049]
h = []
xs = {}
heappush(h, (0, 0))
while 1:
r, m = heappop(h)
if m == N:
result = r
break
for n in ns:
s = r + 1
x = m + n
if x <= N and not x in xs:
xs[x] = s
heappush(h, (s, x))
print(result)
| N = int(eval(input()))
result = 100000000000
def calc(x, base):
r = 0
while x:
x, m = divmod(x, base)
r += m
return r
for i in range(N + 1):
result = min(result, calc(i, 6) + calc(N - i, 9))
print(result)
| p03329 |
N = int(eval(input()))
result = 100000000000
def calc(x, base):
r = 0
while x:
x, m = divmod(x, base)
r += m
return r
for i in range(N + 1):
result = min(result, calc(i, 6) + calc(N - i, 9))
print(result)
| N = int(eval(input()))
def calc(x, base):
r = 0
while x:
x, m = divmod(x, base)
r += m
return r
result = min(calc(i, 6) + calc(N - i, 9) for i in range(N + 1))
print(result)
| p03329 |
n = int(eval(input()))
dp = [i for i in range(101010)]
#dp[i] = i円払うのに必要な最小値
#6ˆn円,0<=i<=Nにおいて、dp[i+6ˆn] = min(dp[i+6ˆn] ,dp[i]+1)
#6の倍数
t = 10
while True:
for i in range(101010):
if 6**t+(i+1) < 101010:
dp[6**t+(i)] = min(dp[6**t+(i)], dp[i] + 1)
t -= 1
if t == 0:
break
#9の倍数
t = 10
while True:
for i in range(101010):
if 9**t+(i+1) < 101010:
dp[9**t+(i)] = min(dp[9**t+(i)], dp[i] + 1)
t -= 1
if t == 0:
break
i = 0
while i+1 < 101010:
dp[i+1] = min(dp[i+1],dp[i]+1)
i += 1
#print(dp)
print((dp[n])) | n = int(eval(input()))
dp = [i for i in range(101010)]
#dp[i] = i円払うのに必要な最小値
#6ˆn円,0<=i<=Nにおいて、dp[i+6ˆn] = min(dp[i+6ˆn] ,dp[i]+1)
t = 7
while True:
for i in range(101010):
if 6**t+(i+1) < 101010:
dp[6**t+(i)] = min(dp[6**t+(i)], dp[i] + 1)
t -= 1
if t == 0:
break
t = 7
while True:
for i in range(101010):
if 9**t+(i+1) < 101010:
dp[9**t+(i)] = min(dp[9**t+(i)], dp[i] + 1)
t -= 1
if t == 0:
break
i = 0
while i+1 < 101010:
dp[i+1] = min(dp[i+1],dp[i]+1)
i += 1
#print(dp)
print((dp[n])) | p03329 |
n = int(eval(input()))
arr6 = []
for i in range(10):
arr6.append(6**i)
arr9 = []
for i in range(10):
arr9.append(9**i)
ans = float("inf")
for i in range(n+1):
count = 0
tmp = i
while tmp > 0:
t = 0
while arr6[t] <= tmp:
t+=1
tmp -= arr6[t-1]
count += 1
tmp = n-i
while tmp > 0:
t = 0
while arr9[t] <= tmp:
t += 1
tmp -= arr9[t-1]
count += 1
ans = min(ans,count)
print(ans)
| N = int(eval(input()))
dp = [float("inf") for _ in range(100010)]
dp[0] = 0
for i in range(1, N+1):
power = 1
while power <= i:
dp[i] = min(dp[i], dp[i-power]+1)
power *= 6
power = 1
while power <= i:
dp[i] = min(dp[i], dp[i-power]+1)
power *= 9
print((dp[N])) | p03329 |
def main():
N = int(eval(input()))
dp = [-1]*(N + 1)
dp[0] = 0
multiples = [1]
n = 9
while n <= N:
multiples.append(n)
n *= 9
n = 6
while n <= N:
multiples.append(n)
n *= 6
multiples.sort(reverse=True)
# print(multiples)
for ratio in reversed(multiples):
for i in range(N + 1):
c = dp[i]
if c == - 1:
continue
if i + ratio > N:
continue
if dp[i + ratio] == -1 or dp[i + ratio] > c + 1:
dp[i + ratio] = c + 1
# print(dp)
print((dp[N]))
if __name__ == '__main__':
main()
| def main():
N = int(eval(input()))
ans = N
for i in range(N + 1):
cc = 0
t = i
while t > 0:
cc += t % 6
t //= 6
t = N - i
while t > 0:
cc += t % 9
t //= 9
ans = min(ans, cc)
print(ans)
if __name__ == '__main__':
main()
| p03329 |
import bisect
x = int(eval(input()))
six_list = [6 ** i for i in range(7)]
nine_list = [9 ** i for i in range(6)]
def six_nine(n):
if n == 0:
return 0
else:
six = six_list[bisect.bisect_right(six_list, n) - 1]
nine = nine_list[bisect.bisect_right(nine_list, n) - 1]
return min(n // six + six_nine(n % six), 1 + six_nine(n - nine))
print((six_nine(x)))
| import bisect
x = int(eval(input()))
six_list = [6 ** i for i in range(7)]
nine_list = [9 ** i for i in range(6)]
def six_nine(n):
if n < 6:
return n
else:
six = six_list[bisect.bisect_right(six_list, n) - 1]
nine = nine_list[bisect.bisect_right(nine_list, n) - 1]
return min(n // six + six_nine(n % six), 1 + six_nine(n - nine))
print((six_nine(x)))
| p03329 |
import bisect
def six_nine(n):
if n < 6:
return n
else:
six = six_list[bisect.bisect_right(six_list, n) - 1]
nine = nine_list[bisect.bisect_right(nine_list, n) - 1]
return min(n // six + six_nine(n % six), 1 + six_nine(n - nine))
if __name__ == '__main__':
x = int(eval(input()))
six_list = [6 ** i for i in range(7)]
nine_list = [9 ** i for i in range(6)]
print((six_nine(x))) | import bisect
six_list = [6 ** i for i in range(7)]
nine_list = [9 ** i for i in range(6)]
def six_nine(n):
if n < 6:
return n
else:
six = six_list[bisect.bisect_right(six_list, n) - 1]
nine = nine_list[bisect.bisect_right(nine_list, n) - 1]
return min(n // six + six_nine(n % six), 1 + six_nine(n - nine))
if __name__ == '__main__':
x = int(eval(input()))
print((six_nine(x))) | p03329 |
import itertools
N = int(eval(input()))
base = [1]
for i in range(1, 7):
if 6 ** i <= N:
base.append(6 ** i)
for i in range(1, 6):
if 9 ** i <= N:
base.append(9 ** i)
ans = N
dp = [0] * (N + 1)
for i in range(1, N + 1):
dp[i] = min([dp[i - j] + 1 if i - j >= 0 else j for j in base])
print((dp[N])) | N = int(eval(input()))
def base_n(x, n):
results = 0
while x > 0:
results += x % n
x //= n
return results
print((min([base_n(i, 6) + base_n(N - i, 9) for i in range(N + 1)]))) | p03329 |
import heapq
N=int(eval(input()))
N_max=100000
d=set()
n=1
while n<=N_max:
d.add(n)
n*=6
n=1
while n<=N_max:
d.add(n)
n*=9
dp=[N_max+1 for _ in range(N_max+1)]
dp[0]=0
for i in range(1,N_max+1):
for n in d:
if i>=n:
dp[i]=min(dp[i],dp[i-n]+1)
print((dp[N])) | N = int(eval(input()))
a = [1]
n6 = 6
while n6 <= 100000:
a.append(n6)
n6 *= 6
n9 = 9
while n9 <= 100000:
a.append(n9)
n9 *= 9
#dp[i]=ちょうどi円払う場合に最小の操作回数
dp = [10**9] * (N+100010)
dp[0] = 0
for i in range(N):
for n in a:
dp[i+n] = min(dp[i+n], dp[i]+1)
print((dp[N])) | p03329 |
def g(n, a):
for i in range(1, 100):
if a**i > n:
return a**(i-1)
return -1
def solve(n):
if n < 6:
return n
a = g(n, 6)
b = g(n, 9)
return min(solve(n-a)+1, solve(n-b)+1)
# assert solve(127) == 4
# assert solve(3) == 3
# assert solve(44852) == 16
print(solve(eval(input()))) | def g(n, a):
for i in range(1, 100):
if a**i > n:
return a**(i-1)
return -1
dp = {}
def solve(n):
if n < 6:
return n
if not n in dp:
a = g(n, 6)
b = g(n, 9)
dp[n] = min(solve(n-a)+1, solve(n-b)+1)
return dp[n]
# assert solve(127) == 4
# assert solve(3) == 3
# assert solve(44852) == 16
print(solve(eval(input()))) | p03329 |
N = int(eval(input()))
B6 = [6**i for i in range(1,7)]
B9 = [9**i for i in range(1,6)]
L = B6 + B9
L = sorted(list(set(L)))
dp = [i for i in range(N+1)]
for i in L :
for j in range(i,(N+1)) :
dp[j] = min(dp[j-i]+1,dp[j])
ans = dp[N]
print(ans)
| N = int(eval(input()))
dp = [i for i in range(N+1)]
B6 = [6**i for i in range(1,8)]
B9 = [9**i for i in range(1,7)]
L = B6 + B9
L = sorted(list(set(L)))
for i in L :
for j in range(i, N+1) :
dp[j] = min(dp[j-i]+1, dp[j])
print((dp[-1]))
| p03329 |
N = int(eval(input()))
dp = [0 for i in range(N+1)]
dp[1] = 1
roku = 0
kyu = 0
for i in range(2, N+1):
if i == 6**(roku+1):
roku += 1
if i == 9**(kyu+1):
kyu += 1
kouho = [1]
for j in range(roku):
kouho.append(6**(j+1))
for j in range(kyu):
kouho.append(9**(j+1))
size = len(kouho)
small = 1000000
for j in range(size):
if dp[i - kouho[j]] + 1 < small:
small = dp[i - kouho[j]] + 1
dp[i] = small
print((str(dp[N]))) | N = int(eval(input()))
dp = [0 for i in range(N+1)]
dp[1] = 1
kazu = [1]
i = 6
while i <= N:
kazu.append(i)
i*=6
i = 9
while i <= N:
kazu.append(i)
i*=9
kazu.sort()
kazulazor = len(kazu)
temp = [1]
lentemp = 1
index = 1
for i in range(2, N+1):
kouho = []
if index < kazulazor and i == kazu[index]:
temp.append(i)
index += 1
lentemp += 1
for j in range(lentemp):
kouho.append(dp[i-temp[j]]+1)
dp[i] = min(kouho)
print((str(dp[N]))) | p03329 |
#公式解法見て書いた
iN = int(eval(input()))
a6 = [0]*7
for i in range(7):
a6[i] = 6 ** i
a6.reverse()
a9 = [0]*6
for i in range(6):
a9[i] = 9 ** i
a9.reverse()
iAns = iN
for i in range(iN+1):
iD = iN - i
iC = 0
for j in range(7):
if i:
iG = a6[j]
if i >= iG:
iC += (i // iG)
i %=iG
for j in range(6):
if iD :
iG = a9[j]
if iD >= iG:
iC += (iD // iG)
iD %= iG
if iAns > iC:
iAns = iC
print(iAns)
| #公式解法見て書いた
iN = int(eval(input()))
a6 = [0]*7
for i in range(7):
a6[i] = 6 ** i
a6.reverse()
a9 = [0]*6
for i in range(6):
a9[i] = 9 ** i
a9.reverse()
iAns = iN
for i in range(iN+1):
iD = iN - i
iC = 0
for j in range(7):
if i:
iG = a6[j]
if i >= iG:
iC += (i // iG)
i %=iG
if iAns <= iC:
continue
for j in range(6):
if iD :
iG = a9[j]
if iD >= iG:
iC += (iD // iG)
iD %= iG
if iAns > iC:
iAns = iC
print(iAns)
| p03329 |
import math
N=int(eval(input()))
number_of_withdrawal=[100000]
# def floor(float_number):
# integer = 0
# while integer < float_number:
# integer+=1
# if integer == float_number:
# return integer
# else:
# integer-=1
# return integer
for money_6 in range(0, N+1):
money_9 = N-money_6
i=0
count_6_pow_number=0
while pow(6,i)<=money_6:
count_6_pow_number += (math.floor(money_6/pow(6,i)))%6
i+=1
j=0
count_9_pow_number=0
while pow(9,j)<=money_9:
count_9_pow_number += (math.floor(money_9/pow(9,j)))%9
j+=1
# print(money_6, money_9, sum(count_6_pow_number), sum(count_9_pow_number))
number_of_withdrawal.append(count_6_pow_number+count_9_pow_number)
print((min(number_of_withdrawal))) | N=int(eval(input()))
money_list=[1,6,36,216,1296,7776,46656,9,81,729,6561,59049]
dp=[0]
for i in range(1,N+1):
dp.append(100000)
for i in range(N):
for money in money_list:
if i+money <= N:
dp[i+money]=min(dp[i+money],dp[i]+1)
print((dp[N])) | p03329 |
N=int(eval(input()))
money_list=[1,6,36,216,1296,7776,46656,9,81,729,6561,59049]
dp=[0]
for i in range(1,N+1):
dp.append(100000)
for i in range(N):
for money in money_list:
if i+money <= N:
dp[i+money]=min(dp[i+money],dp[i]+1)
print((dp[N])) | N=int(eval(input()))
money_list=[1,6,36,216,1296,7776,46656,9,81,729,6561,59049]
dp=[0]
for i in range(1,N+1):
dp.append(100000)
for i in range(1,N+1):
for money in money_list:
if i-money >= 0:
dp[i]=min(dp[i-money]+1,dp[i])
print((dp[N])) | p03329 |
N = int(eval(input()))
ans = 10**9+7
for i in range(N+1):
j = N-i
cnt = 0
while i > 0:
cnt += i%6
i //= 6
while j > 0:
cnt += j%9
j //= 9
ans = min(ans, cnt)
print(ans) | N = int(eval(input()))
sixs = [6**i for i in range(1,7)]
nines = [9**i for i in range(1,6)]
tmp = {}
def dfs(n):
if(n < 6):
return n
if(n in tmp):
return tmp[n]
m = 10**9+7
if(n >= 9):
max_nine = max(nine for nine in nines if nine <= n)
if(n%max_nine == 0):
m = min(m, n // max_nine)
else:
m = min(m, dfs(n - max_nine) + 1)
max_six = max(six for six in sixs if six <= n)
if(n%max_six == 0):
m = min(m, n // max_six)
tmp[n] = min(m, dfs(n - max_six) + 1)
return tmp[n]
print((dfs(N))) | p03329 |
N = int(eval(input()))
sixs = [6**i for i in range(1,7)]
nines = [9**i for i in range(1,6)]
tmp = {}
def dfs(n):
if(n < 6):
return n
if(n in tmp):
return tmp[n]
m = 10**9+7
if(n >= 9):
max_nine = max(nine for nine in nines if nine <= n)
if(n%max_nine == 0):
m = min(m, n // max_nine)
else:
m = min(m, dfs(n - max_nine) + 1)
max_six = max(six for six in sixs if six <= n)
if(n%max_six == 0):
m = min(m, n // max_six)
tmp[n] = min(m, dfs(n - max_six) + 1)
return tmp[n]
print((dfs(N))) | N = int(eval(input()))
nine = [9**i for i in range(7, 0, -1)]
six = [6**i for i in range(8, 0, -1)]
tmp = {}
def f(n):
if(n < 6):
return n
if(n in tmp):
return tmp[n]
m = 1e9+7
if(n >= 9):
mn = max(x for x in nine if x <= n)
if(n%mn == 0):
m = min(m, n//mn)
else:
m = min(m, f(n-mn)+1)
ms = max(x for x in six if x <= n)
if(n%ms == 0):
m = min(m, n//ms)
tmp[n] = min(m, f(n-ms)+1)
return tmp[n]
print((f(N))) | p03329 |
N = int(eval(input()))
ans = 1e9
for i in range(N+1):
cnt = 0
tmp = i
while tmp > 0:
cnt += tmp%6
tmp //= 6
tmp = N-i
while tmp > 0:
cnt += tmp%9
tmp //= 9
ans = min(ans, cnt)
print(ans) | from itertools import count, takewhile
N = int(eval(input()))
def dfs(n, d={}):
if(n < 6):
return n
if(n in d):
return d[n]
mn = max(takewhile(lambda x: x<=n, (9**i for i in count())))
ms = max(takewhile(lambda x: x<=n, (6**i for i in count())))
d[n] = min(dfs(n-mn), dfs(n-ms))+1
return d[n]
print((dfs(N))) | p03329 |
N = int(eval(input()))
dp = dict()
dp[0] = 0
# 貰う DP --- dp[n] に遷移を集める
for n in range(1, N+1):
dp[n] = dp[n-1] + 1
# メモ化
x = 6
while x <= n:
dp[n] = min(dp[n], dp[n-x]+1)
x *= 6
x = 9
while x <= n:
dp[n] = min(dp[n], dp[n-x]+1)
x *= 9
# dp[n] = ans
print((dp[N])) | n = int(eval(input()))
max_N = 1000000
memo = [False]*max_N
import sys
import threading
sys.setrecursionlimit(100000)
threading.stack_size(128*1024*1024)
# 貰う DPではなく、再帰を使ったメモ化再帰
from functools import lru_cache
lru_cache(maxsize=100000)
def f(n):
if n < 6:
return n
if memo[n]:
# print(f"at n: {n}, memo[n]:", memo[n])
return memo[n]
ans = n
# メモ化
x = 6
while x <= n:
ans = min(ans, f(n-x)+1)
x *= 6
x = 9
while x <= n:
ans = min(ans, f(n-x)+1)
x *= 9
memo[n] = ans
return ans
def main():
print((f(n)))
threading.Thread(target=main).start() | p03329 |
N = int(eval(input()))
memo = [N]*(N+1)
unit = [1]
for b in [6,9]:
u = b
while u <= N:
unit.append(u)
u *= b
unit.sort()
cur = set({0})
for i in range(1,N+1):
prev = cur
cur = set()
for p in prev:
for u in unit:
c = p + u
if c == N:
print(i)
exit()
elif c > N:
break
elif memo[c] > i:
cur.add(c)
memo[c] = i | from bisect import bisect_right
N = int(eval(input()))
unit = [1]
for b in [6,9]:
u = b
while u <= N:
unit.append(u)
u *= b
unit.sort()
Nu = len(unit)
ans = N
state_pool = [(0, 0, Nu-1)]
while state_pool:
n, i, pk = state_pool.pop()
if N - n >= (ans-i)*unit[pk]:
continue
sk = bisect_right(unit, N-n, 0, pk+1)
for k in range(sk):
u = unit[k]
c = n + u
if c == N:
if i + 1 < ans:
ans = i + 1
else:
state_pool.append((c, i+1, k))
print(ans) | p03329 |
n=int(eval(input()))
dp=[float("INF")]*(n+1)
dp[0]=0
temp=6
cnt=0
while temp<=n:
cnt+=1
dp[temp]=1
temp*=6
l=[0,0]
l[0]=cnt
temp=9
cnt=0
while temp<=n:
cnt+=1
dp[temp]=1
temp*=9
l[1]=cnt
for j,v in zip(l,[6,9]):
for i in range(j+1):
h=pow(v,i)
for d in range(h,n+1):
dp[d]=min(dp[d],dp[d-h]+1)
print((dp[-1])) | n=int(eval(input()))
ans=float("INF")
for i in range(n+1):
d=0
temp=i
while (temp>0):
d+=temp%6
temp//=6
temp=n-i
while(temp>0):
d+=temp%9
temp//=9
ans=min(d,ans)
print(ans) | p03329 |
N = int(eval(input()))
dp = [N]*(N+1)
dp[0] = 0
for i in range(N+1):
for j in [6**i for i in range(7)]:
if i+j <= N:
dp[i+j] = min(dp[i+j],dp[i]+1)
for j in [9**i for i in range(6)]:
if i+j <= N:
dp[i+j] = min(dp[i+j],dp[i]+1)
print((dp[-1])) | N = int(eval(input()))
dp = [N]*(N+1)
dp[0] = 0
for i in range(N+1):
for j in [6**i for i in range(7)]:
if i+j <= N:
dp[i+j] = min(dp[i+j],dp[i]+1)
for j in [9**i for i in range(1,6)]:
if i+j <= N:
dp[i+j] = min(dp[i+j],dp[i]+1)
print((dp[-1])) | p03329 |
n=int(eval(input()))
inf=float("inf")
DP=[inf]*(n+1)
DP[0]=0
for i in range(1,n+1):
DP[i]=DP[i-1]+1
for point in (6,9):
cnt=1
while point**cnt<=i:
DP[i]=min(DP[i-1]+1,DP[i-point**cnt]+1,DP[i])
cnt +=1
print((DP[n])) | n=int(eval(input()))
inf=float("inf")
DP=[inf]*(n+1)
DP[0]=0
for i in range(1,n+1):
DP[i]=DP[i-1]+1
for P in (6,9):
cnt=1
while P**cnt<=i:
DP[i]=min(DP[i-1]+1,DP[i-P**cnt]+1,DP[i])
cnt +=1
print((DP[n])) | p03329 |
n=int(eval(input()))
inf=float("inf")
DP=[inf]*(n+1)
DP[0]=0
for i in range(1,n+1):
DP[i]=DP[i-1]+1
for P in (6,9):
cnt=1
while P**cnt<=i:
DP[i]=min(DP[i-1]+1,DP[i-P**cnt]+1,DP[i])
cnt +=1
print((DP[n])) | inf=float("inf")
n=int(eval(input()))
DP=[inf]*(n+1)
DP[0]=0
for i in range(1,n+1):
DP[i]=DP[i-1]+1
for num in (6,9):
cnt=1
while num**cnt<=i:
DP[i]=min(DP[i],DP[i-num**cnt]+1)
cnt +=1
print((DP[n])) | p03329 |
n=int(eval(input()))
s_6=[6**(6-i) for i in range(6)]
s_9=[9**(5-i) for i in range(5)]
amari=[0,1,2,3,4,5,1,2,3,1,2,3,2,3]
best=float("inf")
for i in range(n+1):
count_6=0
n_6=i
for j in range(len(s_6)):
count_6+=n_6//s_6[j]
n_6=n_6%s_6[j]
n_9=n-i
count_9=0
for j in range(len(s_9)):
count_9+=n_9//s_9[j]
n_9=n_9%s_9[j]
best=min(best, count_6+count_9+ amari[n_6+n_9])
print(best) | n = int(eval(input()))
ans = float("inf")
for n_nine in range(0, n//9 + 1):
s = n - 9 * n_nine
n_six = s // 6
n_one = s - 6 * n_six
n_nine2 = 0
n_six2 = 0
pow_nine = 5
pow_six = 6
while n_nine >= 9:
if n_nine >= 9 ** (pow_nine - 1):
n_nine -= 9 ** (pow_nine - 1)
n_nine2 += 1
else:
pow_nine -= 1
while n_six >= 6:
if n_six >= 6 ** (pow_six - 1):
n_six -= 6 ** (pow_six - 1)
n_six2 += 1
else:
pow_six -= 1
ans = min(ans, n_nine2 + n_nine + n_six2 + n_six + n_one)
print(ans) | p03329 |
n = int(eval(input()))
ans = float("inf")
for n_nine in range(0, n//9 + 1):
s = n - 9 * n_nine
n_six = s // 6
n_one = s - 6 * n_six
n_nine2 = 0
n_six2 = 0
pow_nine = 5
pow_six = 6
while n_nine >= 9:
if n_nine >= 9 ** (pow_nine - 1):
n_nine -= 9 ** (pow_nine - 1)
n_nine2 += 1
else:
pow_nine -= 1
while n_six >= 6:
if n_six >= 6 ** (pow_six - 1):
n_six -= 6 ** (pow_six - 1)
n_six2 += 1
else:
pow_six -= 1
ans = min(ans, n_nine2 + n_nine + n_six2 + n_six + n_one)
print(ans) | def counting(num, power, base):
num2 = 0
while num >= base:
if num >= base ** (power - 1):
num -= base ** (power - 1)
num2 += 1
else:
power -= 1
return num + num2
def main():
n = int(eval(input()))
ans = float("inf")
for n_nine in range(0, n// 9 + 1):
s = n - 9 * n_nine
n_six = s // 6
n_1 = s - 6 * n_six
pow_nine = 5
pow_six = 6
n_9 = counting(n_nine, pow_nine, 9)
n_6 = counting(n_six, pow_six, 6)
ans = min(ans, n_1 + n_6 + n_9)
print(ans)
main() | p03329 |
s=eval(input())
a=int(s)
list=[]
list.append(1)
list.append(6)
list.append(9)
list.append(36)
list.append(81)
list.append(216)
list.append(729)
list.append(1296)
list.append(6561)
list.append(7776)
list.append(59049)
list.append(46656)
pp=[50 for l in range(50)]
def money(x,y):
for i in range(12):
b=x//list[i]
if b==0:
continue
if i%2==1:
if 0<b<6:
if x%list[i]==0:
pp[y+b]=y+b
else:
money(x-list[i],y+1)
elif i%2==0:
if i!=0:
if 0<b<9:
if x%list[i]==0:
pp[y+b]=y+b
else:
money(x-list[i],y+1)
else:
if 0<b<6:
pp[y+b]=y+b
money(a,0)
print((min(pp))) | s=eval(input())
a=int(s)
list=[]
list.append(1)
list.append(6)
list.append(9)
list.append(36)
list.append(81)
list.append(216)
list.append(729)
list.append(1296)
list.append(6561)
list.append(7776)
list.append(59049)
list.append(46656)
pp=[]
def money(x,y):
for i in range(12):
b=x//list[i]
if b==0:
continue
if i%2==1:
if 0<b<6:
if x%list[i]==0:
pp.append(y+b)
else:
if y>20:
break
money(x-list[i],y+1)
elif i%2==0:
if i!=0:
if 0<b<9:
if x%list[i]==0:
pp.append(y+b)
else:
if y>20:
break
money(x-list[i],y+1)
else:
if 0<b<6:
pp.append(y+b)
money(a,0)
print((min(pp))) | p03329 |
N = int(eval(input()))
dp = [0]*100001
L = [1,6,36,216,1296,7776,46656,9,81,729,6561,59049]
for i in range(100001):
for j in range(len(L)):
if 1 <= i+L[j] <= 100000:
if dp[i+L[j]] == 0:
dp[i+L[j]] = dp[i]+1
else:
dp[i+L[j]] = min(dp[i]+1,dp[i+L[j]])
print((dp[N])) | N = int(eval(input()))
dp = [float('inf')]*100001
dp[0],dp[1] = 0,1
L = [1,6,36,216,1296,7776,46656,9,81,729,6561,59049]
for i in range(2,100001):
for j in range(len(L)):
if i-L[j] >= 0:
dp[i] = min(dp[i-L[j]]+1,dp[i])
print((dp[N])) | p03329 |
import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = []
i = 1
while True:
if 6**i <= 100000:
A.append(6**i)
i += 1
else:
break
A.sort(reverse=True)
B = []
i = 1
while True:
if 9**i <= 100000:
B.append(9**i)
i += 1
else:
break
B.sort(reverse=True)
ans = float("inf")
for i in range(N+1):
n_6, n_9 = i, N-i
c_6 = 0
for a in A:
while True:
if a <= n_6:
n_6 -= a
c_6 += 1
else:
break
c_6 += n_6
c_9 = 0
for b in B:
while True:
if b <= n_9:
n_9 -= b
c_9 += 1
else:
break
c_9 += n_9
c = c_6 + c_9
if c < ans:
ans = c
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = []
i = 1
while True:
if 6**i <= 100000:
A.append(6**i)
i += 1
else:
break
A.sort(reverse=True)
B = []
i = 1
while True:
if 9**i <= 100000:
B.append(9**i)
i += 1
else:
break
B.sort(reverse=True)
ans = float("inf")
for i in range(N+1):
n_6, n_9 = i, N-i
c_6 = 0
for a in A:
q, _, = divmod(n_6, a)
c_6 += q
n_6 -= a * q
c_6 += n_6
c_9 = 0
for b in B:
q, _, = divmod(n_9, b)
c_9 += q
n_9 -= b * q
c_9 += n_9
c = c_6 + c_9
if c < ans:
ans = c
print(ans)
if __name__ == "__main__":
main()
| p03329 |
# dp
# N円を作るのに最も小さい操作回数
import sys
readline = sys.stdin.readline
N = int(readline())
dp = [i for i in range(N + 1)]
for i in range(len(dp)):
n = 6
while i + n < len(dp):
if dp[i + n] > dp[i] + 1:
dp[i + n] = dp[i] + 1
n *= 6
n = 9
while i + n < len(dp):
if dp[i + n] > dp[i] + 1:
dp[i + n] = dp[i] + 1
n *= 9
print((dp[N]))
| import sys
readline = sys.stdin.readline
N = int(readline())
INF = 10 ** 10
dp = [INF] * (N + 1)
dp[0] = 0
for i in range(10,0,-1):
for j in range(N + 1):
if dp[j] != INF:
if j + 6 ** i <= N:
dp[j + 6 ** i] = min(dp[j + 6 ** i], dp[j] + 1)
if j + 9 ** i <= N:
dp[j + 9 ** i] = min(dp[j + 9 ** i], dp[j] + 1)
ans = INF
for i in range(len(dp) - 1, -1, -1):
money = dp[i] + N - i
if ans > money:
ans = money
print(ans) | p03329 |
N=int(eval(input()))
l=[1,6,9,36,81,216,729,1296,6561,7776,46656,59049]
l2=[0]*100010
for i in range(1,100010):
mn=100000000000000000
for x in l:
if i-x>=0 and l2[i-x]<mn:
mn=l2[i-x]+1
l2[i]=mn
print((l2[N])) | N=int(eval(input()))
l=[1,6,9,36,81,216,729,1296,6561,7776,46656,59049]
l2=[0]*100001
for i in range(1,100001):
mn=100000000000000000
for x in l:
if i-x>=0 and l2[i-x]<mn:
mn=l2[i-x]+1
l2[i]=mn
print((l2[N])) | p03329 |
N=int(eval(input()))
l=[1,6,9,36,81,216,729,1296,6561,7776,46656,59049]
l2=[0]*100001
for i in range(1,100001):
mn=100000000000000000
for x in l:
if i-x>=0 and l2[i-x]<mn:
mn=l2[i-x]+1
l2[i]=mn
print((l2[N])) | l=[1,6,9,36,81,216,729,1296,6561,7776,46656,59049]
l2=[0]*100001
N=int(eval(input()))
for i in range(1,N+1):
mn=100000000000000000
for x in l:
if i-x>=0 and l2[i-x]<mn:
mn=l2[i-x]+1
l2[i]=mn
print((l2[N])) | p03329 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N = int(readline())
amt = [1]
a = 6
while a <= N:
amt.append(a)
a *= 6
a = 9
while a <= N:
amt.append(a)
a *= 9
dp = [INF] * (N + 1)
dp[0] = 0
for i in range(1, N + 1):
for a in amt:
if i >= a and dp[i] > dp[i - a]:
dp[i] = dp[i - a] + 1
print((dp[N]))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def f(n, a):
ans = 0
while n > 0:
ans += n % a
n //= a
return ans
def main():
N = int(readline())
ans = INF
for i in range(N + 1):
ans = min(ans, f(i, 6) + f(N - i, 9))
print(ans)
return
if __name__ == '__main__':
main()
| p03329 |
import sys
readline = sys.stdin.readline
from math import floor, log
def main():
N = int(readline())
dp = [i for i in range(N+1)]
for i in range(N):
dp[i+1] = min(dp[i+1], dp[i]+1)
log9 = floor(log(N-i, 9))
for e in range(1, log9+2):
if i + 9**e <= N:
dp[i+9**e] = min(dp[i+9**e], dp[i]+1)
log6 = floor(log(N-i, 6))
for e in range(1, log6+2):
if i + 6**e <= N:
dp[i+6**e] = min(dp[i+6**e], dp[i]+1)
print((dp[N]))
if __name__ == '__main__':
main()
| import sys
readline = sys.stdin.readline
def main():
N = int(readline())
dp = [i for i in range(N+1)]
for i in range(N):
dp[i+1] = min(dp[i+1], dp[i]+1)
e = 9
while i + e <= N:
dp[i+e] = min(dp[i+e], dp[i]+1)
e *= 9
e = 6
while i + e <= N:
dp[i+e] = min(dp[i+e], dp[i]+1)
e *= 6
print((dp[N]))
if __name__ == '__main__':
main() | p03329 |
n=int(eval(input()))
dp=[0]*(n+1)
for i in range(1,n+1):
ans=dp[i-1]+1
j=1
while i>=6**j:
ans=min(ans,dp[i-6**j]+1)
j+=1
j=1
while i>=9**j:
ans=min(ans,dp[i-9**j]+1)
j+=1
dp[i]=ans
print(ans)
| n=int(eval(input()))
l=[1]
l_9=[pow(9,i) for i in range(1,7)]
l_6=[pow(6,i) for i in range(1,8)]
l+=l_9
l+=l_6
l.sort(reverse=True)
dp=[10**9 for i in range(n+1)]
dp[0]=0
for i in range(1,n+1):
for j in l:
if i-j>=0:
dp[i]=min(dp[i],dp[i-j]+1)
print((dp[n])) | p03329 |
n=int(eval(input()))
l=[1]
l_9=[pow(9,i) for i in range(1,7)]
l_6=[pow(6,i) for i in range(1,8)]
l+=l_9
l+=l_6
l.sort(reverse=True)
dp=[10**9 for i in range(n+1)]
dp[0]=0
for i in range(1,n+1):
for j in l:
if i-j>=0:
dp[i]=min(dp[i],dp[i-j]+1)
print((dp[n])) | n=int(eval(input()))
m=[int(pow(6,i)) for i in range(7)]
m9=[int(pow(9,i)) for i in range(1,6)]
m+=m9
m.sort(reverse=True)
# print(m)
dp=[10**18 for i in range(n+1)]
dp[0]=0
for i in range(1,n+1):
for j in m:
if i-j>=0:
dp[i]=min(dp[i],dp[i-j]+1)
# print(dp)
print((dp[n])) | p03329 |
N = int(eval(input()))
INF = 10 ** 6
dp = [INF] * (10**5+1)
dp[0] = 0
for n in range(1, 100001):
power = 1
while power <= n:
dp[n] = min(dp[n], dp[n-power] + 1)
power *= 6
power = 1
while power <= n:
dp[n] = min(dp[n], dp[n-power] + 1)
power *= 9
print((dp[N]))
| N = int(eval(input()))
INF = 10 ** 5 + 1
dp = [0 for _ in range(INF)]
for n in range(1, N + 1):
dp[n] = INF
power = 1
while power <= n:
dp[n] = min(dp[n], dp[n - power] + 1)
power *= 6
power = 1
while power <= n:
dp[n] = min(dp[n], dp[n - power] + 1)
power *= 9
print((dp[N]))
| p03329 |
# 配るDP
N = int(eval(input()))
INF = 10 ** 5 + 1
dp = [INF for _ in range(N + 1)]
dp[0] = 0
for n in range(N):
power = 1
while n + power <= N:
dp[n + power] = min(dp[n + power], dp[n] + 1)
power *= 6
power = 1
while n + power <= N:
dp[n + power] = min(dp[n + power], dp[n] + 1)
power *= 9
print((dp[N]))
| # 貰うDP
N = int(eval(input()))
INF = 10 ** 5 + 1
dp = [INF for _ in range(N + 1)]
dp[0] = 0
for n in range(N + 1):
power = 1
while power <= n:
dp[n] = min(dp[n], dp[n - power] + 1)
power *= 6
power = 1
while power <= n:
dp[n] = min(dp[n], dp[n - power] + 1)
power *= 9
print((dp[N]))
| p03329 |
# 貰うDP
N = int(eval(input()))
INF = 10 ** 5 + 1
dp = [INF for _ in range(N + 1)]
dp[0] = 0
for n in range(N + 1):
power = 1
while power <= n:
dp[n] = min(dp[n], dp[n - power] + 1)
power *= 6
power = 1
while power <= n:
dp[n] = min(dp[n], dp[n - power] + 1)
power *= 9
print((dp[N]))
| INF = float('inf')
N = int(eval(input()))
dp = [INF for _ in range(N+1)]
dp[0] = 0
for i in range(1, N+1):
# 1円玉を使う場合
dp[i] = min(dp[i], dp[i-1] + 1)
# 6べき円玉を使う場合
power = 6
while power <= i:
dp[i] = min(dp[i], dp[i-power] + 1)
power *= 6
# 9べき円玉を使う場合
power = 9
while power <= i:
dp[i] = min(dp[i], dp[i-power] + 1)
power *= 9
print((dp[N]))
| p03329 |
N = int(eval(input()))
INF = float('inf')
dp = [INF] * (N+1)
dp[0] = 0
for n in range(N + 1):
power = 0
while pow(6, power) <= N:
dp[n] = min(dp[n], dp[n - pow(6, power)] + 1)
power += 1
power = 0
while pow(9, power) <= N:
dp[n] = min(dp[n], dp[n - pow(9, power)] + 1)
power += 1
print((dp[N]))
| N = int(eval(input()))
INF = float('inf')
dp = [INF] * (N+1)
dp[0] = 0
for n in range(N + 1):
power = 0
while pow(6, power) <= n:
dp[n] = min(dp[n], dp[n - pow(6, power)] + 1)
power += 1
power = 0
while pow(9, power) <= n:
dp[n] = min(dp[n], dp[n - pow(9, power)] + 1)
power += 1
print((dp[N]))
| p03329 |
n = int(eval(input()))
ans = 10 ** 5
for i in range(n + 1):
count = 0
s = i
while s > 0:
count += s % 6
s //= 6
t = n - i
while t > 0:
count += t % 9
t //= 9
ans = min(count, ans)
print(ans) | n = int(eval(input()))
ans = 1000000
for i in range(n+1):
count = 0
s = i
while s > 0:
count += s % 6
s //= 6
t = n - i
while t > 0:
count += t % 9
t //= 9
ans = min(ans, count)
print(ans) | p03329 |
N = int(eval(input()))
dp = [N + 1 for i in range(N+1)]
dp[0] = 0
for i in range(1,N+1):
j = 0
while i - pow(6,j) >= 0:
if dp[i-pow(6,j)] + 1 < dp[i]:
dp[i] = dp[i-pow(6,j)] + 1
j += 1
j = 0
while i - pow(9,j) >= 0:
if dp[i-pow(9,j)] + 1 < dp[i]:
dp[i] = dp[i-pow(9,j)] + 1
j += 1
print((dp[N])) | inf = float('inf')
N = int(eval(input()))
dp = [inf] * (N+1)
dp[0] = 0
for i in range(N):
if i+1 < N+1:
dp[i+1] = min(dp[i+1], dp[i] + 1)
j = 6
while i+j < N+1:
dp[i+j] = min(dp[i+j], dp[i] + 1)
j *= 6
j = 9
while i+j < N+1:
dp[i+j] = min(dp[i+j], dp[i] + 1)
j *= 9
ans = dp[N]
print(ans) | p03329 |
from collections import deque
N=int(eval(input()))
A=[]
for i in range(N):
s=int(eval(input()))
A.append(s)
A.sort()
H=deque()
H.append(A[0])
s=1
t=N-1
i=0
while t-s!=-1:
x=A[s]
y=A[t]
a=abs(H[0]-x)
b=abs(H[-1]-x)
c=abs(H[0]-y)
d=abs(H[-1]-y)
e=max(a,b,c,d)
if a==e:
H.appendleft(x)
s+=1
elif b==e:
H.append(x)
s+=1
elif c==e:
H.appendleft(y)
t-=1
else:
H.append(y)
t-=1
ans=0
for i in range(N-1):
ans+=abs(H[i+1]-H[i])
print(ans) | import sys
N=int(eval(input()))
A=[int(eval(input())) for i in range(N)]
B=sorted(A)
if N%2==0:
C=B[:(N//2)]
D=B[(N//2):]
print((2*sum(D)-2*sum(C)+C[-1]-D[0]))
sys.exit()
C=B[:(N//2)]
D=B[((N//2)+1):]
s=B[(N//2)]
print((max(2*sum(D)-2*sum(C)+C[-1]-s,2*sum(D)-2*sum(C)+s-D[0]))) | p03223 |
from collections import deque
N = int(eval(input()))
A = deque(sorted([int(eval(input())) for i in range(N)]))
X = deque([A.popleft()])
ans = 0
for i in range(N - 1):
# Aのどちらから取り出してXのどちらに入れるか
left_left = abs(X[0] - A[0])
left_right = abs(X[-1] - A[0])
right_left = abs(X[0] - A[-1])
right_right = abs(X[-1] - A[-1])
if left_left >= max(left_right, right_left, right_right):
ans += left_left
X.appendleft(A.popleft())
elif left_right >= max(left_left, right_left, right_right):
ans += left_right
X.append(A.popleft())
elif right_left >= max(left_left, left_right, right_right):
ans += right_left
X.appendleft(A.pop())
else:
ans += right_right
X.append(A.pop())
print(ans)
| N = int(eval(input()))
A = sorted([int(eval(input())) for i in range(N)])
if N % 2 == 0:
X = [-2] * ((N - 2) // 2) + [-1, 1] + [2] * ((N - 2) // 2)
ans = sum([a * x for a, x in zip(A, X)])
print(ans)
else:
X1 = [-2] * ((N - 2) // 2 + 1) + [1, 1] + [2] * ((N - 2) // 2)
X2 = [-2] * ((N - 2) // 2) + [-1, -1] + [2] * ((N - 2) // 2 + 1)
ans1 = sum([a * x for a, x in zip(A, X1)])
ans2 = sum([a * x for a, x in zip(A, X2)])
print((max(ans1, ans2)))
| p03223 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import deque
n = ni()
a = []
for _ in range(n):
a.append(ni())
mx_cent = [ai for ai in a]
mn_cent = [ai for ai in a]
a.sort()
a = deque(a)
mx_cent = deque([ai for ai in a])
mn_cent = deque([ai for ai in a])
bmx = deque([mx_cent.pop()])
bmn = deque([mn_cent.popleft()])
cnt = 0
while len(mx_cent) > 1:
lf = 0
rt = 0
if cnt % 2 == 0:
lf = mx_cent.popleft()
rt = mx_cent.popleft()
else:
lf = mx_cent.pop()
rt = mx_cent.pop()
bmx.appendleft(lf)
bmx.append(rt)
if cnt % 2 == 0:
lf = mn_cent.pop()
rt = mn_cent.pop()
else:
lf = mn_cent.popleft()
rt = mn_cent.popleft()
bmn.appendleft(lf)
bmn.append(rt)
cnt += 1
if len(mx_cent) == 1:
last = mx_cent.pop()
if abs(bmx[0] - last) > abs(bmx[-1] - last):
bmx.appendleft(last)
else:
bmx.append(last)
last = mn_cent.pop()
if abs(bmn[0] - last) > abs(bmn[-1] - last):
bmn.appendleft(last)
else:
bmn.append(last)
diffmx, diffmn = 0, 0
for i in range(n-1):
diffmx += abs(bmx[i+1] - bmx[i])
diffmn += abs(bmn[i+1] - bmn[i])
print((max(diffmx, diffmn))) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import deque
n = ni()
a = [ni() for _ in range(n)]
a.sort()
b = a.copy()
c = a.copy()
# 小さい順に詰める
bdeq = deque(b)
bret = deque()
bret.append(bdeq.popleft())
push_small = False
while len(bdeq) > 1:
if push_small:
bret.append(bdeq.popleft())
bret.appendleft(bdeq.popleft())
push_small = False
else:
bret.append(bdeq.pop())
bret.appendleft(bdeq.pop())
push_small = True
if len(bdeq) > 0:
if abs(bdeq[0] - bret[0]) > abs(bdeq[0] - bret[-1]):
bret.appendleft(bdeq[0])
else:
bret.append(bdeq[0])
# 大きい順に詰める
cdeq = deque(c)
cret = deque()
cret.append(cdeq.pop())
push_small = True
while len(cdeq) > 1:
if push_small:
cret.append(cdeq.popleft())
cret.appendleft(cdeq.popleft())
push_small = False
else:
cret.append(cdeq.pop())
cret.appendleft(cdeq.pop())
push_small = True
if len(cdeq) > 0:
if abs(cdeq[0] - cret[0]) > abs(cdeq[0] - cret[-1]):
cret.appendleft(cdeq[0])
else:
cret.append(cdeq[0])
# 答えが大きいほうを選択
bans = 0
for i in range(n-1):
bans += abs(bret[i] - bret[i+1])
cans = 0
for i in range(n-1):
cans += abs(cret[i] - cret[i+1])
print((max(bans, cans)))
| p03223 |
# coding: utf-8
# Your code here!
n=int(eval(input()))
a=[]
for _ in range(n):
a.append(int(eval(input())))
a.sort()
#print(a)
ans=0
if n%2==0:
for i in range(n//2-1):
ans += 2*(a[n-1-i]-a[i])
ans += a[n//2] - a[n//2-1]
if n%2==1:
for i in range(n//2-1):
ans += 2*(a[n-1-i]-a[i])
ans += max(a[n//2+1] + a[n//2] - 2*a[n//2-1], 2*a[n//2+1] - a[n//2] - a[n//2-1])
print(ans) | # coding: utf-8
# Your code here!
n=int(eval(input()))
a=[]
for _ in range(n):
a.append(int(eval(input())))
a.sort()
#print(a)
ans=0
if n%2==0:
for i in range(n//2-1):
ans += 2*(a[n-1-i]-a[i])
ans += a[n//2] - a[n//2-1]
if n%2==1:
for i in range(n//2-1):
ans += 2*(a[n-1-i]-a[i])
ans += max(a[n//2+1] + a[n//2] - 2*a[n//2-1], 2*a[n//2+1] - a[n//2] - a[n//2-1])
print(ans) | p03223 |
N = int(eval(input()))
A = []
for i in range(N):
A.append(int(eval(input())))
A.sort()
ary1 = [A[0]]
ary2 = [A[N-1]]
fst = 0
lst = N
fst_flg = False
sum1, sum2 = 0,0
while fst + 1 < lst:
if fst_flg:
fst_flg = False
if fst + 2 != lst:
fst += 1
ary1 = [A[fst]] + ary1 + [A[fst+1]]
ary2 = [A[N-1-fst]] + ary2 + [A[N-1-fst-1]]
fst += 1
l = len(ary1)
sum1 += abs(ary1[0]-ary1[1]) + abs(ary1[l-1]-ary1[l-2])
sum2 += abs(ary2[0]-ary2[1]) + abs(ary2[l-1]-ary2[l-2])
else:
fst += 1
ary1 = [A[fst]] + ary1
ary2 = [A[N-1-fst]] + ary2
sum1 += abs(ary1[0]-ary1[1])
sum2 += abs(ary2[0]-ary2[1])
else:
fst_flg = True
if fst + 2 != lst:
lst -= 1
ary1 = [A[lst]] + ary1 + [A[lst-1]]
ary2 = [A[N-1-lst]] + ary2 + [A[N-lst]]
lst -= 1
l = len(ary1)
sum1 += abs(ary1[0]-ary1[1]) + abs(ary1[l-1]-ary1[l-2])
sum2 += abs(ary2[0]-ary2[1]) + abs(ary2[l-1]-ary2[l-2])
else:
lst -= 1
ary1 = [A[lst]] + ary1
ary2 = [A[N-1-lst]] + ary2
sum1 += abs(ary1[0]-ary1[1])
sum2 += abs(ary2[0]-ary2[1])
print((max(sum1,sum2))) | N = int(eval(input()))
A = []
for i in range(N):
A.append(int(eval(input())))
A.sort()
if N % 2 == 0:
print((-2*sum(A[:N//2-1]) + 2*(sum(A[N//2+1:])) + A[N//2] - A[N//2-1]))
exit()
a = 2*sum(A[N//2+1:]) - 2*sum(A[:N//2-1]) - A[N//2] - A[N//2-1]
b = 2*sum(A[N//2+2:]) - 2*sum(A[:N//2]) + A[N//2] + A[N//2+1]
print((max(a,b)))
| p03223 |
# 頂点 v の所属するグループを調べる
def root(v, uni):
if uni[v] < 0: # v が親の場合
return v
else: # v が子の場合
uni[v] = root(uni[v], uni) # 親のrootを調べる
return uni[v]
# 頂点 a と頂点 b をつなぐ。もともと同じグループのとき、False を返す
def connect(a, b, uni, sets):
# まずはそれぞれ根の番号に置き換える
ra = root(a, uni)
rb = root(b, uni)
if ra == rb: # a と b がそもそも同じグループに属しているなら即終了
return False
# ra と rb を結合し、rb の親を ra とする
sets[ra] += sets[rb]
uni[rb] = ra
return True
##
N, K, L = map(int, input().split())
road = [0]*(N+1)
rail = [0]*(N+1)
road_sets = [0]*(N+1)
rail_sets = [0]*(N+1)
for i in range(1, N+1):
road[i] = -i
rail[i] = -i
road_sets[i] = [i]
rail_sets[i] = [i]
for i in range(K):
a, b = map(int, input().split())
connect(a, b, road, road_sets)
for i in range(L):
a, b = map(int, input().split())
connect(a, b, rail, rail_sets)
for i in range(1, N+1):
tmp = set(road_sets[root(i, road)]) & set(rail_sets[root(i, rail)])
ans = len(tmp)
if i == N:
print(ans)
else:
print(ans, end=" ")
| # 頂点 v の所属するグループを調べる
def root(v, uni):
if uni[v] < 0: # v が親の場合
return v
else: # v が子の場合
uni[v] = root(uni[v], uni) # 親のrootを調べる
return uni[v]
# 頂点 a と頂点 b をつなぐ。もともと同じグループのとき、False を返す
def connect(a, b, uni, sets):
# まずはそれぞれ根の番号に置き換える
ra = root(a, uni)
rb = root(b, uni)
if ra == rb: # a と b がそもそも同じグループに属しているなら即終了
return False
# ra と rb を結合し、rb の親を ra とする
sets[ra] = sets[ra] | sets[rb]
uni[rb] = ra
return True
##
N, K, L = map(int, input().split())
road = [0]*(N+1)
rail = [0]*(N+1)
road_sets = [0]*(N+1)
rail_sets = [0]*(N+1)
for i in range(1, N+1):
road[i] = -i
rail[i] = -i
road_sets[i] = set([i])
rail_sets[i] = set([i])
for i in range(K):
a, b = map(int, input().split())
connect(a, b, road, road_sets)
for i in range(L):
a, b = map(int, input().split())
connect(a, b, rail, rail_sets)
for i in range(1, N+1):
tmp = road_sets[root(i, road)] & rail_sets[root(i, rail)]
ans = len(tmp)
if i == N:
print(ans)
else:
print(ans, end=" ")
| p03857 |
n, k, l = list(map(int, input().split()))
def root(x):
if x == parent[x]: return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
px = root(x)
py = root(y)
if px < py:
parent[py] = px
else:
parent[px] = py
parent = list(range(n))
for i in range(k):
p, q = list(map(int, input().split()))
unite(p-1, q-1)
parent1 = parent
for i in range(n):root(i)
parent = list(range(n))
for i in range(l):
r, s = list(map(int, input().split()))
unite(r-1, s-1)
parent2 = parent
for i in range(n):root(i)
dic = {}
for p1, p2 in zip(parent1, parent2):
dic[p1, p2] = dic.get((p1, p2), 0) + 1
ans = [dic[p1, p2] for p1, p2 in zip(parent1, parent2)]
print(" ".join(map(str, ans)))
| n, k, l = list(map(int, input().split()))
def root(x):
if x != parent[x]: parent[x] = x = root(parent[x])
return x
def unite(x, y):
px = root(x)
py = root(y)
if px < py:
parent[py] = px
else:
parent[px] = py
parent = list(range(n))
for i in range(k):
p, q = list(map(int, input().split()))
unite(p-1, q-1)
parent1 = parent
for i in range(n):root(i)
parent = list(range(n))
for i in range(l):
r, s = list(map(int, input().split()))
unite(r-1, s-1)
parent2 = parent
for i in range(n):root(i)
dic = {}
for p1, p2 in zip(parent1, parent2):
dic[p1, p2] = dic.get((p1, p2), 0) + 1
ans = [dic[p1, p2] for p1, p2 in zip(parent1, parent2)]
print(" ".join(map(str, ans)))
| p03857 |
import sys
from collections import deque
sys.setrecursionlimit(1000000)
N, K, L = list(map(int, input().split()))
pq = [list(map(int, input().split())) for _ in range(K)]
rs = [list(map(int, input().split())) for _ in range(L)]
G_r = [[] for _ in range(N+1)]
for elem in pq:
G_r[elem[0]].append(elem[1])
G_r[elem[1]].append(elem[0])
G_t = [[] for _ in range(N+1)]
for elem in rs:
G_t[elem[0]].append(elem[1])
G_t[elem[1]].append(elem[0])
field_r = [[] for _ in range(N+1)]
def dfs_r(i):
q = deque()
q.append(i)
field_r[i].append(i)
while q:
tmp = q.pop()
for pos in G_r[tmp]:
if pos not in field_r[i]:
field_r[i].append(pos)
q.append(pos)
else:
continue
for i in range(1, N+1):
if not field_r[i]:
dfs_r(i)
field_t = [[] for _ in range(N+1)]
cnt = [1 for _ in range(N+1)]
def dfs_t(i):
q = deque()
q.append(i)
field_t[i].append(i)
while q:
tmp = q.pop()
for pos in G_t[tmp]:
if pos not in field_t[i]:
field_t[i].append(pos)
if pos in field_r[i]:
cnt[i] += 1
q.append(pos)
else:
continue
for i in range(1, N+1):
if not field_t[i]:
dfs_t(i)
ans = []
for i in range(1, N+1):
ans.append(cnt[i])
print((' '.join(map(str, ans))))
| import sys
from collections import deque, Counter
sys.setrecursionlimit(1000000)
N, K, L = list(map(int, input().split()))
pq = [list(map(int, input().split())) for _ in range(K)]
rs = [list(map(int, input().split())) for _ in range(L)]
G_r = [[] for _ in range(N+1)]
for elem in pq:
G_r[elem[0]].append(elem[1])
G_r[elem[1]].append(elem[0])
G_t = [[] for _ in range(N+1)]
for elem in rs:
G_t[elem[0]].append(elem[1])
G_t[elem[1]].append(elem[0])
field_r = [None]*(N+1)
def dfs_r(i, idx):
q = deque()
q.append(i)
field_r[i] = idx
while q:
tmp = q.pop()
for pos in G_r[tmp]:
if field_r[pos] is None:
field_r[pos] = idx
q.append(pos)
else:
continue
idx = 0
for i in range(1, N+1):
if field_r[i] is None:
dfs_r(i, idx)
idx += 1
field_t = [None]*(N+1)
def dfs_t(i, idx):
q = deque()
q.append(i)
field_t[i] = idx
while q:
tmp = q.pop()
for pos in G_t[tmp]:
if field_t[pos] is None:
field_t[pos] = idx
q.append(pos)
else:
continue
idx = 0
for i in range(1, N+1):
if field_t[i] is None:
dfs_t(i, idx)
idx += 1
m = list(zip(field_r[1:], field_t[1:]))
cnt = Counter(m)
ans = []
for elem in list(m):
ans.append(cnt[elem])
print((' '.join(map(str, ans))))
| p03857 |
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [i for i in range(size)]
self.rank = [0 for _ in range(size)]
def find(self, x):
if self.parent[x] == x:
return x
else:
return self.find(self.parent[x])
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def __str__(self):
ret = "parents\n"
ret += " ".join(map(str, self.parent))
ret += '\n'
ret += " ".join(map(str, self.rank))
return ret
N, K, L = list(map(int, input().split()))
def solve1():
root = UnionFind(N)
train = UnionFind(N)
for _ in range(K):
a, b = [int(x)-1 for x in input().split()]
root.union(a, b)
for _ in range(L):
a, b = [int(x)-1 for x in input().split()]
train.union(a, b)
ans = [1]*N
for i in range(N):
for j in range(N):
if i == j:
continue
else:
if root.same(i, j) and train.same(i, j):
ans[i] += 1
print((" ".join(map(str, ans))))
def solve2():
ans = [0]*N
root = UnionFind(N)
train = UnionFind(N)
for _ in range(K):
a, b = [int(x)-1 for x in input().split()]
root.union(a, b)
for _ in range(L):
a, b = [int(x)-1 for x in input().split()]
train.union(a, b)
par = [0]*N
d = 10**6
for i in range(N):
par[i] = root.find(i)+train.find(i)*d
s = set(par)
nums = dict()
for c in s:
nums[c] = par.count(c)
for i in range(N):
ans[i] = nums[root.find(i)+train.find(i)*d]
print((" ".join(map(str, ans))))
solve2()
| # python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [i for i in range(size)]
self.rank = [0 for _ in range(size)]
def find(self, x):
if self.parent[x] == x:
return x
else:
return self.find(self.parent[x])
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def __str__(self):
ret = "parents\n"
ret += " ".join(map(str, self.parent))
ret += '\n'
ret += " ".join(map(str, self.rank))
return ret
N, K, L = list(map(int, input().split()))
def solve1():
root = UnionFind(N)
train = UnionFind(N)
for _ in range(K):
a, b = [int(x)-1 for x in input().split()]
root.union(a, b)
for _ in range(L):
a, b = [int(x)-1 for x in input().split()]
train.union(a, b)
ans = [1]*N
for i in range(N):
for j in range(N):
if i == j:
continue
else:
if root.same(i, j) and train.same(i, j):
ans[i] += 1
print((" ".join(map(str, ans))))
def solve2():
ans = [0]*N
root = UnionFind(N)
train = UnionFind(N)
for _ in range(K):
a, b = [int(x)-1 for x in input().split()]
root.union(a, b)
for _ in range(L):
a, b = [int(x)-1 for x in input().split()]
train.union(a, b)
d = 10**6
nums = dict()
for i in range(N):
n = root.find(i)+train.find(i)*d
if n in list(nums.keys()):
nums[n] = nums[n]+1
else:
nums[n] = 1
for i in range(N):
ans[i] = nums[root.find(i)+train.find(i)*d]
print((" ".join(map(str, ans))))
solve2()
| p03857 |
from collections import defaultdict as dd
road = dd(list)
train = dd(list)
rd = dict()
td = dict()
ans = []
def gr(tree,start):
island = set()
rest = [start,]
while rest:
node = rest.pop()
island.add(node)
for x in tree[node]:
if x not in island:
rest.append(x)
return(island)
n,k,l = list(map(int, input().split()))
for _ in range(k):
a,b = list(map(int, input().split()))
road[a].append(b)
road[b].append(a)
for _ in range(l):
a,b = list(map(int, input().split()))
train[a].append(b)
train[b].append(a)
for i in range(1,n+1):
if i not in rd:
tempr = gr(road,i)
for x in tempr:
rd[x] = tempr
if i not in td:
tempt = gr(train,i)
for x in tempt:
td[x] = tempt
ans.append(str(len(rd[i]&td[i])))
print((" ".join(ans))) | from collections import defaultdict as dd
def find(u,x):
if u[x]<0:
return x
u[x] = find(u,u[x])
return u[x]
def unite(u,a,b):
a = find(u,a)
b = find(u,b)
if a == b:
return False
if u[b] < u[a]:
a,b = b,a
u[a] += u[b]
u[b] = a
return True
n,k,l = list(map(int, input().split()))
ufr = [-1]*(n+1)
uft = [-1]*(n+1)
for _ in range(k):
a,b = list(map(int, input().split()))
unite(ufr,a,b)
for _ in range(l):
a,b = list(map(int, input().split()))
unite(uft,a,b)
tot = dd(int)
for i in range(1,n+1):
tot[(find(ufr,i),find(uft,i))] += 1
print((" ".join([str(tot[(find(ufr,i),find(uft,i))]) for i in range(1,n+1)]))) | p03857 |
import queue
N,K,L=list(map(int,input().split()))
G=[[] for i in range(N)]
H=[[] for i in range(N)]
#T=[-1 for i in range(N)]
#B=[-1 for i in range(N)]
for i in range(K):
p,q=list(map(int,input().split()))
G[p-1].append(q-1)
G[q-1].append(p-1)
for i in range(L):
r,s=list(map(int,input().split()))
H[r-1].append(s-1)
H[s-1].append(r-1)
def bfs(A):
k=1
q=queue.Queue()
reached=[0 for i in range(N)]
res=[0 for i in range(N)]
for i in range(N):
if reached[i]==1:
continue
q.put(i)
while(not(q.empty())):
r=q.get()
res[r]=k
for p in A[r]:
if reached[p]==1:
continue
q.put(p)
reached[p]=1
k+=1
return res
T=bfs(G)
B=bfs(H)
TB=[(T[i],B[i]) for i in range(N)]
D=dict()
for i in range(N):
if TB[i] in D:
D[TB[i]]+=1
else:
D[TB[i]]=1
ans=[str(D[TB[i]]) for i in range(N)]
print((" ".join(ans)))
| N,K,L=list(map(int,input().split()))
G=[[] for i in range(N)]
H=[[] for i in range(N)]
#T=[-1 for i in range(N)]
#B=[-1 for i in range(N)]
for i in range(K):
p,q=list(map(int,input().split()))
G[p-1].append(q-1)
G[q-1].append(p-1)
for i in range(L):
r,s=list(map(int,input().split()))
H[r-1].append(s-1)
H[s-1].append(r-1)
def bfs(A):
k=1
q=[]
reached=[0 for i in range(N)]
res=[0 for i in range(N)]
for i in range(N):
if reached[i]==1:
continue
q.append(i)
while(len(q)>0):
r=q[-1]
q.pop()
res[r]=k
for p in A[r]:
if reached[p]==1:
continue
q.append(p)
reached[p]=1
k+=1
return res
T=bfs(G)
B=bfs(H)
TB=[(T[i],B[i]) for i in range(N)]
D=dict()
for i in range(N):
if TB[i] in D:
D[TB[i]]+=1
else:
D[TB[i]]=1
ans=[str(D[TB[i]]) for i in range(N)]
print((" ".join(ans))) | p03857 |
N,K,L = list(map(int, input().split()))
class UFT:
def __init__(self, N):
self.UFdata = [-1] * (N+1)
self.rank = [0] * (N+1)
self.connected_num = [1] * (N+1)
def find(self,x):
UFdata = self.UFdata
while UFdata[x] != -1:
x = UFdata[x]
return x
def unite(self,x,y):
UFdata = self.UFdata
rank = self.rank
connected_num = self.connected_num
find = self.find
x = find(x)
y = find(y)
if x != y:
if rank[x] < rank[y]:
UFdata[x] = UFdata[y]
x,y = y,x
if rank[x] == rank[y]:
rank[x] += 1
UFdata[y] = x
connected_num[x] += connected_num[y]
UF1 = UFT(N)
UF2 = UFT(N)
ans = [1] * (N+1)
MAP= [ [0] * (N+1) for _ in range(N+1)]
for i in range(K):
p,q = list(map(int, input().split()))
mn, mx = min(p,q), max(p,q)
if UF1.find(p) != -1 and UF1.find(p) != UF1.find(q) or UF1.find(p) == UF1.find(q) == -1:
UF1.unite(p,q)
for i in range(L):
p,q = list(map(int, input().split()))
mn, mx = min(p,q), max(p,q)
if UF1.find(p) != -1 and UF1.find(p) == UF1.find(q) :
UF2.unite(mn, mx)
ans = []
for i in range(1,N+1):
ans.append ( UF2.connected_num[ UF2.find( i) ] )
# print(" ".join( map(lambda x: str(x), connected_num[1:])))
print((" ".join( [str(x) for x in ans])))
| N,K,L = list(map(int, input().split()))
class UFT:
def __init__(self, N):
self.UFdata = [-1] * (N+1)
self.rank = [0] * (N+1)
self.connected_num = [1] * (N+1)
def find(self,x):
UFdata = self.UFdata
while UFdata[x] != -1:
x = UFdata[x]
return x
def unite(self,x,y):
UFdata = self.UFdata
rank = self.rank
connected_num = self.connected_num
find = self.find
x = find(x)
y = find(y)
if x != y:
if rank[x] < rank[y]:
UFdata[x] = UFdata[y]
x,y = y,x
if rank[x] == rank[y]:
rank[x] += 1
UFdata[y] = x
connected_num[x] += connected_num[y]
UF1 = UFT(N)
UF2 = UFT(N)
ans = [1] * (N+1)
MAP= [ [0] * (N+1) for _ in range(N+1)]
import sys
input = sys.stdin.readline
PQ = [ [int(j) for j in input().split()] for _ in range(K)]
RS = [ [int(j) for j in input().split()] for _ in range(L)]
for i in range(K):
# p,q = map(int, input().split())
p,q = PQ[i]
mn, mx = min(p,q), max(p,q)
if UF1.find(p) != -1 and UF1.find(p) != UF1.find(q) or UF1.find(p) == UF1.find(q) == -1:
UF1.unite(p,q)
for i in range(L):
# p,q = map(int, input().split())
p,q = RS[i]
mn, mx = min(p,q), max(p,q)
if UF1.find(p) != -1 and UF1.find(p) == UF1.find(q) :
UF2.unite(mn, mx)
ans = []
for i in range(1,N+1):
ans.append ( UF2.connected_num[ UF2.find( i) ] )
# print(" ".join( map(lambda x: str(x), connected_num[1:])))
print((" ".join( [str(x) for x in ans])))
| p03857 |
N,K,L = list(map(int, input().split()))
class UFT:
def __init__(self, N):
self.UFdata = [-1] * (N+1)
self.rank = [0] * (N+1)
self.connected_num = [1] * (N+1)
def find(self,x):
UFdata = self.UFdata
while UFdata[x] != -1:
x = UFdata[x]
return x
def unite(self,x,y):
UFdata = self.UFdata
rank = self.rank
connected_num = self.connected_num
find = self.find
x = find(x)
y = find(y)
if x != y:
if rank[x] < rank[y]:
UFdata[x] = UFdata[y]
x,y = y,x
if rank[x] == rank[y]:
rank[x] += 1
UFdata[y] = x
connected_num[x] += connected_num[y]
UF1 = UFT(N)
UF2 = UFT(N)
ans = [1] * (N+1)
MAP= [ [0] * (N+1) for _ in range(N+1)]
import sys
input = sys.stdin.readline
PQ = [ [int(j) for j in input().split()] for _ in range(K)]
RS = [ [int(j) for j in input().split()] for _ in range(L)]
for i in range(K):
# p,q = map(int, input().split())
p,q = PQ[i]
mn, mx = min(p,q), max(p,q)
if UF1.find(p) != -1 and UF1.find(p) != UF1.find(q) or UF1.find(p) == UF1.find(q) == -1:
UF1.unite(p,q)
for i in range(L):
# p,q = map(int, input().split())
p,q = RS[i]
mn, mx = min(p,q), max(p,q)
if UF1.find(p) != -1 and UF1.find(p) == UF1.find(q) :
UF2.unite(mn, mx)
ans = []
for i in range(1,N+1):
ans.append ( UF2.connected_num[ UF2.find( i) ] )
# print(" ".join( map(lambda x: str(x), connected_num[1:])))
print((" ".join( [str(x) for x in ans])))
| N,K,L = list(map(int, input().split()))
class UFT:
def __init__(self, N):
self.UFdata = [-1] * (N+1)
self.rank = [0] * (N+1)
self.connected_num = [1] * (N+1)
def find(self,x):
UFdata = self.UFdata
while UFdata[x] != -1:
x = UFdata[x]
return x
def unite(self,x,y):
UFdata = self.UFdata
rank = self.rank
connected_num = self.connected_num
find = self.find
x = find(x)
y = find(y)
if x != y:
if rank[x] < rank[y]:
UFdata[x] = UFdata[y]
x,y = y,x
if rank[x] == rank[y]:
rank[x] += 1
UFdata[y] = x
connected_num[x] += connected_num[y]
UF1 = UFT(N)
UF2 = UFT(N)
ans = [1] * (N+1)
MAP= [ [0] * (N+1) for _ in range(N+1)]
import sys
input = sys.stdin.readline
PQ = [ [int(j) for j in input().split()] for _ in range(K)]
RS = [ [int(j) for j in input().split()] for _ in range(L)]
for i in range(K):
p,q = PQ[i]
if UF1.find(p) != -1 and UF1.find(p) != UF1.find(q) or UF1.find(p) == UF1.find(q) == -1:
UF1.unite(p,q)
for i in range(L):
p,q = RS[i]
if UF1.find(p) != -1 and UF1.find(p) == UF1.find(q) :
UF2.unite(p, q)
ans = []
for i in range(1,N+1):
ans.append ( UF2.connected_num[ UF2.find( i) ] )
# print(" ".join( map(lambda x: str(x), connected_num[1:])))
print((" ".join( [str(x) for x in ans])))
| p03857 |
N,K,L = list(map(int, input().split()))
class UFT:
def __init__(self, N):
self.UFdata = [-1] * (N+1)
self.rank = [0] * (N+1)
def find(self,x):
UFdata = self.UFdata
while UFdata[x] != -1:
x = UFdata[x]
return x
def unite(self,x,y):
UFdata = self.UFdata
rank = self.rank
find = self.find
x = find(x)
y = find(y)
if x != y:
if rank[x] < rank[y]:
x,y = y,x
if rank[x] == rank[y]:
rank[x] += 1
UFdata[y] = x
UF1 = UFT(N)
UF2 = UFT(N)
ans = [1] * (N+1)
MAP= [ [0] * (N+1) for _ in range(N+1)]
import sys
input = sys.stdin.readline
PQ = [ [int(j) for j in input().split()] for _ in range(K)]
RS = [ [int(j) for j in input().split()] for _ in range(L)]
for i in range(K):
p,q = PQ[i]
UF1.unite(p,q)
for i in range(L):
p,q = RS[i]
UF2.unite(p, q)
counter=[]
for i in range(1,N+1):
counter.append(UF1.find(i)+UF2.find(i)*10**6)
from collections import Counter
p=Counter(counter)
ans = [0]*(N+1)
for i in range(1,N+1):
ans[i] = p[UF1.find(i)+UF2.find(i)*10**6]
del ans[0]
# print(" ".join( map(lambda x: str(x), connected_num[1:])))
print((" ".join( [str(x) for x in ans])))
| N,K,L = list(map(int, input().split()))
class UFT:
def __init__(self, N):
self.UFdata = [-1] * (N+1)
self.rank = [0] * (N+1)
def find(self,x):
UFdata = self.UFdata
while UFdata[x] != -1:
x = UFdata[x]
return x
def unite(self,x,y):
UFdata = self.UFdata
rank = self.rank
find = self.find
x = find(x)
y = find(y)
if x != y:
if rank[x] < rank[y]:
x,y = y,x
if rank[x] == rank[y]:
rank[x] += 1
UFdata[y] = x
UF1 = UFT(N)
UF2 = UFT(N)
ans = [1] * (N+1)
MAP= [ [0] * (N+1) for _ in range(N+1)]
import sys
input = sys.stdin.readline
PQ = [ [int(j) for j in input().split()] for _ in range(K)]
RS = [ [int(j) for j in input().split()] for _ in range(L)]
for i in range(K):
p,q = PQ[i]
UF1.unite(p,q)
for i in range(L):
p,q = RS[i]
UF2.unite(p, q)
counter=[]
from collections import defaultdict
cntdic =defaultdict(int)
for i in range(1,N+1):
counter.append(UF1.find(i)+UF2.find(i)*10**6)
cntdic[counter[-1]]+=1
ans = [0]*(N+1)
for i in range(1,N+1):
ans[i] = cntdic[UF1.find(i)+UF2.find(i)*10**6]
del ans[0]
# print(" ".join( map(lambda x: str(x), connected_num[1:])))
print((" ".join( [str(x) for x in ans])))
| p03857 |
N,K,L = list(map(int, input().split()))
class UFT:
def __init__(self, N):
self.UFdata = [-1] * (N+1)
self.rank = [0] * (N+1)
def find(self,x):
UFdata = self.UFdata
while UFdata[x] != -1:
x = UFdata[x]
return x
def unite(self,x,y):
UFdata = self.UFdata
rank = self.rank
find = self.find
x = find(x)
y = find(y)
if x != y:
if rank[x] < rank[y]:
x,y = y,x
if rank[x] == rank[y]:
rank[x] += 1
UFdata[y] = x
UF1 = UFT(N)
UF2 = UFT(N)
ans = [1] * (N+1)
MAP= [ [0] * (N+1) for _ in range(N+1)]
import sys
input = sys.stdin.readline
#PQ = [ [int(j) for j in input().split()] for _ in range(K)]
#RS = [ [int(j) for j in input().split()] for _ in range(L)]
for i in range(K):
p,q = list(map(int,input().split()))
UF1.unite(p,q)
for i in range(L):
p,q = list(map(int,input().split()))#RS[i]
UF2.unite(p, q)
counter=[]
from collections import defaultdict
cntdic =defaultdict(int)
for i in range(1,N+1):
counter.append(UF1.find(i)+UF2.find(i)*10**6)
cntdic[counter[-1]]+=1
ans = [0]*(N+1)
for i in range(1,N+1):
ans[i] = cntdic[counter[i-1]]
del ans[0]
# print(" ".join( map(lambda x: str(x), connected_num[1:])))
print((" ".join( [str(x) for x in ans])))
| N,K,L = list(map(int, input().split()))
class UFT:
def __init__(self, N):
self.UFdata = [-1] * (N+1)
self.rank = [0] * (N+1)
def find(self,x):
UFdata = self.UFdata
while UFdata[x] != -1:
x = UFdata[x]
return x
def unite(self,x,y):
UFdata = self.UFdata
rank = self.rank
find = self.find
x = find(x)
y = find(y)
if x != y:
if rank[x] < rank[y]:
x,y = y,x
if rank[x] == rank[y]:
rank[x] += 1
UFdata[y] = x
UF1 = UFT(N)
UF2 = UFT(N)
ans = [1] * (N+1)
# MAP= [ [0] * (N+1) for _ in range(N+1)]
import sys
input = sys.stdin.readline
#PQ = [ [int(j) for j in input().split()] for _ in range(K)]
#RS = [ [int(j) for j in input().split()] for _ in range(L)]
for i in range(K):
p,q = list(map(int,input().split()))
UF1.unite(p,q)
for i in range(L):
p,q = list(map(int,input().split()))#RS[i]
UF2.unite(p, q)
counter=[]
from collections import defaultdict
cntdic =defaultdict(int)
for i in range(1,N+1):
counter.append(UF1.find(i)+UF2.find(i)*10**6)
cntdic[counter[-1]]+=1
ans = [0]*(N+1)
for i in range(1,N+1):
ans[i] = cntdic[counter[i-1]]
del ans[0]
# print(" ".join( map(lambda x: str(x), connected_num[1:])))
print((" ".join( [str(x) for x in ans])))
| p03857 |
class Union():
def __init__(me,N):
me.N = N
me.up = [-1]*N
me.down = [ [] for i in range(N) ]
def union(me,a,b):
ua = me.up[a] if me.up[a]!=-1 else a
ub = me.up[b] if me.up[b]!=-1 else b
if (ua == ub):
return
if ( len(me.down[ua]) < len(me.down[ub]) ):
ub,ua = ua,ub
for v in me.down[ub]:
me.up[v] = ua
me.down[ua].extend( me.down[ub] )
me.down[ub] = []
me.up[ub] = ua
me.down[ua].append( ub )
N,K,L = [ int(it) for it in input().split() ]
uk = Union(N)
for a,b in [ [int(it)-1 for it in input().split()] for i in range(K) ]:
uk.union(a,b)
ul = Union(N)
for a,b in [ [int(it)-1 for it in input().split()] for i in range(L) ]:
ul.union(a,b)
for i in range(N):
if ( uk.up[i] == -1 ):
uk.down[i].append(i)
uk.down[i] = set(uk.down[i])
if ( ul.up[i] == -1 ):
ul.down[i].append(i)
ul.down[i] = set(ul.down[i])
li = [-1]*N
for i in range(N):
if (li[i] != -1):
continue
ua = uk.up[i] if uk.up[i]!=-1 else i
ub = ul.up[i] if ul.up[i]!=-1 else i
uni = uk.down[ua] & ul.down[ub]
for it in uni:
li[i] = len(uni)
print(( " ".join( [ str(it) for it in li ]) ))
| class Union():
def __init__(me,N):
me.N = N
me.up = [-1]*N
me.down = [ [] for i in range(N) ]
def union(me,a,b):
ua = me.up[a] if me.up[a]!=-1 else a
ub = me.up[b] if me.up[b]!=-1 else b
if (ua == ub):
return
if ( len(me.down[ua]) < len(me.down[ub]) ):
ub,ua = ua,ub
for v in me.down[ub]:
me.up[v] = ua
me.down[ua].extend( me.down[ub] )
me.down[ub] = []
me.up[ub] = ua
me.down[ua].append( ub )
N,K,L = [ int(it) for it in input().split() ]
uk = Union(N)
for a,b in [ [int(it)-1 for it in input().split()] for i in range(K) ]:
uk.union(a,b)
ul = Union(N)
for a,b in [ [int(it)-1 for it in input().split()] for i in range(L) ]:
ul.union(a,b)
pr = [0]*N
for i in range(N):
ua = uk.up[i] if uk.up[i]!=-1 else i
ub = ul.up[i] if ul.up[i]!=-1 else i
pr[i] = (ua*N+ub,i)
pr.sort(key = lambda x:x[0])
li = [0]*N
de = pr[0][0]
s = [pr[0][1]]
for i in range(1,N):
if (de!=pr[i][0]):
for v in s:
li[v] = len(s)
s=[pr[i][1]]
de = pr[i][0]
else:
s.append(pr[i][1])
for v in s:
li[v] = len(s)
print(( " ".join( [ str(it) for it in li ]) ))
| p03857 |
from collections import defaultdict
N, K, L = map(int, input().split())
class UnionFind(object):
def __init__(self, n):
self.n = n
self.par = list(range(n))
self.rank = [1] * n
def is_same(self, a, b):
return self.root(a) == self.root(b)
def root(self, x):
if self.par[x] == x:
return x
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return
if self.rank[x] > self.rank[y]:
self.par[y] = x
elif self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
self.rank[x] += 1
def group(self):
d = defaultdict(set)
for i in range(self.n):
d[self.root(i)].add(i)
return d
load_uf = UnionFind(N)
rail_uf = UnionFind(N)
for k in range(K):
p, q = map(int, input().split())
p -= 1
q -= 1
load_uf.unite(p, q)
for l in range(L):
r, s = map(int, input().split())
r -= 1
s -= 1
rail_uf.unite(r, s)
ld = load_uf.group()
rd = rail_uf.group()
ans = []
d = defaultdict(int)
for i in range(N):
lp = load_uf.par[i]
rp = rail_uf.par[i]
d[lp, rp] += 1
# print(d)
for i in range(N):
lp = load_uf.par[i]
rp = rail_uf.par[i]
if i == N-1:
print(d[lp, rp])
else:
print(d[lp, rp], end=' ')
# print(rd[rp])
# print(ld[lp])
# ans.append(len(ld[lp] & rd[rp]))
# print(str(ans).replace(',', '')[1:-1])
| from collections import defaultdict
N, K, L = map(int, input().split())
class UnionFind(object):
def __init__(self, n):
self.n = n
self.par = list(range(n))
self.rank = [1] * n
def is_same(self, a, b):
return self.root(a) == self.root(b)
def root(self, x):
if self.par[x] == x:
return x
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return
if self.rank[x] > self.rank[y]:
self.par[y] = x
elif self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
self.rank[x] += 1
load_uf = UnionFind(N)
rail_uf = UnionFind(N)
for k in range(K):
p, q = map(int, input().split())
p -= 1
q -= 1
load_uf.unite(p, q)
for l in range(L):
r, s = map(int, input().split())
r -= 1
s -= 1
rail_uf.unite(r, s)
ans = []
d = defaultdict(int)
for i in range(N):
lp = load_uf.root(i)
rp = rail_uf.root(i)
d[lp, rp] += 1
for i in range(N):
lp = load_uf.par[i]
rp = rail_uf.par[i]
if i == N-1:
print(d[lp, rp])
else:
print(d[lp, rp], end=' ')
# print(rd[rp])
# print(ld[lp])
# ans.append(len(ld[lp] & rd[rp]))
# print(str(ans).replace(',', '')[1:-1])
| p03857 |
def main():
h, w, k = list(map(int, input().split()))
s = [input().rstrip() for _ in range(h)]
t = [[0]*(w+1) for _ in range(h+1)]
for i in range(h):
for j in range(w):
if s[i][j] == "1":
t[i+1][j+1] = 1
for i in range(1, h+1):
for j in range(1, w+1):
t[i][j] += t[i-1][j] + t[i][j-1] - t[i-1][j-1]
# for i in range(h+1):
# print(t[i])
ans = 10**9
for i in range(2**(h-1)):
a, b = 0, 0
buf = [0]
for j in range(h-1):
if ((1<<j) & i) > 0:
a += 1
buf.append(j+1)
buf.append(h)
x = 0
F = True
for j in range(1, w+1):
f = False
for l in range(1, len(buf)):
if t[buf[l]][j] - t[buf[l-1]][j] - t[buf[l]][x] + t[buf[l-1]][x] > k:
f = True
if f:
b += 1
x = j-1
for l in range(1, len(buf)):
if t[buf[l]][j] - t[buf[l-1]][j] - t[buf[l]][j-1] + t[buf[l-1]][j-1] > k:
F = False
if a + b < ans and F:
# print(a, b, i, x)
ans = a + b
print(ans)
if __name__ == "__main__":
main() | def main():
h, w, k = list(map(int, input().split()))
s = [input().rstrip() for _ in range(h)]
t = [[0]*(w+1) for _ in range(h+1)]
for i in range(h):
for j in range(w):
if s[i][j] == "1":
t[i+1][j+1] = 1
for i in range(1, h+1):
for j in range(1, w+1):
t[i][j] += t[i-1][j] + t[i][j-1] - t[i-1][j-1]
# for i in range(h+1):
# print(t[i])
ans = 10**9
for i in range(2**(h-1)):
a, b = 0, 0
buf = [0]
for j in range(h-1):
if ((1<<j) & i) > 0:
a += 1
buf.append(j+1)
buf.append(h)
x = 0
F = True
for j in range(1, w+1):
f = False
for l in range(1, len(buf)):
if t[buf[l]][j] - t[buf[l-1]][j] - t[buf[l]][x] + t[buf[l-1]][x] > k:
f = True
if f:
b += 1
x = j-1
for l in range(1, len(buf)):
if t[buf[l]][j] - t[buf[l-1]][j] - t[buf[l]][j-1] + t[buf[l-1]][j-1] > k:
F = False
break
if a + b < ans and F:
# print(a, b, i, x)
ans = a + b
print(ans)
if __name__ == "__main__":
main() | p02733 |
from sys import stdin
def main():
#入力
last_res=float("inf")
readline=stdin.readline
H,W,K=list(map(int,readline().split()))
grid=[]
for i in range(H):
s=readline().strip()
grid.append(s)
for i in range(1<<(H-1)):
output=[]
for j in range(H-1):
if(i>>j)&1:
output.append(j)
count=[0]*(len(output)+1)
res=len(output)
for b in range(W):
now=0
flag=False
for a in range(H):
if len(output)>now and a>output[now]:
now+=1
if grid[a][b]=="1":
count[now]+=1
if count[now]>K:
count=[0]*(len(output)+1)
res+=1
flag=True
break
if flag:
now=0
flag=False
for a in range(H):
if len(output)>now and a>output[now]:
now+=1
if grid[a][b]=="1":
count[now]+=1
if count[now]>K:
res+=1
flag=True
break
if flag:
break
if flag:
res=float("inf")
last_res=min(last_res,res)
print(last_res)
if __name__=="__main__":
main() | from sys import stdin
def main():
#入力
readline=stdin.readline
h,w,k=list(map(int,readline().split()))
grid=[readline().strip() for _ in range(h)]
ans=float("inf")
for i in range(1<<(h-1)):
div=[(i>>j)&1 for j in range(h-1)]
l=len([0 for i in range(h-1) if div[i]])+1
cnt=[0]*l
tmp=0
for j in range(w):
now=0
flag=False
for i_2 in range(h):
if grid[i_2][j]=="1":
cnt[now]+=1
if cnt[now]>k:
flag=True
break
if i_2<h-1 and div[i_2]==1: now+=1
if flag:
tmp+=1
cnt=[0]*l
now=0
flag=False
for i_2 in range(h):
if grid[i_2][j]=="1":
cnt[now]+=1
if cnt[now]>k:
flag=True
break
if i_2<h-1 and div[i_2]==1: now+=1
if flag: break
else:
tmp+=l-1
ans=min(ans,tmp)
print(ans)
if __name__=="__main__":
main() | p02733 |
import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
H, W, K = [int(x) for x in input().split()]
S = [list(input().strip()) for _ in range(H)]
ans = float("inf")
for n in range(2 ** (H - 1)):
tmp = 0
wn = [0] * 10
wi = [set() for _ in range(10)]
ni = 0
for i in range(H):
wi[ni].add(i)
if n >> i & 1:
ni += 1
tmp += 1
for i in range(W):
f = False
for j in range(H):
for wii in range(ni + 1):
if j in wi[wii]:
if wn[wii] + int(S[j][i]) > K:
tmp += 1
f = True
else:
wn[wii] += int(S[j][i])
break
if f:
break
if f:
for wii in range(ni + 1):
wn[wii] = 0
for j in range(H):
for wii in range(ni + 1):
if j in wi[wii]:
wn[wii] += int(S[j][i])
break
ans = min(ans, tmp)
print(ans)
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
H, W, K = [int(x) for x in input().split()]
S = [list(input().strip()) for _ in range(H)]
ans = float("inf")
for n in range(2 ** (H - 1)):
tmp = 0
wn = [0] * 10
wi = [set() for _ in range(10)]
ni = 0
for i in range(H):
wi[ni].add(i)
if n >> i & 1:
ni += 1
tmp += 1
for i in range(W):
f = False
for j in range(H):
for wii in range(ni + 1):
if j in wi[wii]:
if wn[wii] + int(S[j][i]) > K:
tmp += 1
f = True
else:
wn[wii] += int(S[j][i])
break
if f:
break
if f:
for wii in range(ni + 1):
wn[wii] = 0
for j in range(H):
for wii in range(ni + 1):
if j in wi[wii]:
wn[wii] += int(S[j][i])
break
for wii in range(ni + 1):
if wn[wii] > K:
tmp = float("inf")
ans = min(ans, tmp)
print(ans)
if __name__ == '__main__':
main()
| p02733 |
import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
H, W, K = [int(x) for x in input().split()]
S = [list(input().strip()) for _ in range(H)]
ans = float("inf")
for n in range(2 ** (H - 1)):
tmp = 0
wn = [0] * 10
wi = [set() for _ in range(10)]
ni = 0
for i in range(H):
wi[ni].add(i)
if n >> i & 1:
ni += 1
tmp += 1
for i in range(W):
f = False
for j in range(H):
for wii in range(ni + 1):
if j in wi[wii]:
if wn[wii] + int(S[j][i]) > K:
tmp += 1
f = True
else:
wn[wii] += int(S[j][i])
break
if f:
break
if f:
for wii in range(ni + 1):
wn[wii] = 0
for j in range(H):
for wii in range(ni + 1):
if j in wi[wii]:
wn[wii] += int(S[j][i])
break
for wii in range(ni + 1):
if wn[wii] > K:
tmp = float("inf")
ans = min(ans, tmp)
print(ans)
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
H, W, K = [int(x) for x in input().split()]
S = [list(input().strip()) for _ in range(H)]
ans = float("inf")
for n in range(2 ** (H - 1)):
tmp = 0
wn = [0] * 10
for i in range(H):
if n >> i & 1:
tmp += 1
for i in range(W):
f = False
ni = 0
for j in range(H):
if wn[ni] + int(S[j][i]) > K:
tmp += 1
f = True
break
else:
wn[ni] += int(S[j][i])
if n >> j & 1:
ni += 1
if f:
if i == 0:
tmp = float("inf")
for j in range(H):
wn[j] = 0
ni = 0
for j in range(H):
wn[ni] += int(S[j][i])
if wn[ni] > K:
tmp = float("inf")
if n >> j & 1:
ni += 1
ans = min(ans, tmp)
print(ans)
if __name__ == '__main__':
main()
| p02733 |
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n, m, K = na()
b = []
for i in range(n):
b.append(ns())
ans = 999999999999999
for ptn in range(1<<m-1):
lans = 0
x = ptn
while x > 0:
lans += x&1
x //= 2
to = [0] * n
for i in range(1,n):
if ptn>>i-1&1:
to[i] = i
else:
to[i] = to[i-1]
f = [0] * n
ok = True
for j in range(m):
plus = [0] * n
for r in range(n):
plus[to[r]] += ord(b[r][j])-ord("0")
if plus[to[r]] > K:
ok = False
break
if not ok: break
reset = False
for r in range(n):
if f[r] + plus[r] > K:
reset = True
if reset:
lans += 1
f = plus
else:
for i in range(n):
f[i] += plus[i]
if not ok:
continue
ans = min(ans, lans)
print(ans)
| import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n, m, K = na()
b = []
for i in range(n):
b.append(ns())
ans = 999999999999999
for ptn in range(1<<n-1):
lans = 0
x = ptn
while x > 0:
lans += x&1
x //= 2
to = [0] * n
for i in range(1,n):
if ptn>>i-1&1:
to[i] = i
else:
to[i] = to[i-1]
f = [0] * n
ok = True
o = ord("0")
for j in range(m):
plus = [0] * n
for r in range(n):
plus[to[r]] += ord(b[r][j])-o
if plus[to[r]] > K:
ok = False
break
if not ok:
break
reset = any(f[r] + plus[r] > K for r in range(n))
if reset:
lans += 1
f = plus
else:
for i in range(n):
f[i] += plus[i]
if not ok:
continue
ans = min(ans, lans)
print(ans)
| p02733 |
# -*- 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 collections import deque
from functools import lru_cache
import bisect
import re
import queue
import decimal
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 [Scanner.string() 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 [Scanner.int() for i in range(n)]
def solve():
H, W, K = Scanner.map_int()
S = Scanner.string_list(H)
ans = int(1e15)
for i in range(1 << (H - 1)):
cut = 0
whites = [[0 for _ in range(W)] for _ in range(H)]
for j in range(H - 1):
for w in range(W):
whites[cut][w] += S[j][w] == '1'
if i >> j & 1:
cut += 1
for w in range(W):
whites[cut][w] += S[-1][w] == '1'
flag = True
for line in whites:
for cnt in line:
if cnt > K:
flag = False
if not flag:
continue
cnt = [0 for _ in range(H)]
for w in range(W):
flag = True
for j in range(H):
if cnt[j] + whites[j][w] > K:
flag = False
if not flag:
cnt = [0 for _ in range(H)]
cut += 1
for j in range(H):
cnt[j] += whites[j][w]
ans = min(ans, cut)
print(ans)
def main():
# sys.setrecursionlimit(1000000)
# sys.stdin = open("sample.txt")
# T = Scanner.int()
# for _ in range(T):
# solve()
# print('YNeos'[not solve()::2])
solve()
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 collections import deque
from functools import lru_cache
import bisect
import re
import queue
import decimal
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 [Scanner.string() 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 [Scanner.int() for i in range(n)]
def solve():
H, W, K = Scanner.map_int()
S = Scanner.string_list(H)
ans = int(1e15)
for i in range(1 << (H - 1)):
cut = 0
pc = 1
whites = [[0 for _ in range(W)] for _ in range(H)]
for j in range(H - 1):
for w in range(W):
whites[cut][w] += S[j][w] == '1'
if i >> j & 1:
cut += 1
pc += 1
for w in range(W):
whites[cut][w] += S[-1][w] == '1'
flag = True
for line in whites:
for cnt in line:
if cnt > K:
flag = False
if not flag:
continue
cnt = [0 for _ in range(pc)]
for w in range(W):
flag = True
for j in range(pc):
if cnt[j] + whites[j][w] > K:
flag = False
if not flag:
cnt = [0 for _ in range(pc)]
cut += 1
for j in range(pc):
cnt[j] += whites[j][w]
ans = min(ans, cut)
print(ans)
def main():
# sys.setrecursionlimit(1000000)
# sys.stdin = open("sample.txt")
# T = Scanner.int()
# for _ in range(T):
# solve()
# print('YNeos'[not solve()::2])
solve()
if __name__ == "__main__":
main()
| p02733 |
r=range;_,*s=open(0)
h,w,k=list(map(int,_.split()))
m=9e9
for i in r(1<<h-1):
t,v,l=[],-1,1
for j in r(h):
if i>>j&1:t+=j+1,;l+=1
t+=h,
c=[0]*l
for i in r(w):
b=f=g=0;u=[]
for j in r(l):d,b=sum(s[j][i]>"0"for j in r(b,t[j])),t[j];u+=d,;g|=d>k;c[j]+=d;f|=c[j]>k
v+=f
if f:c=u
if~g:m=min(m,v+l)
print(m) | r=range;_,*s=open(0)
h,w,k=list(map(int,_.split()))
m=9e9
for i in r(1<<h-1):
t,v,l=[],-1,1
for j in r(h):
if i>>j&1:t+=j+1,;l+=1
t+=h,
c=[0]*l
for i in r(w):
b=f=g=0;u=[]
for j in r(l):d,b=sum(s[j][i]>"0"for j in r(b,t[j])),t[j];u+=d,;g|=d>k;c[j]+=d;f|=c[j]>k
v+=f
if f:c=u
if not g:m=min(m,v+l)
print(m) | p02733 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
from re import split
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
from copy import deepcopy
import re
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
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 = 10 ** 9 + 7
h, w, k = LI()
s = []
for _ in range(h):
s += [[int(i) for i in list(S())]]
ans = INF
for j in range(2 ** (h - 1)):
L = []
last = 0
for m in range(h - 1):
if j >> m & 1:
L += [(last, m + 1)]
last = m + 1
L += [(last, h)]
now = [0] * len(L)
last_x = 0
cnt = len(L) - 1
flag2 = 0
flag = 0
x = 0
while x < w:
flag3 = 0
K = [s[y][x] for y in range(h)]
for i in range(len(L)):
l, r = L[i]
k_sum = sum(K[l:r])
if now[i] + k_sum > k:
cnt += 1
if flag == 0:
flag2 = 1
break
else:
flag = 0
now = [0] * len(L)
flag3 = 1
break
else:
now[i] += k_sum
else:
flag = 1
if flag3:
continue
if flag2:
break
x += 1
else:
ans = min(ans, cnt)
print(ans)
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
from re import split
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
from copy import deepcopy
import re
sys.setrecursionlimit(2147483647)
INF = 10 ** 20
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 = 10 ** 9 + 7
h, w, k = LI()
s = SRL(h)
ans = INF
for bits in range(2 ** (h - 1)):
res = sum([int(j) for j in "{0:b}".format(bits)])
div_cnt = res + 1
cnt = [0] * div_cnt
x = 0
flg = 0
while x < w:
cur = 0
for y in range(h):
if s[y][x] == '1':
cnt[cur] += 1
if bits >> y & 1:
cur += 1
if max(cnt) > k:
if flg == 0:
res = INF
break
else:
cnt = [0] * div_cnt
flg = 0
res += 1
else:
flg = 1
x += 1
ans = min(ans, res)
print(ans)
| p02733 |
import sys
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
S = [[int(i) for i in input()[:-1]] for _ in range(H)]
m = float('inf')
for i in range(1 << (H - 1)) :
pos = [0] * H
x = 0
for j in range(H - 1) :
if i & (1 << j) :
x += 1
pos[j+1] = x
x = 0
cnt = [0] * H
ret = bin(i)[2:].count('1')
while x < W :
for y in range(H) :
cnt[pos[y]] += S[y][x]
if cnt[pos[y]] > K :
cnt = [0] * H
ret += 1
break
else :
x += 1
m = min(m, ret)
print(m) | import sys
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
S = [[int(i) for i in input()[:-1]] for _ in range(H)]
m = float('inf')
for i in range(1 << (H - 1)) :
pos = [0] * H
x = 0
for j in range(H - 1) :
if i & (1 << j) :
x += 1
pos[j+1] = x
ret = x
x = 0
cnt = [0] * H
flag = 0
while x < W :
for y in range(H) :
cnt[pos[y]] += S[y][x]
if cnt[pos[y]] > K :
cnt = [0] * H
ret += 1
flag += 1
break
else :
x += 1
flag = 0
if flag == 2 :
ret = float('inf')
break
m = min(m, ret)
print(m) | p02733 |
x,*s=open(0)
h,w,k,*m=list(map(int,x.split()))
for b in range(512):
r=t=j=0;d=[0]*h
while j<w:
i=c=0
while h-i:
d[c]+=s[i][j]>'0';x=d[c]>k
if(t<j)&x:r+=1;t=j;d=[0]*h;break
r+=x*h*w;c+=b>>i&1;i+=1
else:j+=1
while b:r+=b&1;b>>=1
m+=r,
print((min(m))) | x,*s=open(0)
h,w,k,*m=list(map(int,x.split()))
b=512
while b:
b-=1;r=t=j=0;d=[0]*h
while j<w:
i=c=0
while h-i:
d[c]+=s[i][j]>'0';y=t<j
if d[c]>k:d=[0]*h;r+=1-~-y*h*w;t=j;j-=y;break
c+=b>>i&1;i+=1
j+=1
m+=r+c,
print((min(m))) | p02733 |
import sys
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
choco = []
for i in range(H):
s = input().strip()
a = list(map(int, list(s)))
choco.append(a)
def f(n):
if n == 1:
return [[0], [1]]
a = f(n-1)
na = []
for v in a:
na.append([0] + v)
na.append([1] + v)
return na
def min_split(h):
sum_cnt = [0] * H
num_split = 0
for j in range(W):
c = 0
cnt = [0] * H
for i in range(H):
if choco[i][j] == 1:
cnt[c] += 1
if i < H-1 and h[i] == 1:
c += 1
new_cnt = [x + y for x, y in zip(sum_cnt, cnt)]
if max(new_cnt) > K:
num_split += 1
sum_cnt = cnt
else:
sum_cnt = new_cnt
return num_split + sum(h)
min_m = float('inf')
for h in f(H-1):
m = min_split(h)
min_m = min(min_m, m)
print(min_m) | import sys, itertools
input = sys.stdin.readline
H, W, K = list(map(int, input().split()))
choco = []
for i in range(H):
s = input().strip()
a = list(map(int, list(s)))
choco.append(a)
def min_split(h):
sum_cnt = [0] * H
num_split = 0
for j in range(W):
c = 0
cnt = [0] * H
flag = False
for i in range(H):
if choco[i][j] == 1:
cnt[c] += 1
if cnt[c] > K:
return float('inf')
if cnt[c] + sum_cnt[c] > K:
flag = True
if i < H-1 and h[i] == 1:
c += 1
if flag:
num_split += 1
sum_cnt = cnt
else:
for i in range(len(cnt)):
sum_cnt[i] += cnt[i]
return num_split + sum(h)
min_m = float('inf')
for h in itertools.product([0,1], repeat=H-1):
m = min_split(h)
min_m = min(min_m, m)
print(min_m) | p02733 |
import sys
from itertools import accumulate
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
H, W, K = lr()
S = [list(map(int, sr())) for _ in range(H)]
Scum = [list(accumulate(x)) for x in S]
answer = 10000
for bit in range(1<<(H-1)):
count = 0
for i in range(H-1):
if bit >> i & 1:
count += 1
bit += 1 << H-1 # 最後の切れ目
# 縦のラインは貪欲法
prev = -1
w = 0
while w < W:
white = 0
cut = False
for i in range(H):
white += Scum[i][w] - (Scum[i][prev] if prev >= 0 else 0)
if (bit >> i) & 1: # 切れ目が来た
if white > K:
cut = True
white = 0
if cut:
if prev == w-1: # 一列でKをオーバー
break
count += 1
prev = w-1
else:
w += 1
else:
answer = min(answer, count)
print(answer)
| # coding: utf-8
import sys
from itertools import accumulate
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
H, W, K = lr()
S = [list(map(int, sr())) for _ in range(H)]
Scum = [list(accumulate(row)) for row in S]
# H方向はbit全探索、W方向はGreedyに
INF = 10 ** 10
answer = INF
for pattern in range(1<<(H-1)):
slice = set()
cnt = 0
for i in range(H-1):
if pattern>>i & 1:
slice.add(i)
cnt += 1
slice.add(H-1) # 最後の区切り
w = 0
prev = -1
while w < W:
cut = False
white = 0
for i in range(H):
white += Scum[i][w] - (Scum[i][prev] if prev >= 0 else 0)
if i in slice:
if white > K:
cut = True
break
white = 0
if cut:
if prev == w - 1: # 1列でKをオーバーしたので無理
break
cnt += 1
prev = w-1
else:
w += 1
else:
answer = min(answer, cnt)
print(answer)
# 43 | p02733 |
import sys
input = sys.stdin.readline
h, w, K = [int(x) for x in input().split()]
s = [input().rstrip() for _ in range(h)]
# print(s)
# print(len(s[1]))
# ans = h + w - 2
ans = h + w - 2
for i in range(2 ** (h - 1)):
new_s = []
cnt = 0
i_bin = bin(i)[2:].zfill(h - 1)
add = []
for j in range(h - 1):
if i_bin[j] == "1":
cnt += 1
add.append(s[j])
new_s.append(add)
add = []
else:
add.append(s[j])
if j == h - 2:
add.append(s[-1])
new_s.append(add)
if h == 1:
new_s = [s]
#print(len(new_s))
total = [0] * len(new_s)
#print(new_s)
for k in range(w):
# print(k)
tmp_list = [0]*len(new_s)
#print(total)
flag = 0
for l in range(len(new_s)):
tmp = sum([int(new_s[l][x][k]) for x in range(len(new_s[l]))])
# tmp_list[l] = tmp
# print(tmp)
if tmp > K:
cnt = 10**18
flag = 1
break
tmp_list[l] = tmp
total[l] += tmp
if flag:
break
for m in total:
flag_2 = 1
if m > K:
cnt += 1
total = tmp_list
flag_2 = 0
break
# if flag_2:
# for m in total:
# if m == K and k != w - 1:
# cnt += 1
# total = [0]*len(new_s)
# break
if not flag:
#print(cnt)
ans = min(ans, cnt)
print(ans)
| import sys
input = sys.stdin.readline
h, w, K = [int(x) for x in input().split()]
s = [input().rstrip() for _ in range(h)]
ans = h + w - 2
for i in range(2 ** (h - 1)):
new_s = []
cnt = 0
i_bin = bin(i)[2:].zfill(h - 1)
add = []
for j in range(h - 1):
if i_bin[j] == "1":
cnt += 1
add.append(s[j])
new_s.append(add)
add = []
else:
add.append(s[j])
if j == h - 2:
add.append(s[-1])
new_s.append(add)
if h == 1:
new_s = [s]
total = [0] * len(new_s) # ブロックごとに、切った後~進んだ分の増えたホワイトチョコの個数を管理
for k in range(w):
tmp_list = [0]*len(new_s) # ブロックごとに、1つ進めて増えるホワイトチョコを管理
flag = 0
for l in range(len(new_s)):
tmp = sum([int(new_s[l][x][k]) for x in range(len(new_s[l]))])
if tmp > K:
flag = 1
break
tmp_list[l] = tmp
total[l] += tmp
if flag:
break
for m in total: # 1つでもKを越えていたら直前で切る
if m > K:
cnt += 1
total = tmp_list
break
if not flag:
ans = min(ans, cnt)
print(ans)
| p02733 |
# -*- coding: utf-8 -*-
import sys
from collections import defaultdict
H,W,K=list(map(int, sys.stdin.readline().split()))
S=[ sys.stdin.readline().strip() for _ in range(H) ]
ans=float("inf")
for bit in range(2**H):
cnt=0
group_num=0
GROUP={}
for i,s in enumerate(S):
if i==0:
GROUP[i]=group_num
else:
if bit>>i-1&1==1:
cnt+=1 #境目のカウントに+1
group_num+=1
GROUP[i]=group_num
ok=None
VALUE=defaultdict(lambda: 0)
w=0
break_flag=False
for w in range(W):
if break_flag: #breakフラグがTrueならループを止める
break
for h in range(H):
VALUE[GROUP[h]]+=int(S[h][w])
#現在の集計でKを超えている値がないかをチェック
for v in list(VALUE.values()):
if v<=K:
pass
else:
if ok is None: #okに値がない場合は、このパターンは成り立たない
cnt=float("inf") #不可能なパターンなのでカウントに無限大を代入
break_flag=True #breakフラグにTrueを代入
break
else: #以前の列でok番号に値が入っていた、つまり成り立つ列があった場合
cnt+=1 #境目のカウントに+1
VALUE=defaultdict(lambda: 0) #NGの場合は値を初期化して入れなおし
for h in range(H):
VALUE[GROUP[h]]+=int(S[h][w])
break
else:
ok=w #値が全てK以下だった場合はok変数に列番号を記録
ans=min(ans,cnt)
print(ans) | # -*- coding: utf-8 -*-
import sys
from collections import defaultdict
H,W,K=list(map(int, sys.stdin.readline().split()))
S=[ sys.stdin.readline().strip() for _ in range(H) ]
ans=float("inf")
for bit in range(2**H):
cnt=0
group_num=0
GROUP={}
for i,s in enumerate(S):
if i==0:
GROUP[i]=group_num
else:
if bit>>i-1&1==1:
cnt+=1 #境目のカウントに+1
group_num+=1
GROUP[i]=group_num
ok=None
VALUE=defaultdict(lambda: 0)
w=0
break_flag=False
for w in range(W):
if break_flag: #breakフラグがTrueならループを止める
break
for h in range(H):
VALUE[GROUP[h]]+=int(S[h][w])
#現時点の集計でKを超えている値がないかをチェック
for v in list(VALUE.values()):
if v<=K:
pass
else:
if ok is None: #okに値がない場合は、このパターンは成り立たない
cnt=float("inf") #不可能なパターンなのでカウントに無限大を代入
break_flag=True #breakフラグにTrueを代入
break
else: #以前の列でok番号に値が入っていた、つまり成り立つ列があった場合
cnt+=1 #境目のカウントに+1
VALUE=defaultdict(lambda: 0) #NGの場合は値を初期化して入れなおし
for h in range(H):
VALUE[GROUP[h]]+=int(S[h][w])
break
else:
ok=w #値が全てK以下だった場合はok変数に列番号を記録
ans=min(ans,cnt)
print(ans) | p02733 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
H,W,K = list(map(int, readline().split()))
S = [readline().strip() for j in range(H)]
white = []
for line in S:
white.append(line.count("1"))
white_total = sum(white)
if white_total <= K:
print((0))
exit()
# 横線の決め方を全探索
ans = 10**5
for pattern in range(2**(H-1)):
# 初期化
impossible = False
x = 0
ly = bin(pattern).count("1")
y = [[0]*W]*(ly + 1)
line = 0
for i in range(H):
y[line] = [y[line][j] + int(S[i][j]) for j in range(W)]
if (pattern >> i) & 1:
line += 1
# 各列の値を加算していく
count = [0]*(ly + 1)
for col in zip(*y):
# Kより大きい値を加算する場合は不成立
if any(a > K for a in col):
impossible = True
break
for i, a in enumerate(col):
count[i] += a
# 和がKより大きければカット数を増やす
if count[i] > K:
x += 1
count = list(col)
break
if impossible:
x = 10**6
ans = min(ans, x + ly)
print(ans)
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
H,W,K = list(map(int, readline().split()))
S = [readline().strip() for j in range(H)]
white = []
for line in S:
white.append(line.count("1"))
white_total = sum(white)
if white_total <= K:
print((0))
exit()
# 横線の決め方を全探索
ans = 10**5
for pattern in range(2**(H-1)):
# 初期化
impossible = False
x = 0
ly = bin(pattern).count("1")
y = [[0]*W]*(ly + 1)
line = 0
for i in range(H):
y[line] = [y[line][j] + int(S[i][j]) for j in range(W)]
if (pattern >> i) & 1:
line += 1
# 各列の値を加算していく
count = [0]*(ly + 1)
for col in zip(*y):
# Kより大きい値を加算する場合は不成立
if any(a > K for a in col):
impossible = True
break
for i, a in enumerate(col):
count[i] += a
# 和がKより大きければカット数を増やす
if count[i] > K:
x += 1
count = list(col)
break
if x + ly > ans:
impossible = True
break
if impossible:
x = 10**6
ans = min(ans, x + ly)
print(ans)
if __name__ == "__main__":
main()
| p02733 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
H,W,K = list(map(int, readline().split()))
S = [readline().strip() for j in range(H)]
white = []
for line in S:
white.append(line.count("1"))
white_total = sum(white)
if white_total <= K:
print((0))
exit()
# 横線の決め方を全探索
ans = 10**5
for pattern in range(2**(H-1)):
# 初期化
impossible = False
x = 0
ly = bin(pattern).count("1")
y = [[0]*W]*(ly + 1)
line = 0
for i in range(H):
y[line] = [y[line][j] + int(S[i][j]) for j in range(W)]
if (pattern >> i) & 1:
line += 1
# 各列の値を加算していく
count = [0]*(ly + 1)
for col in zip(*y):
# Kより大きい値を加算する場合は不成立
if any(a > K for a in col):
impossible = True
break
for i, a in enumerate(col):
count[i] += a
# 和がKより大きければカット数を増やす
if count[i] > K:
x += 1
count = list(col)
break
if x + ly > ans:
impossible = True
break
if impossible:
x = 10**6
ans = min(ans, x + ly)
print(ans)
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
H,W,K = list(map(int, readline().split()))
S = [list(map(int, readline().strip())) for j in range(H)]
white = 0
for line in S:
white += sum(line)
if white <= K:
print((0))
exit()
# 横線の決め方を全探索
ans = 10**5
for pattern in range(2**(H-1)):
# 初期化
impossible = False
x = 0
ly = bin(pattern).count("1")
y = [[0]*W]*(ly + 1)
line = 0
for i in range(H):
y[line] = [y[line][j] + S[i][j] for j in range(W)]
if (pattern >> i) & 1:
line += 1
# 各列の値を加算していく
count = [0]*(ly + 1)
for col in zip(*y):
# Kより大きい値を加算する場合は不成立
if any(a > K for a in col):
impossible = True
break
for i, a in enumerate(col):
count[i] += a
# 和がKより大きければカット数を増やす
if count[i] > K:
x += 1
count = list(col)
break
if x + ly > ans:
impossible = True
break
if impossible:
x = 10**6
ans = min(ans, x + ly)
print(ans)
if __name__ == "__main__":
main()
| p02733 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
H,W,K = list(map(int, readline().split()))
S = [list(map(int, readline().strip())) for j in range(H)]
white = 0
for line in S:
white += sum(line)
if white <= K:
print((0))
exit()
# 横線の決め方を全探索
ans = 10**5
for pattern in range(2**(H-1)):
# 初期化
impossible = False
x = 0
ly = bin(pattern).count("1")
y = [[0]*W]*(ly + 1)
line = 0
for i in range(H):
y[line] = [y[line][j] + S[i][j] for j in range(W)]
if (pattern >> i) & 1:
line += 1
# 各列の値を加算していく
count = [0]*(ly + 1)
for j in range(W):
for i in range(line+1):
if y[i][j] > K :
impossible = True
break
count[i] += y[i][j]
if count[i] > K:
x += 1
for i in range(line+1):
count[i] = y[i][j]
break
if x + ly > ans or impossible:
impossible = True
break
if impossible:
x = 10**6
ans = min(ans, x + ly)
print(ans)
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
H,W,K = list(map(int, readline().split()))
S = [list(map(int, readline().strip())) for j in range(H)]
white = 0
for line in S:
white += sum(line)
if white <= K:
print((0))
exit()
# 横線の決め方を全探索
ans = 10**5
for pattern in range(2**(H-1)):
# 初期化
impossible = False
x = 0
ly = bin(pattern).count("1")
y = [S[0]]
line = 0
for i in range(1,H):
if (pattern >> i-1) & 1:
line += 1
y.append(S[i])
else:
y[line] = [y[line][j] + S[i][j] for j in range(W)]
# 各列の値を加算していく
count = [0]*(ly + 1)
for j in range(W):
for i in range(line+1):
if y[i][j] > K :
impossible = True
break
count[i] += y[i][j]
if count[i] > K:
x += 1
for i in range(line+1):
count[i] = y[i][j]
break
if x + ly > ans or impossible:
impossible = True
break
if impossible:
x = 10**6
ans = min(ans, x + ly)
print(ans)
if __name__ == "__main__":
main()
| p02733 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.