input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
x=int(eval(input()))
c=x//500
d=x%500
e=d//5
print((1000*c+e*5)) | x=int(eval(input()))
a=x//500
b=x%500
c=b//5
print((1000*a+5*c)) | p02724 |
x = int(eval(input()))
a = x//500
x -= a*500
b = x//5
ax = a*1000
bx = b*5
print((ax+bx)) | n = int(eval(input()))
x = n//500
y = n-500*x
z = y//5
print((x*1000+z*5)) | p02724 |
s=int(eval(input()))
ans=s//500*1000+(s%500//5)*5
print(ans) | x=int(eval(input()))
print(((x//500)*1000+(x%500)//5*5))
| p02724 |
from operator import itemgetter
n = int(eval(input()))
lr = [list(map(int, input().split())) + [i] for i in range(n)]
l_sort = sorted(lr, key=itemgetter(0), reverse=True)
r_sort = sorted(lr, key=itemgetter(1))
ans = 0
used = []
now = 0
i = 0
j = 0
if abs(l_sort[0][0]) >= abs(r_sort[0][1]):
while len(used) != n:
while l_sort[i][2] in used:
i += 1
if not (l_sort[i][0] <= now and now <= l_sort[i][1]):
ans += abs(now - l_sort[i][0])
now = l_sort[i][0]
used.append(l_sort[i][2])
i += 1
if len(used) == n:
break
while r_sort[j][2] in used:
j += 1
if not (r_sort[j][0] <= now and now <= r_sort[j][1]):
ans += abs(now - r_sort[j][1])
now = r_sort[j][1]
used.append(r_sort[j][2])
j += 1
print((ans + abs(now)))
else:
while len(used) != n:
while r_sort[j][2] in used:
j += 1
if not (r_sort[j][0] <= now and now <= r_sort[j][1]):
ans += abs(now - r_sort[j][1])
now = r_sort[j][1]
used.append(r_sort[j][2])
j += 1
if len(used) == n:
break
while l_sort[i][2] in used:
i += 1
if not (l_sort[i][0] <= now and now <= l_sort[i][1]):
ans += abs(now - l_sort[i][0])
now = l_sort[i][0]
used.append(l_sort[i][2])
i += 1
#print(now)
print((ans + abs(now))) | from operator import itemgetter
n = int(eval(input()))
lr = [list(map(int, input().split())) for i in range(n)] + [[0, 0]]
l_sort = sorted(lr, key=itemgetter(0), reverse=True)
r_sort = sorted(lr, key=itemgetter(1))
ans = 0
sigma = 0
for i in range(n // 2 + 1):
sigma += 2 * (l_sort[i][0] - r_sort[i][1])
if sigma > ans:
ans = sigma
print(ans) | p03333 |
from heapq import heappush, heappop
N = int(eval(input()))
S = []
for i in range(N):
l, r = list(map(int, input().split()))
S.append((l, r))
S.sort()
if all(l <= 0 <= r for l, r in S):
print((0))
exit(0)
que = []
P = []
Q = [l for l, r in S]
Q.reverse()
ans = 0
a = b = 0
p = 0
for i in range(N+1):
if i < N:
l, r = S[i]
while que and que[0] <= l:
P.append(heappop(que))
cnt = min(len(P), len(Q))
while p < cnt:
a += P[p]
b += Q[p]
p += 1
ans = max(ans, abs(a-b)*2)
if len(P) < len(Q):
b2 = b + Q[cnt]
ans = max(ans, abs(a-b2)*2)
elif len(P) > len(Q):
a2 = a + P[cnt]
ans = max(ans, abs(a2-b)*2)
heappush(que, r)
if cnt == len(Q) > 0:
a -= P[cnt-1]
b -= Q[cnt-1]
if i < N:
Q.pop()
print(ans)
| from heapq import heappush, heappop
N = int(eval(input()))
S = []
for i in range(N):
l, r = list(map(int, input().split()))
S.append((l, r))
if all(l <= 0 <= r for l, r in S):
print((0))
exit(0)
P = sorted(r for l, r in S)
Q = sorted(l for l, r in S)
L = R = 0
ans = 0
for i in range(N):
if not i < N-1-i:
break
L += P[i]
R += Q[N-1-i]
ans = max(ans, abs(R - L)*2)
if i+1 < N-1-i:
ans = max(ans, abs(R - L - P[i+1])*2)
if i < N-1-i-1:
ans = max(ans, abs(R + Q[N-1-i-1] - L)*2)
print(ans) | p03333 |
N=int(eval(input()))
LR=[None]*N
for i in range(N):
LR[i]=list(map(int,input().split()))
if len(LR)%2==1:
LR=LR+[[0,0]]
RAN=(len(LR)+1)//2
LR_L=sorted(LR,key=lambda x: x[0],reverse=True)
LR_R=sorted(LR,key=lambda x: x[1])
ANS=0
for k in range(RAN):
SUB=0
for i in range(k+1):
SUB+=LR_L[i][0]-LR_R[i][1]
ANS=max(SUB,ANS)
print((ANS*2))
| N=int(eval(input()))
LR=[None]*N
for i in range(N):
LR[i]=list(map(int,input().split()))
RAN=(len(LR)+1)//2
LR_L=sorted(LR,key=lambda x: x[0],reverse=True)
LR_R=sorted(LR,key=lambda x: x[1])
ANS_l=[0]*(RAN*2+2)
ANS_r=[0]*(RAN*2+2)
for i in range(RAN):
ANS_l[2*i+1]=ANS_l[2*i]+LR_L[i][0]
ANS_l[2*i+2]=ANS_l[2*i+1]-LR_R[i][1]
ANS_r[2*i+1]=ANS_r[2*i]-LR_R[i][1]
ANS_r[2*i+2]=ANS_r[2*i+1]+LR_L[i][0]
print((max(max(ANS_l)*2,max(ANS_r)*2))) | p03333 |
"""
貪欲か？
今いる地点から左のRと右のLの数を比較
多い方の最遠点に行く→そのような点が無くなったら終了
証明は…
まず右のR,左のLは無意味→区間を無駄にするだけ
少ない方に行く→多い方の区間が無駄になる
近い点に行く→ ここがむずい
遠い区間が無駄になるのを防ぐため？
実装は？
多い方の処理→BITで左にあるRの数と右にあるLの数をlogNで
優先度付きキューで最小のRと最大のLを検出
10^5+1 を足して1 ～ 2*10^5 + 1の区間として扱う
初期・終了地点は 10^5+1
"""
import heapq
def bitadd(a,w,bit): #aにwを加える(1-origin)
x = a
while x <= (len(bit)-1):
bit[x] += w
x += x & (-1 * x)
def bitsum(a,bit): #ind 1～aまでの和を求める
ret = 0
x = a
while x > 0:
ret += bit[x]
x -= x & (-1 * x)
return ret
N = int(eval(input()))
used = [False] * N
lq = []
rq = []
LR = []
LBIT = [0] * (2 * (10**5) + 10)
RBIT = [0] * (2 * (10**5) + 10)
for i in range(N):
L,R = list(map(int,input().split()))
L += 10**5+1
R += 10**5+1
LR.append([L,R])
heapq.heappush(lq,[-1 * L,i])
heapq.heappush(rq,[R,i])
bitadd(L,1,LBIT)
bitadd(R,1,RBIT)
ans = 0
now = 10**5+1
for i in range(N):
R_in_left = bitsum(now-1,RBIT)
L_in_right = N - i - bitsum(now,LBIT)
if R_in_left >= L_in_right: #左にあるRに移動
while len(rq) > 0 and used[ rq[0][1] ]:
heapq.heappop(rq)
if len(rq) == 0:
break
nexp,nexind = heapq.heappop(rq)
pair = LR[nexind][0]
bitadd(nexp,-1,RBIT)
bitadd(pair,-1,LBIT)
used[nexind] = True
if nexp >= now:
break
ans += now - nexp
now = nexp
else:
while len(lq) > 0 and used[ lq[0][1] ]:
heapq.heappop(lq)
if len(lq) == 0:
break
nexp,nexind = heapq.heappop(lq)
nexp *= -1
pair = LR[nexind][1]
bitadd(nexp,-1,LBIT)
bitadd(pair,-1,RBIT)
used[nexind] = True
if nexp <= now:
break
ans += nexp - now
now = nexp
ans += abs(10**5+1 - now)
print (ans)
|
N = int(eval(input()))
L = []
R = []
for i in range(N):
l,r = list(map(int,input().split()))
L.append(2 * l)
R.append(-2 * r)
L.sort()
R.sort()
L.reverse()
R.reverse()
ans = 0
now = 0
for i in range(N):
now += L[i]
ans = max(ans,now)
now += R[i]
ans = max(ans,now)
now = 0
for i in range(N):
now += R[i]
ans = max(ans,now)
now += L[i]
ans = max(ans,now)
print (ans)
| p03333 |
import sys
import heapq
import copy
input = sys.stdin.buffer.readline
N = int(eval(input()))
pq_L = []
pq_R = []
for i in range(N):
L, R = list(map(int, input().split()))
heapq.heappush(pq_L, (-L, i))
heapq.heappush(pq_R, (R, i))
pq_L2 = copy.deepcopy(pq_L)
pq_R2 = copy.deepcopy(pq_R)
ans1 = 0
prev = 0
used = [0] * N
for i in range(N):
if i % 2 == 0:
while True:
_x, j = heapq.heappop(pq_L)
x = -_x
if not used[j]:
used[j] = 1
break
if prev < x:
ans1 += x - prev
prev = x
else:
while True:
x, j = heapq.heappop(pq_R)
if not used[j]:
used[j] = 1
break
if prev > x:
ans1 += prev - x
prev = x
ans1 += abs(prev)
ans2 = 0
prev = 0
used = [0] * N
for i in range(N):
if i % 2 == 1:
while True:
_x, j = heapq.heappop(pq_L2)
x = -_x
if not used[j]:
used[j] = 1
break
if prev < x:
ans2 += x - prev
prev = x
else:
while True:
x, j = heapq.heappop(pq_R2)
if not used[j]:
used[j] = 1
break
if prev > x:
ans2 += prev - x
prev = x
ans2 += abs(prev)
print((max(ans1, ans2)))
| import sys
import heapq
import copy
input = sys.stdin.buffer.readline
def main():
N = int(eval(input()))
pq_L = []
pq_R = []
for i in range(N):
L, R = list(map(int, input().split()))
heapq.heappush(pq_L, (-L, i))
heapq.heappush(pq_R, (R, i))
pq_L2 = copy.deepcopy(pq_L)
pq_R2 = copy.deepcopy(pq_R)
ans1 = 0
prev = 0
used = [0] * N
for i in range(N):
if i % 2 == 0:
while True:
_x, j = heapq.heappop(pq_L)
x = -_x
if not used[j]:
used[j] = 1
break
if prev < x:
ans1 += x - prev
prev = x
else:
while True:
x, j = heapq.heappop(pq_R)
if not used[j]:
used[j] = 1
break
if prev > x:
ans1 += prev - x
prev = x
ans1 += abs(prev)
ans2 = 0
prev = 0
used = [0] * N
for i in range(N):
if i % 2 == 1:
while True:
_x, j = heapq.heappop(pq_L2)
x = -_x
if not used[j]:
used[j] = 1
break
if prev < x:
ans2 += x - prev
prev = x
else:
while True:
x, j = heapq.heappop(pq_R2)
if not used[j]:
used[j] = 1
break
if prev > x:
ans2 += prev - x
prev = x
ans2 += abs(prev)
print((max(ans1, ans2)))
if __name__ == '__main__':
main()
| p03333 |
from sys import stdin, stdout
from time import perf_counter
import sys
sys.setrecursionlimit(10**9)
mod = 10**9+7
l = [int(item) for item in input().split()]
if (l[0]==5 and l[1] == 5 and l[2]==7) or (l[0]==5 and l[1] == 7 and l[2]==5) or (l[0]==7 and l[1] == 5 and l[2]==5):
print("YES")
else:
print("NO") | from sys import stdin, stdout
from time import perf_counter
import sys
sys.setrecursionlimit(10**9)
mod = 10**9+7
l= sorted(map(int, input().split()))
print(("YES" if l == [5,5,7] else "NO")) | p04043 |
'''To count the number of occurrences of
something in a programs
Use count fucntion of the list
'''
a=list(map(int,input().split()))
if a.count(5)==2 and a.count(7)==1:
print("YES")
else:
print("NO")
| seq = [int(s) for s in input().split()]
if seq.count(5) == 2 and seq.count(7) == 1:
print("YES")
else: print("NO") | p04043 |
L = [int(x) for x in input().split()]
L.sort()
if L == [5,5,7]:
print("YES")
else:
print("NO")
| L = sorted(list(map(int, input().split())))
print(('YES' if L[0]==L[1]==5 and L[2]==7 else 'NO'))
| p04043 |
L = sorted(list(map(int, input().split())))
if L == [5,5,7]:
print("YES")
else:
print("NO") | S = [int(i) for i in input().split()]
S.sort()
if S == [5,5,7]:
print("YES")
else:
print("NO")
| p04043 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def main():
ABC = list(map(int, input().split()))
print(('YES' if ABC.count(5) == 2 and ABC.count(7) == 1 else 'NO'))
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
# -*- coding: utf-8 -*-
def main():
ABC = list(map(int, input().split()))
ABC.sort()
print(('YES' if [5, 5, 7] == ABC else 'NO'))
if __name__ == "__main__":
main()
| p04043 |
abc = list(map(int,input().split()))
print(("YES" if abc.count(5) == 2 and abc.count(7) == 1 else "NO")) | abc = list(map(int, input().split()))
if abc.count(5) == 2 and abc.count(7) == 1: print("YES")
else: print("NO") | p04043 |
ABC = list(map(int,input().split()))
print(("YES" if ABC.count(5)==2 and ABC.count(7)==1 else "NO")) | X = list(map(int,input().split()))
print(("YES" if X.count(5)==2 and X.count(7)==1 else "NO")) | p04043 |
a = list(map(int,input().split()))
b = sorted(a)
print(('YES' if b[0]==5 and b[1]==5 and b[2]==7 else 'NO')) | a = input().split()
b = sorted(a)
if b == ['5','5','7']:
print('YES')
else:
print('NO') | p04043 |
print((["NO","YES"][eval(input().replace(" ","*"))==175])) | a,b,c=list(map(str,input().split()))
s=a+b+c
if s.count("5")==2 and s.count("7")==1:
print("YES")
else:
print("NO") | p04043 |
a,b,c = list(map(int, input().split()))
print(('YES' if a+b+c==17 else 'NO')) | a = [int(_) for _ in input().split()]
a.sort()
print(('YES' if a[0]==a[1]==5 and a[2]==7 else 'NO')) | p04043 |
a,b,c=sorted(map(int,input().split()))
print((["NO","YES"][a==b==5 and c==7])) | a,b,c=sorted(input().split())
print((["NO","YES"][a==b=="5" and c=="7"])) | p04043 |
#ABC42 A
#リストで書いた場合
myList=[]
myList_int=[]
myList=input().split() #split()でリストに入力をstrで入れる
myList_int=[int(s) for s in myList] #intに変換
#print(myList)
if myList_int== [7,5,5]:
print("YES")
elif myList_int== [5,7,5] :
print("YES")
elif myList_int== [5,5,7] :
print("YES")
else:
print("NO") | myList=[]
myList_int=[]
myList=input().split() #split()でリストに入力をstrで入れる
myList_int=[int(s) for s in myList] #intに変換
#print(myList)
if myList_int== [7,5,5]:
print("YES")
elif myList_int== [5,7,5] :
print("YES")
elif myList_int== [5,5,7] :
print("YES")
else:
print("NO") | p04043 |
ABC=list(map(int,input().split()))
print(("YES" if ABC.count(5)==2 and ABC.count(7)==1 else "NO"))
| ABC=input().split()
if ABC.count("5")==2 and ABC.count("7")==1:
print("YES")
else:
print("NO")
| p04043 |
# -*- coding: utf-8 -*-
if __name__ == "__main__":
# str_list = [map(int, input().split())]
# if str_list.count(5) == 2 and str_list.count(7) == 1:
# print('YES')
# else:
# print('NO')
str_list = list(map(int, input().split()))
if sum(str_list) == 17:
print('YES')
else:
print('NO')
| # -*- coding: utf-8 -*-
if __name__ == "__main__":
str_list = list(map(int, input().split()))
if sum(str_list) == 17:
print('YES')
else:
print('NO')
| p04043 |
# ABC158 A
def main():
list = input().split()
list.sort()
if ''.join(list) == '557':
print('YES')
else:
print('NO')
if __name__ == '__main__':
main()
| def main():
list = input().split()
list.sort()
if ''.join(list) == '557':
print('YES')
else:
print('NO')
if __name__ == '__main__':
main()
| p04043 |
List=list(map(int,input().split()))
print(('YES' if List.count(7)==1 and List.count(5)==2 else 'NO')) | l=list(input().split())
print(('YES' if l.count('5')==2 and l.count('7')==1 else 'NO')) | p04043 |
l = list(input().split())
five = 0
seven = 0
for i in l:
if i == '5':
five += 1
elif i == '7':
seven += 1
else:
pass
if five == 2 and seven == 1:
print('YES')
else:
print('NO') | l = list(map(int, input().split()))
print((['NO', 'YES'][l.count(5) == 2 and l.count(7) == 1])) | p04043 |
import sys
a=list(map(int,input().split()))
s=0
f=0
for i in range(3):
s+=a[i]
if s!=17:
print('NO')
sys.exit()
else:
for t in range(3):
if a[t]==5:
f+=1
if f==2:
print('YES')
else:
print('NO')
| a=list(map(int,input().split()))
b=a[0]+a[1]+a[2]
c=a[2]-a[1]-a[0]
if b==17 and (c==-7 or c==-3):
print('YES')
else:
print('NO')
| p04043 |
def slove():
import sys, collections
input = sys.stdin.readline
a = dict(collections.Counter(list(map(int, input().rstrip('\n').split()))).most_common())
print(("YES" if a[5] == 2 and a[7] == 1 else "NO"))
if __name__ == '__main__':
slove()
| def slove():
import sys
input = sys.stdin.readline
a = "".join(sorted(list(map(str, str(input().rstrip('\n')).split()))))
print(("YES" if a == "557" else "NO"))
if __name__ == '__main__':
slove()
| p04043 |
S = list(map(int, input().split()))
S.sort()
if S[0] == 5 and S[1] == 5 and S[2] == 7:
print("YES")
else:
print("NO") | L = list(map(int, input().split()))
L.sort()
if L[0]==5 and L[1]==5 and L[2] == 7:
print("YES")
else:
print("NO") | p04043 |
import math
import queue
import bisect
import heapq
import time
import itertools
mod = int(1e9+7)
def swap(a,b):
return (b,a)
def gcd(a,b): #最大公約数
if (a<b):
a,b = swap(a,b)
if (b==0):
return a
else:
return gcd(b,a%b)
def divisors(a): # 約数列挙
divisors = []
for i in range(1,int(a**0.5)+1):
if a%i==0:
divisors.append(i)
if i!=a//i:
divisors.append(a//i)
return divisors
def is_prime(a): #素数判定
if a<2:
return False
elif a==2:
return True
elif a%2==0:
return False
sqrt_num = int(a**0.5)
for i in range(3,sqrt_num+1,2):
if a%i==0:
return False
return True
def prime_num(a): #素数列挙
pn = [2]
for i in range(3,int(a**0.5),2):
prime = True
for j in pn:
if i%j==0:
prime = False
break
if prime:
pn.append(i)
return pn
def main():
x = [y for y in map(int,input().split())]
x.sort()
f = 0
s = 0
for i in x:
if i == 5:
f += 1
elif i == 7:
s += 1
else:
print("NO")
return
if f==2 and s==1:
print("YES")
else:
print("NO")
return
if __name__=='__main__':
main()
| # import math
# import decimal
# import queue
# import bisect
# import heapq
# import time
# import itertools
mod = int(1e9+7)
class Library():
@staticmethod
def Swap(a,b):
return [b,a]
@staticmethod
def myRound(a,dig=0): # 四捨五入
# dig => 桁数
# dig = 1 => 10の位
# dig = -1 => 小数第一位
p = 10 ** dig
return (a * p * 2 + 1) // 2 / p
@staticmethod
def Roundup(a): # 切り上げ
if a < 0:
return int(a)
else:
return int(a + 0.9)
# 整数の切り上げ => (a + b - 1) // b
@staticmethod
def Gcd(a,b): #最大公約数
if (a<b):
a,b = Library.Swap(a,b)
if (b==0):
return a
else:
return Library.Gcd(b,a%b)
@staticmethod
def Lcm(a,b): #最小公倍数
return a//Library.Gcd(a,b)*b
@staticmethod
def Divisors(a): # 約数列挙
divisors = []
for i in range(1,int(a**0.5)+1):
if a%i==0:
divisors.append(i)
if i!=a//i:
divisors.append(a//i)
divisors.sort()
return divisors
class Prime():
# コンストラクタ
# エラストテネスの篩
def __init__(self,num):
self.num = num
self.sieve = [0] * (self.num + 1)
self.sieve[0] = -1
self.sieve[1] = -1
for i in range(2,self.num + 1):
if not self.sieve[i]:
self.sieve[i] = i
for j in range(i * i,self.num + 1,i):
if self.sieve[j]:
self.sieve[j] = i
# 素数判定
def isPrime(self,num = None):
if num is None:
num = self.num
if self.sieve[num] == num:
return True
else:
return False
# 素数列挙
def PrimeNum(self,num = None):
if num is None:
num = self.num
prime = []
for i in range(2,num):
if self.sieve[i] == i:
prime.append(i)
return prime
# 素因数分解
def PrimeFact(self,num = None):
if num is None:
num = self.num
fact = []
while self.sieve[num] != num:
fact.append(self.sieve[num])
num //= self.sieve[num]
fact.append(num)
return fact
def main():
abc = list(map(int,input().split()))
abc.sort()
if abc[0] == 5 and abc[1] == 5 and abc[2] == 7:
print('YES')
else:
print('NO')
return
if __name__=='__main__':
main()
| p04043 |
ABC = list(map(int, input().split()))
if ABC.count(5) == 2 and ABC.count(7):
print('YES')
else:
print('NO') | ABC = list(map(int, input().split()))
if ABC.count(5) == 2 and ABC.count(7) == 1:
print('YES')
else:
print('NO') | p04043 |
l = list(map(int, input().split()))
l.sort(reverse=True)
if l[0] == 7 and l[1] == 5 and l[2] == 5:
print('YES')
else:
print('NO') | a = list(map(int, input().split()))
cnt_5 = 0
cnt_7 = 0
for i in a:
if i == 5:
cnt_5 += 1
if i == 7:
cnt_7 += 1
if cnt_5 == 2 and cnt_7 == 1:
print('YES')
else:
print('NO') | p04043 |
go=0
nana=0
num = input().split()
for i in num:
if i == "5":
go+=1
if i == "7":
nana+=1
if (go==2) and (nana==1):
print("YES")
else:
print("NO") | num = input().split()
go = 0
nana = 0
for i in num:
if i == "5":
go+=1
if i == "7":
nana+=1
if (go==2) and (nana==1):
print("YES")
else:
print("NO")
| p04043 |
input1 = list(map(int,input().split()))
A = input1[0]
B = input1[1]
C = input1[2]
if A == 5:
if B == 5 and C == 7:
print("YES")
elif B == 7 and C == 5:
print("YES")
else:
print("NO")
elif A == 7:
if B == 5 and C == 5:
print("YES")
else:
print("NO")
else:
print("NO") | a,b,c=list(map(int,input().split()))
print(("YES" if a*b*c==175 else "NO")) | p04043 |
a,b,c=list(map(int, input().split()))
if a==5 and b==5 and c==7:
print('YES')
elif a==5 and b==7 and c==5:
print('YES')
elif a==7 and b==5 and c==5:
print('YES')
else:
print('NO') | myList = list(map(int, input().split()))
if myList.count(5)==2 and myList.count(7)==1:
print('YES')
else:
print('NO') | p04043 |
A = sorted([int(i) for i in input().split()])
print(('YES' if A == [5, 5, 7] else 'NO')) | A = sorted(input().split())
print(('YES' if A == ['5', '5', '7'] else 'NO')) | p04043 |
l = input().split()
print(("YES" if sorted(l) == ['5', '5', '7'] else "NO")) | l = list(map(int, input().split()))
print(("YES" if sorted(l) == [5, 5, 7] else "NO")) | p04043 |
N,A,B,C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
ans = float('inf')
for i in range(1<<N):
for j in range(1<<N):
a,b,c = [],[],[]
cost = 0
for keta in range(N):
bit_i = i&(1<<keta)
bit_j = j&(1<<keta)
if bit_i==0 and bit_j==0:
a.append(keta)
elif bit_i==0 and bit_j>0:
b.append(keta)
elif bit_i>0 and bit_j==0:
c.append(keta)
else:
pass
if a==[] or b==[] or c==[]:
continue
cost += 10*(len(a)+len(b)+len(c)-3)
for l,val in zip([a,b,c],
[A,B,C]):
s = sum([L[li] for li in l])
cost += abs(s-val)
ans = min(ans, cost)
print(ans)
| from itertools import product
N,A,B,C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
ans = float('inf')
for p in product(list(range(4)), repeat=N): # 4^Nループ
take = [[] for _ in range(4)] # [A,B,C,使わない]
for i in range(N):
take[p[i]].append(L[i])
a,b,c = take[0],take[1],take[2]
if len(a)*len(b)*len(c)==0:
continue
cost = (len(a)+len(b)+len(c)-3)*10
cost += abs(sum(a)-A)+abs(sum(b)-B)+abs(sum(c)-C)
ans = min(ans, cost)
print(ans) | p03111 |
# 8重for
# N,A,B,C = 5,100,90,80
# L = [98,40,30,21,80]
N,A,B,C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
ans = float('inf')
for i1 in range(4):
for i2 in range(4):
for i3 in range(4):
for i4 in range(4):
for i5 in range(4):
for i6 in range(4):
for i7 in range(4):
for i8 in range(4):
p = [i1,i2,i3,i4,i5,i6,i7,i8]
take = [[] for _ in range(4)] # [A,B,C,使わない]
for i in range(N):
take[p[i]].append(L[i])
a,b,c = take[0],take[1],take[2]
if len(a)*len(b)*len(c)==0:
continue
cost = (len(a)+len(b)+len(c)-3)*10
cost += abs(sum(a)-A)+abs(sum(b)-B)+abs(sum(c)-C)
ans = min(ans, cost)
print(ans) | # DFS
# N,A,B,C = 5,100,90,80
# L = [98,40,30,21,80]
N,A,B,C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
ans = float('inf')
def dfs(cur,a,b,c)->int:
if cur==N:
if min(a,b,c)>0: return abs(a-A)+abs(b-B)+abs(c-C)-30
else: return float('inf')
ret0 = dfs(cur+1, a, b, c)
ret1 = dfs(cur+1, a+L[cur],b, c) + 10
ret2 = dfs(cur+1, a, b+L[cur],c) + 10
ret3 = dfs(cur+1, a, b, c+L[cur]) + 10
return min(ret0, ret1, ret2, ret3)
print((dfs(0,0,0,0))) | p03111 |
n, a, b, c = list(map(int, input().split()))
l = []
for _ in range(n):
l.append(int(eval(input())))
def dfs(depth, t, ans):
if depth == n:
sum = calc(t)
if sum < ans:
return sum
else:
return ans
for j in range(4):
tt = t.copy()
tt.append(j)
ans = dfs(depth + 1, tt, ans)
return ans
def calc(t):
ttt = [ [0, 0] ] * 3
for i, v in enumerate(t):
if v < 3:
ttt[v] = [ttt[v][0] + 1, ttt[v][1] + l[i]]
if ttt[0][0] == 0 or ttt[1][0] == 0 or ttt[2][0] == 0:
return 1000000000
sum = 0
abc = [a, b, c, 0]
for i, v in enumerate(ttt):
sum += ((v[0] - 1) * 10) + abs(v[1] - abc[i])
return sum
ans = dfs(0, [], 1000000000)
print(ans) | N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
INF = 10**12
def dfs(depth, a, b, c):
if depth == N:
return abs(A - a) + abs(B - b) + abs(C - c) - 30 if min(a, b, c) > 0 else INF
res1 = dfs(depth + 1, a, b, c)
res2 = dfs(depth + 1, a + l[depth], b, c) + 10
res3 = dfs(depth + 1, a, b + l[depth], c) + 10
res4 = dfs(depth + 1, a, b, c + l[depth]) + 10
return min(res1, res2, res3, res4)
print((dfs(0, 0, 0, 0))) | p03111 |
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
def solve(X):
if not ("1" in X and "2" in X and "3" in X):
return 1e10
MS = [[L[i] for i in range(N) if X[i] == j] for j in "123"]
ret = 1e10
ret = min(ret, solve2(MS[0], A) + solve2(MS[1], B) + solve2(MS[2], C))
ret = min(ret, solve2(MS[0], A) + solve2(MS[2], B) + solve2(MS[1], C))
ret = min(ret, solve2(MS[1], A) + solve2(MS[0], B) + solve2(MS[2], C))
ret = min(ret, solve2(MS[1], A) + solve2(MS[2], B) + solve2(MS[0], C))
ret = min(ret, solve2(MS[2], A) + solve2(MS[0], B) + solve2(MS[1], C))
ret = min(ret, solve2(MS[2], A) + solve2(MS[1], B) + solve2(MS[0], C))
return ret
def solve2(M, target):
def rec(Y, target):
# Y: [1, 0, 0]
if len(Y) == len(M):
if len(set(Y)) == 1 and Y[0] == 0:
return 1e10
sum_M = sum([M[i] for i in range(len(M)) if Y[i] == 1])
return abs(target - sum_M) + 10 * (Y.count(1) - 1)
return min(rec(Y + [0], target), rec(Y + [1], target))
ret = rec([], target)
return ret
ans = 1e10
def rec(X):
global ans
if len(X) == N:
ans = min(ans, solve(X))
return
rec(X + "1")
rec(X + "2")
rec(X + "3")
rec("")
print(ans)
| N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
def solve(X):
if not ("1" in X and "2" in X and "3" in X):
return 1e10
MS = [[L[i] for i in range(N) if X[i] == j] for j in "123"]
ret = 1e10
A_ans = []
B_ans = []
C_ans = []
for i in range(3):
A_ans.append(solve2(MS[i], A))
B_ans.append(solve2(MS[i], B))
C_ans.append(solve2(MS[i], C))
ret = min(ret, A_ans[0] + B_ans[1] + C_ans[2])
ret = min(ret, A_ans[0] + B_ans[2] + C_ans[1])
ret = min(ret, A_ans[1] + B_ans[0] + C_ans[2])
ret = min(ret, A_ans[1] + B_ans[2] + C_ans[0])
ret = min(ret, A_ans[2] + B_ans[0] + C_ans[1])
ret = min(ret, A_ans[2] + B_ans[1] + C_ans[0])
return ret
def solve2(M, target):
def rec(Y, target):
# Y: [1, 0, 0]
if len(Y) == len(M):
if len(set(Y)) == 1 and Y[0] == 0:
return 1e10
sum_M = sum([M[i] for i in range(len(M)) if Y[i] == 1])
return abs(target - sum_M) + 10 * (Y.count(1) - 1)
return min(rec(Y + [0], target), rec(Y + [1], target))
ret = rec([], target)
return ret
ans = 1e10
def rec(X):
global ans
if len(X) == N:
ans = min(ans, solve(X))
return
rec(X + "1")
rec(X + "2")
rec(X + "3")
rec("")
print(ans)
| p03111 |
n,a,b,c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
answer = a+b+c
def Base_10_to_n(X, n):
if (int(X/n)):
return Base_10_to_n(int(X/n), n)+str(X%n)
return str(X%n)
for i in range(1, 4**n):
aa = []
bb = []
cc = []
four = list(str(Base_10_to_n(i,4).zfill(n)))
if four.count("1")==0 or four.count("2")==0 or four.count("3") ==0:
continue
for index,f in enumerate(four) :
if f == "0": #使わない
continue
elif f == "1":
aa.append(l[index])
elif f == "2":
bb.append(l[index])
elif f == "3":
cc.append(l[index])
else:
break
cur = (len(aa)-1)*10+abs(a-sum(aa))+(len(bb)-1)*10+abs(b-sum(bb))+(len(cc)-1)*10+abs(c-sum(cc))
answer = min(answer, cur)
print(answer)
| #!/usr/bin/env python3
import sys
import itertools
def solve(N: int, A: int, B: int, C: int, l: "List[int]"):
# 0: 使わない 1:A 2:B 3:C
all = list(itertools.product([0,1,2,3], repeat=N))
answer = 10**9
for a in all:
a_sum = 0
a_count = 0
b_sum = 0
b_count = 0
c_sum = 0
c_count = 0
for i in range(len(a)):
if a[i] == 0:
continue
elif a[i] == 1:
a_sum += l[i]
a_count +=1
elif a[i] == 2:
b_sum += l[i]
b_count +=1
elif a[i] == 3:
c_sum += l[i]
c_count +=1
if a_count == 0 or b_count == 0 or c_count==0 :
continue
MP = (a_count-1)*10+(b_count-1)*10+(c_count-1)*10+abs(A-a_sum)+abs(B-b_sum)+abs(C-c_sum)
answer = min(MP,answer)
print(answer)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
C = int(next(tokens)) # type: int
l = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A, B, C, l)
if __name__ == '__main__':
main()
| p03111 |
def main():
#入力をとる
n,a,b,c = list(map(int,input().split()))
moto = [int(eval(input())) for i in range(n)]
take = []
take.append(a)
take.append(b)
take.append(c)
mp = 10000000000
pt= []
#全探索
for i in range(2**(2*n)):
pt = []
for j in range(n):
if (i >> j*2)&1:
if (i >> j*2+1)&1:
pt.append(3)
else:
pt.append(1)
else:
if (i >> j*2+1)&1:
pt.append(2)
else:
pt.append(0)
#keisan
mp_tmp = 0
all_used = True
for k in range(3):
if pt.count(k) == 0:
all_used = False
break
sum_tmp = 0
mp_tmp += (pt.count(k) - 1)*10
for l in range(n):
if pt[l] == k:
sum_tmp += moto[l]
mp_tmp += abs(sum_tmp-take[k])
if all_used == True:
mp = min(mp_tmp, mp)
print(mp)
main() | minmp = 10000000
def dfs(depth, pt):
if depth==n:
mp_tmp = 0
all_used = True
for k in range(3):
if pt.count(k) == 0:
all_used = False
break
sum_tmp = 0
mp_tmp += (pt.count(k) - 1)*10
for l in range(n):
if pt[l] == k:
sum_tmp += moto[l]
mp_tmp += abs(sum_tmp-take[k])
if all_used == True:
global minmp
minmp = min(minmp,mp_tmp)
return
else:
return
for i in range(4):
pt[depth] = i
dfs(depth+1, pt)
return
#入力をとる
n,a,b,c = list(map(int,input().split()))
moto = [int(eval(input())) for i in range(n)]
take = []
take.append(a)
take.append(b)
take.append(c)
pt = [3]*n
for i in range(n):
dfs(i,pt)
print(minmp) | p03111 |
N,A,B,C = list(map(int, input().split()))
bamboos = [int(eval(input())) for _ in range(N)]
#print("---", bamboos)
ans = float("inf")
def solve(lst, idx):
global ans
if idx == N:
#print("qqqqq")
for i in range(3):
if len(lst[i]) == 0:
return
pa = 10 * (len(lst[0])-1) + abs(A - sum(lst[0]))
pb = 10 * (len(lst[1])-1) + abs(B - sum(lst[1]))
pc = 10 * (len(lst[2])-1) + abs(C - sum(lst[2]))
#print(pa, pb, pc, lst)
ans = min(ans, pa + pb + pc)
#print("aaaaaaa")
return
for i in range(4):
nxt_lst = [lst[0][:], lst[1][:], lst[2][:], lst[3][:]]
nxt_lst[i].append(bamboos[idx])
#print(lst, nxt_lst)
solve(nxt_lst, idx+1)
empty_lst = [[], [], [], []]
solve(empty_lst, 0)
print(ans) |
N,A,B,C = list(map(int, input().split()))
bamboos = [int(eval(input())) for _ in range(N)]
#print("---", bamboos)
INF = float("inf")
ans = INF
def solve(idx, cnt_merge, a, b, c):
if idx == N:
if min(a,b,c) > 0:
return abs(A - a) + abs(B - b) + abs(C - c) + 10 * (cnt_merge-3)
else:
return INF
pa = solve(idx+1, cnt_merge+1, a+bamboos[idx], b, c)
pb = solve(idx+1, cnt_merge+1, a, b+bamboos[idx], c)
pc = solve(idx+1, cnt_merge+1, a, b, c+bamboos[idx])
pn = solve(idx+1, cnt_merge, a, b, c)
return min(pa, pb, pc, pn)
print((solve(0,0,0,0,0))) | p03111 |
N, A, B, C = list(map(int, input().split()))
bamboos = []
for _ in range(N):
l = int(eval(input()))
bamboos.append(l)
ABC = [A, B, C]
import itertools
import sys
ans = sys.maxsize
executed = set()
for i in range(3, N+1):
for bamboos_rearranged in itertools.permutations(bamboos, i):
execute = ','.join(map(str,bamboos_rearranged))
if execute in executed:
continue
else:
executed.add(execute)
#print(bamboos_rearranged)
for j in range(1, len(bamboos_rearranged)):
for k in range(j+1, len(bamboos_rearranged)):
bamboos_abc = (bamboos_rearranged[:j], bamboos_rearranged[j:k], bamboos_rearranged[k:])
cost = 0
flag = True
for n, b in enumerate(bamboos_abc):
cost += (len(b) - 1) * 10
cost += abs(ABC[n] - sum(b))
if cost >= ans:
flag = False
break
if flag == True:
ans = min(ans, cost)
print(ans)
| N, A, B, C = list(map(int, input().split()))
bamboos = []
for _ in range(N):
l = int(eval(input()))
bamboos.append(l)
import copy
def dfs(i, bs):
if i == len(bamboos):
#print(bs)
if not bs['A'] or not bs['B'] or not bs['C']:
return []
return [bs]
ret = []
tmp = copy.deepcopy(bs)
tmp['A'].append(bamboos[i])
ret.extend(dfs(i+1, tmp))
tmp = copy.deepcopy(bs)
tmp['B'].append(bamboos[i])
ret.extend(dfs(i+1, tmp))
tmp = copy.deepcopy(bs)
tmp['C'].append(bamboos[i])
ret.extend(dfs(i+1, tmp))
tmp = copy.deepcopy(bs)
tmp['D'].append(bamboos[i])
ret.extend(dfs(i+1, tmp))
return ret
ABC = {'A': A, 'B': B, 'C': C}
bs_comb = dfs(0, {'A':[],'B':[],'C':[],'D':[]})
import sys
ans = sys.maxsize
for bs in bs_comb:
cost = 0
for abc in ['A', 'B', 'C']:
cost += (len(bs[abc]) - 1) * 10
cost += abs(sum(bs[abc]) - ABC[abc])
ans = min(ans, cost)
print(ans)
| p03111 |
import itertools
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for n in range(N)]
P = []
for n in range(1, N + 1):
P.extend(itertools.combinations([n for n in range(N)], n))
add_len = {s: sum(L[i] for i in s) for s in P}
def cost(v, s):
return 10 * (len(s) - 1) + abs(v - add_len[s])
res = 2 << 30
for a in P:
cost_a = cost(A, a)
if res < cost_a:
continue
for b in P:
cost_b = cost(B, b)
if res < cost_b:
continue
if len(set(a) & set(b)):
continue
for c in P:
cost_c = cost(C, c)
if res < cost_c:
continue
if len(set(a) & set(c)) or len(set(b) & set(c)):
continue
res = min(res, cost_a + cost_b + cost_c)
print(res)
| import itertools
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for n in range(N)]
P = []
for n in range(1, N + 1):
P.extend(itertools.combinations([n for n in range(N)], n))
add_len = {s: sum(L[i] for i in s) for s in P}
def cost(v, s):
return 10 * (len(s) - 1) + abs(v - add_len[s])
res = 2 << 30
for a in P:
cost_a = cost(A, a)
if res < cost_a:
continue
for b in P:
cost_b = cost(B, b)
if res < cost_b:
continue
set_a = set(a)
set_b = set(b)
if len(set_a & set_b):
continue
for c in P:
cost_c = cost(C, c)
if res < cost_c:
continue
set_c = set(c)
if len(set_a & set_c) or len(set_b & set_c):
continue
res = min(res, cost_a + cost_b + cost_c)
print(res)
| p03111 |
from itertools import permutations
def main():
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
# full search
ans = 10**9
for perm in permutations(l):
cost = -30
for i in range(1, n-1):
cost1 = cost + 10 * len(perm[:i]) + abs(a - sum(perm[:i]))
for j in range(i+1, n):
cost2 = cost1 + 10 * len(perm[i:j]) + abs(b - sum(perm[i:j]))
for k in range(j+1, n+1):
cost3 = cost2 + 10 * len(perm[j:k]) + abs(c - sum(perm[j:k]))
if cost3 < ans:
ans = cost3
print(ans)
main() | from itertools import product
from sys import stdin
input = stdin.buffer.readline
def main():
n, *abc = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
ans = 10**9
for prod in product([0, 1, 2, 3], repeat=n):
cost = 10 * (n-3)
lengths = [0, 0, 0]
for i, x in enumerate(prod):
if x < 3:
lengths[x] += l[i]
else:
cost -= 10
for i in lengths:
if i == 0:
break
else:
for i, x in enumerate(abc):
cost += abs(x - lengths[i])
if cost < ans:
ans = cost
print(ans)
main() | p03111 |
n,a,b,c = list(map(int,input().split()))
L = [int(eval(input())) for i in range(n)]
MP = []
for i in range(4**n):
i_bit = bin(i)[2:].zfill(2*n)
co_a = 0
co_b = 0
co_c = 0
p_a = 0
p_b = 0
p_c = 0
for j in range(n):
if i_bit[-1-2*j:-3-2*j:-1] == '00':
co_a += L[j]
p_a += 1
elif i_bit[-1-2*j:-3-2*j:-1] == '01':
co_b += L[j]
p_b += 1
elif i_bit[-1-2*j:-3-2*j:-1] == '10':
co_c += L[j]
p_c += 1
else:
continue
if co_a*co_b*co_c!=0 and p_a<=a and p_b<=b and p_c<=c:
MP += [10*(p_a+p_b+p_c-3)+abs(a-co_a)+abs(b-co_b)+abs(c-co_c)]
print((min(MP))) | N,A,B,C = list(map(int,input().split()))
L = [int(eval(input())) for _ in range(N)]
minmp = 10**18
for i in range(4**N):
mp = 0
a = []
b = []
c = []
d = []
for j in range(N):
if i>>(2*j) & 1:
if i>>(2*j+1) & 1:
a.append(j)
else:
b.append(j)
else:
if i>>(2*j+1) & 1:
c.append(j)
else:
d.append(j)
if not a or not b or not c:
continue
mp += (len(a)-1)*10
mp += abs(A-sum([L[j] for j in a]))
mp += (len(b)-1)*10
mp += abs(B-sum([L[j] for j in b]))
mp += (len(c)-1)*10
mp += abs(C-sum([L[j] for j in c]))
minmp = min(mp,minmp)
print(minmp) | p03111 |
# ABC119C - Synthetic Kadomatsu
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for i in range(N)]
INF = float('inf')
def dfs(cursor=0, a=0, b=0, c=0): # cursor:カーソル a,b,c:現在の竹の長さ
if cursor == N: # cursorが最後まで行ったら終了する。
return abs(a - A) + abs(b - B) + abs(c - C) - 30 if min(a, b, c) > 0 else INF
# abs(a - A) + abs(b - B) + abs(c - C) - 30でなぜ 30を減じているのかというと、
# dfs(0,0,0,0)で始まる以上、最初に選ばれるa,b,cを決定する際にもコストが 10増加してしまうからである。
# また、全探索を行う中で、a,b,cの初期値が 0,0,0である以上、a,b,cのどれかが 0のまま終了する場合が存在する。
# この場合はa,b,cに竹が対応してないと言えるため、解にはならない。
# そこで三項演算子を利用して、その場合についてコストをINFとしている
# 以下は4^Nで展開される再起処理となる。
# カーソルの当たっている竹に対して、(A or B or Cに合成する) or (合成しない)の場合に分ける
no_compound_pattern = dfs(cursor + 1, a, b, c)
compound_a_pattern = dfs(cursor + 1, a + L[cursor], b, c) + 10
compound_b_pattern = dfs(cursor + 1, a, b + L[cursor], c) + 10
compound_c_pattern = dfs(cursor + 1, a, b, c + L[cursor]) + 10
# 結果的に以下の値が返るのはそれぞれのパターンのコストが決定されてからなので
# 以下のコードは最終的なコストの最小値
return min(
no_compound_pattern, compound_a_pattern, compound_b_pattern, compound_c_pattern
)
print((dfs())) | n, *goals = list(map(int, input().split()))
bamboos = list(map(int, [input().rstrip() for _ in range(n)]))
def get_best(li, goal):
bam_mp_lis = {0: (-10, tuple())}
li.sort()
for i, v in enumerate(li):
tmp = bam_mp_lis.copy()
for bam, (mp, lis) in list(tmp.items()):
b0 = bam + v
m0 = mp + 10
l0 = lis + (i,)
if b0 not in bam_mp_lis or m0 < bam_mp_lis[b0][0]:
bam_mp_lis[b0] = (m0, l0)
del bam_mp_lis[0]
best = 10 ** 9
for bam, (mp, lis) in list(bam_mp_lis.items()):
cost = mp + abs(goal - bam)
if cost < best:
best = cost
beslis = lis
return best, beslis
ans = 10 ** 9
from itertools import permutations
for junjo in permutations(goals):
tmp = 0
bambooo = bamboos.copy()
for ju in junjo:
if len(bambooo) == 0:
tmp = 10 ** 9
break
be, beli = get_best(bambooo, ju)
beli = sorted(beli, reverse=True)
for beli0 in beli:
del bambooo[beli0]
tmp += be
if tmp < ans:
ans = tmp
print(ans) | p03111 |
import sys
from copy import deepcopy
def input(): return sys.stdin.readline().strip()
"""
この関数、xxxxxxxxxをaaabbbcccやaabbbbbbcみたいに分けるのには使えるけど
abcabcabcみたいに入り混じった場合が出てこないからだめだ。。。
def func(n): # 和がnになるような３つの数字の組を全列挙
arr = []
for i in range(1, n - 1):
for j in range(1, n - i):
arr.append((i, j, (n - i - j)))
return arr
"""
def base10to(n, b):
if (int(n/b)):
return base10to(int(n/b), b) + [n%b]
return [n%b]
def main():
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
"""
どの竹をくっつけるかをビット全探索
"""
ans = 10**100
for n in range(1 << N):
bumboo_num = [i for i in range(N) if n & (1 << i)] # まずは使う竹の選別
l = len(bumboo_num)
for i in range(3 **l): # 各竹をA, B, Cのどれに振り分けるかの3^l通りを試すべきだった
near_a = 0
near_b = 0
near_c = 0
p = 0
q = 0
r = 0
x = base10to(i, 3)
l_x = len(x)
for j in range(l):
if l_x - j - 1 < 0 or x[l_x - j - 1] == 0:
p += 1
near_a += L[bumboo_num[j]]
elif l_x - j - 1 < 0 or x[l_x - j - 1] == 1:
q += 1
near_b += L[bumboo_num[j]]
elif l_x - j - 1 < 0 or x[l_x - j - 1] == 2:
r += 1
near_c += L[bumboo_num[j]]
if p == 0 or q == 0 or r == 0: continue
val = 10 * (p - 1 + q - 1 + r - 1)
val1 = val + abs(A - near_a) + abs(B - near_b) + abs(C - near_c)
#if ans > val1: print("n={}, p={}, q={}, r={}, val={}".format(bin(n)[2:], p, q, r, val1))
ans = min(ans, val1)
val2 = val + abs(A - near_a) + abs(C - near_b) + abs(B - near_c)
#if ans > val2: print("n={}, p={}, q={}, r={}, val={}".format(bin(n)[2:], p, r, q, val2))
ans = min(ans, val2)
val3 = val + abs(B - near_a) + abs(A - near_b) + abs(C - near_c)
#if ans > val3: print("n={}, p={}, q={}, r={}, val={}".format(bin(n)[2:], q, p, r, val3))
ans = min(ans, val3)
val4 = val + abs(B - near_a) + abs(C - near_b) + abs(A - near_c)
#if ans > val4: print("n={}, p={}, q={}, r={}, val={}".format(bin(n)[2:], r, p, q, val4))
ans = min(ans, val4)
val5 = val + abs(C - near_a) + abs(A - near_b) + abs(B - near_c)
#if ans > val5: print("n={}, p={}, q={}, r={}, val={}".format(bin(n)[2:], q, r, p, val5))
ans = min(ans, val5)
val6 = val + abs(C - near_a) + abs(B - near_b) + abs(A - near_c)
#if ans > val6: print("n={}, p={}, q={}, r={}, val={}".format(bin(n)[2:], r, q, p, val6))
ans = min(ans, val6)
print(ans)
if __name__ == "__main__":
main()
| import sys
def input(): return sys.stdin.readline().strip()
def main():
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
"""
解答方針は正しかったが、選んだ竹のA,B,Cへの割り振り方の実装にてこずったので、
潔く模範解答を写経することにする。
こういう全列挙は再帰を使うと超あっさり書けるのは聞いてたけど、まだ実践力が足らぬ。。
再帰を木構造に書き表せたら自然にdfsと結びつくのか！
"""
def dfs(cur, a, b, c):
if cur == N: # 全ての竹をチェックし終わった時
if min(a, b, c) > 0: # a, b, cのどれにもベースの竹が取れている時
return abs(a - A) + abs(b - B) + abs(c - C) - 30 # 最初の0本から1本への合成にはMP10は使わないので最後に引く
else:
return 10**10
ret0 = dfs(cur + 1, a, b, c) # curの竹を使わない時
ret1 = dfs(cur + 1, a + L[cur], b, c) + 10 # curの竹をaに繋いだ時
ret2 = dfs(cur + 1, a, b + L[cur], c) + 10 # curの竹をbに繋いだ時
ret3 = dfs(cur + 1, a, b, c + L[cur]) + 10 # curの竹をcに繋いだ時
return min(ret0, ret1, ret2, ret3)
print((dfs(0, 0, 0, 0)))
if __name__ == "__main__":
main()
| p03111 |
#18:51
n,A,B,C = list(map(int,input().split()))
D = [A,B,C]
l = []
for _ in range(n):
l.append(int(eval(input())))
l.sort(reverse=True)
def nex(time):
for i in range(n-1,-1,-1):
if time[i] < 3:
time[i] += 1
break
else:
time[i] = 0
else:
time = 'over'
return time
#print(nex([0,0,0,0]),nex([0,3,3,3]),nex([3,3,3,3]))
can = []
time = [0 for _ in range(n)]
while time != 'over':
ans = (n-3) * 10
d = [0,0,0]
for i in range(n):
t = time[i]
if t == 3:
ans -= 10
else:
d[t] += l[i]
if all(d[k] != 0 for k in range(3)):
for k in range(3):
ans += abs(D[k] - d[k])
can.append([ans,d])
time = nex(time)
print((min(can,key=lambda x:x[0])[0])) | n,A,B,C = list(map(int,input().split()))
D = [A,B,C]
def nex(time):
for i in range(n):
if time[i] < 3:
time[i] += 1
break
else:
time[i] = 0
else:
time = 'over'
return time
boo = []
for _ in range(n):
boo.append(int(eval(input())))
can = []
time = [0 for _ in range(n)]
while time != 'over':
d = [0,0,0]
tmp = (n-3) * 10
for i in range(n):
if time[i] < 3:
d[time[i]] += boo[i]
else:
tmp -= 10
for k in range(3):
tmp += abs(D[k] - d[k])
if d[0] * d[1] * d[2] != 0:
can.append(tmp)
time = nex(time)
print((min(can))) | p03111 |
n,a,b,c = list(map(int,input().split()))
la = [a,b,c]
lt = [int(eval(input())) for i in range(n)]
import itertools as it
ans = 3000
for p in it.product(list(range(4)),repeat=n):
ll = [0]*4
lc = [0]*4
for i in range(n):
ll[p[i]] += lt[i]
lc[p[i]] += 1
if lc[0]*lc[1]*lc[2] > 0:
mp = 10*(sum(lc[:3])-3) + sum(abs(ll[i]-la[i]) for i in range(3))
ans = min(ans, mp)
print(ans) | import sys
input = sys.stdin.readline
n,a,b,c = list(map(int,input().split()))
la = [a,b,c]
lt = [int(eval(input())) for i in range(n)]
import itertools as it
ans = 3000
for p in it.product(list(range(4)),repeat=n):
ll = [0]*4
lc = [0]*4
for i in range(n):
ll[p[i]] += lt[i]
lc[p[i]] += 1
if lc[0]*lc[1]*lc[2] > 0:
mp = 10*(sum(lc[:3])-3) + sum(abs(ll[i]-la[i]) for i in range(3))
ans = min(ans, mp)
print(ans) | p03111 |
def change_base(n, base):
q = n // base
r = n % base
if q == 0:
return str(r)
return change_base(q, base) + str(r)
N, A, B, C = list(map(int, input().split()))
target = [A, B, C]
l = [int(eval(input())) for _ in range(N)]
ans = float('inf')
for n in range(4**N):
bit = change_base(n, 4)
bit = '0'*(N-len(bit)) + bit
start = [0] * 3
mp = 0
for i in range(N):
for j in range(3):
if bit[i] == str(j):
if start[j] > 0:
mp += 10
start[j] += l[i]
if any(s == 0 for s in start):
continue
for j in range(3):
mp += abs(target[j]-start[j])
ans = min(ans, mp)
print(ans)
| def dfs(i, a, b, c):
if i == N:
return abs(a-A) + abs(b-B) + abs(c-C) - 30 if min(a, b, c) > 0 else float('inf')
mx = dfs(i+1, a, b, c)
ma = dfs(i+1, a+l[i], b, c) + 10
mb = dfs(i+1, a, b+l[i], c) + 10
mc = dfs(i+1, a, b, c+l[i]) + 10
return min(mx, ma, mb, mc)
N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
print((dfs(0, 0, 0, 0)))
| p03111 |
import sys
sys.setrecursionlimit(10**9)
def search(arr,arr2,cost,flag):
global mincost
if cost>mincost:
return 0
if flag==0:
if len(arr2)==0:
ans.add(cost)
if mincost>cost:
mincost=cost
return 0
for i in range(len(arr)):
search(arr[:i]+arr[i+1:],arr2[1:],cost+abs(arr2[0]-arr[i]),0)
else:
if len(arr)>=len(arr2)+1:
for i in range(len(arr)):
for j in range(i+1,len(arr)):
search(arr[:i]+arr[i+1:j]+arr[j+1:]+[arr[i]+arr[j]],arr2,cost+10,0)
search(arr[:i]+arr[i+1:j]+arr[j+1:]+[arr[i]+arr[j]],arr2,cost+10,1)
n,a,b,c=list(map(int,input().split()))
arr=[int(eval(input())) for _ in range(n)]
arr2=[a,b,c]
ans=set()
mincost=10**9
search(arr,arr2,0,0)
search(arr,arr2,0,1)
ans=sorted(list(ans))
print((ans[0])) | import collections
from copy import deepcopy
n,a,b,c=list(map(int,input().split()))
arr=[int(eval(input())) for _ in range(n)]
l=collections.deque()
l.append([[],[],[]])
cnt=0
while 1:
if cnt==n:
break
base=l.popleft()
if len(base[0])==0 and len(base[1])==0 and len(base[2])==0:
l.append([[arr[cnt]],[],[]])
l.append([[],[arr[cnt]],[]])
l.append([[],[],[arr[cnt]]])
l.append([[],[],[]])
cnt+=1
else:
tmp1=deepcopy(base)
tmp1[0].append(arr[cnt])
l.append(tmp1)
tmp2=deepcopy(base)
tmp2[1].append(arr[cnt])
l.append(tmp2)
tmp3=deepcopy(base)
tmp3[2].append(arr[cnt])
l.append(tmp3)
tmp4=deepcopy(base)
l.append(tmp4)
mincost=10**9
for bl in l:
if len(bl[0])==0 or len(bl[1])==0 or len(bl[2])==0:
continue
else:
tmpcost=abs(sum(bl[0])-a)+abs(sum(bl[1])-b)+abs(sum(bl[2])-c)+10*(len(bl[0])-1+len(bl[1])-1+len(bl[2])-1)
if mincost>tmpcost:
mincost=tmpcost
print(mincost)
| p03111 |
import sys
import itertools
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
def main():
N, A, B, C = in_nn()
l = list(map(int, read().rstrip().split()))
comb = list(itertools.product(list(range(4)), repeat=N))
abc_p = list(itertools.permutations([A, B, C], 3))
ans = 10**9 + 7
for abc in abc_p:
for c in comb:
if (0 in c) and (1 in c) and (2 in c):
t = [0] * 3
m = [-10] * 3
for i in range(N):
if c[i] == 3:
continue
t[c[i]] += l[i]
m[c[i]] += 10
for i in range(3):
m[i] += abs(t[i] - abc[i])
ans = min(ans, sum(m))
print(ans)
if __name__ == '__main__':
main()
| import sys
import itertools
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
def main():
N, A, B, C = in_nn()
l = list(map(int, read().rstrip().split()))
comb = list(itertools.product(list(range(4)), repeat=N))
ans = 10**9 + 7
for c in comb:
if (0 in c) and (1 in c) and (2 in c):
t = [0] * 3
m = [-10] * 3
for i in range(N):
if c[i] == 3:
continue
t[c[i]] += l[i]
m[c[i]] += 10
m[0] += abs(t[0] - A)
m[1] += abs(t[1] - B)
m[2] += abs(t[2] - C)
ans = min(ans, sum(m))
print(ans)
if __name__ == '__main__':
main()
| p03111 |
N, A, B, C = list(map(int, input().split(" ")))
l = [int(eval(input())) for i in range(N)]
INF = 10 ** 9
def dfs(cnt, a, b, c):
if cnt == N:
return abs(a-A)+abs(b-B)+abs(c-C)-30 if min(a,b,c)>0 else INF
ret1=dfs(cnt+1,a+l[cnt],b,c)+10
ret2=dfs(cnt+1,a,b+l[cnt],c)+10
ret3=dfs(cnt+1,a,b,c+l[cnt])+10
ret4=dfs(cnt+1,a,b,c)
return min(ret1,ret2,ret3,ret4)
print((dfs(0,0,0,0))) | N,A,B,C = list(map(int, input().split()))
l = [0]*N
for i in range(N):
l[i] = int(eval(input()))
def dfs(i,a,b,c):
if i == N:
if a==0 or b==0 or c==0:
return 100000
else:
return abs(A-a)+abs(B-b)+abs(C-c)-30
else:
return min(dfs(i+1,a+l[i],b,c)+10, dfs(i+1,a,b+l[i],c)+10, dfs(i+1,a,b,c+l[i])+10, dfs(i+1,a,b,c))
print((dfs(0,0,0,0)))
| p03111 |
from collections import deque
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
minMP = 10**5
p = deque()
p.append([-1] * len(L))
while p:
stats = p.pop()
stats = list(stats)
a, b, c = 0, 0, 0
MP = 0
cntA = 0; cntB = 0; cntC = 0
for i in range(N):
if stats[i] == 1:
a += L[i]
cntA += 1
elif stats[i] == 2:
b += L[i]
cntB += 1
elif stats[i] == 3:
c += L[i]
cntC += 1
if cntA >= 1 and cntB >= 1 and cntC >= 1:
MP += abs(A - a) + abs(B - b) + abs(C - c) + 10 * (cntA+cntB+cntC-3)
minMP = min(minMP, MP)
if not -1 in stats:
continue
j = stats.index(-1)
for k in range(4):
stats[j] = k
newStats = tuple(stats)
p.append(newStats)
print(minMP)
| N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
INF = float('inf')
def dfs(cursor=0, a=0, b=0, c=0):
if cursor == N:
return abs(a-A) + abs(b-B) + abs(c-C) - 30 if a*b*c > 0 else INF
no_compound = dfs(cursor+1, a, b, c)
A_compound = dfs(cursor+1, a+L[cursor], b, c) + 10
B_compound = dfs(cursor+1, a, b+L[cursor], c) + 10
C_compound = dfs(cursor+1, a, b, c+L[cursor]) + 10
return min(no_compound, A_compound, B_compound, C_compound)
print((dfs()))
| p03111 |
n, *abc = [int(x) for x in input().split()]
l = [int(eval(input())) for i in range(n)]
A = 0; B = 1; C = 2;
minmp = 10 ** 9
for k in range(2 ** (2 * n)):
mat = [[], [], [], []] # mat[0]:= Aの材料, mat[1]:=Bの材料, mat[2]:=Cの材料
# for i = 0, ..., N-1
# kの 2*i & 2*i+1ビット目が 0b00: l[i]はAに使う
# ↑lsbから 0b01: l[i]はBに使う
# 0b10: l[i]はCに使う
# 0b11: l[i]は使わない
for i in range(n):
mat[(k >> 2 * i) & (0b11)].append(l[i])
if len(mat[0]) == 0 or len(mat[1]) == 0 or len(mat[2]) == 0:
continue
mp = 0
for j in range(3):
mp += 10 * (len(mat[j]) - 1)
mp += 1 * abs(abc[j] - sum(mat[j]))
minmp = min(minmp, mp)
print(minmp) | n, *abc = [int(x) for x in input().split()]
l = [int(eval(input())) for i in range(n)]
A = 0; B = 1; C = 2;
minmp = 10 ** 9
for k in range(2 ** (2 * n)):
mat = [[], [], [], []] # mat[0]:= Aの材料, mat[1]:=Bの材料, mat[2]:=Cの材料
# for i = 0, ..., N-1
# kの 2*i & 2*i+1ビット目が 0b00: l[i]はAに使う
# ↑lsbから 0b01: l[i]はBに使う
# 0b10: l[i]はCに使う
# 0b11: l[i]は使わない
for i in range(n):
mat[k & (0b11)].append(l[i])
k >>= 2
if len(mat[0]) == 0 or len(mat[1]) == 0 or len(mat[2]) == 0:
continue
mp = 0
for j in range(3):
mp += 10 * (len(mat[j]) - 1)
mp += 1 * abs(abc[j] - sum(mat[j]))
minmp = min(minmp, mp)
print(minmp) | p03111 |
from itertools import product
def solve(NUM, LIST):
lst = [l[i] for i, t in enumerate(LIST) if t == NUM]
if len(lst) == 0:
return 10 ** 5
ANS = (len(lst) - 1) * 10
ANS += abs(sum(lst) - tgt[NUM])
return ANS
tgt = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(tgt[0])]
ans = 10 ** 5
for pttn in product([0, 1, 2, 3], repeat=tgt[0]):
tmp = sum(solve(i + 1, pttn) for i in range(3))
ans = min(ans, tmp)
print(ans)
| from itertools import product
def solve(T, PTTN):
lst = [l[i] for i, t in enumerate(PTTN) if t == T]
if lst:
ANS = (len(lst) - 1) * 10
ANS += abs(sum(lst) - tgt[T])
return ANS
return 10 ** 5
tgt = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(tgt[0])]
ans = 10 ** 5
for pttn in product([0, 1, 2, 3], repeat=tgt[0]):
tmp = sum(solve(i + 1, pttn) for i in range(3))
ans = min(ans, tmp)
print(ans)
| p03111 |
def Base_10_to_n(X, n):
if (int(X/n)):
return Base_10_to_n(int(X/n), n)+str(X%n)
return str(X%n)
n,a,b,c=list(map(int,input().split()))
L=[]
for _ in range(n):
L.append(int(eval(input())))
ans=99999
for i in range(4**len(L)):
i_4_list=list(Base_10_to_n(i, 4).zfill(len(L)))
at,bt,ct=[],[],[]
for num,i_4 in enumerate(i_4_list):
if i_4=='0':
at.append(L[num])
elif i_4=='1':
bt.append(L[num])
elif i_4=='2':
ct.append(L[num])
else:
continue
if min(len(at),len(bt),len(ct))>0:
al=0
al+=(len(at)+len(bt)+len(ct)-3)*10
al+=(abs(sum(at)-a)+abs(sum(bt)-b)+abs(sum(ct)-c))
if al < ans:
ans=al
print(ans) | N,A,B,C=list(map(int,input().split()))
L = []
for i in range(N):
L.append(int(eval(input())))
def dfs(n,a,b,c):
if n == N:
if min(a,b,c)>0:
return abs(A-a)+abs(B-b)+abs(C-c)-30
else:
return 10000
root1=dfs(n+1,a+L[n],b,c)+10
root2=dfs(n+1,a,b+L[n],c)+10
root3=dfs(n+1,a,b,c+L[n])+10
root4=dfs(n+1,a,b,c)
return min(root1,root2,root3,root4)
print((dfs(0,0,0,0)))
| p03111 |
import sys
sys.setrecursionlimit(1000000000)
INF=10**9
n,a,b,c=list(map(int,input().split()))
l=[int(eval(input())) for i in range(n)]
def dfs(i,x,y,z,m):
if i==n:
if x>0 and y>0 and z>0:
return abs(x-a)+abs(y-b)+abs(z-c)+m
else:
return INF
ans=INF
if x==0:
ans=min(dfs(i+1,l[i],y,z,m),ans)
else:
ans=min(dfs(i+1,x+l[i],y,z,m+10),ans)
if y==0:
ans=min(dfs(i+1,x,l[i],z,m),ans)
else:
ans=min(dfs(i+1,x,y+l[i],z,m+10),ans)
if z==0:
ans=min(dfs(i+1,x,y,l[i],m),ans)
else:
ans=min(dfs(i+1,x,y,z+l[i],m+10),ans)
return min(ans,dfs(i+1,x,y,z,m))
print((dfs(0,0,0,0,0))) | import sys
sys.setrecursionlimit(1000000000)
INF=10**9
n,a,b,c=list(map(int,input().split()))
l=[int(eval(input())) for i in range(n)]
def dfs(i,x,y,z):
if i==n:
if min(x,y,z)>0:
return abs(x-a)+abs(y-b)+abs(z-c)-30
else:
return INF
ans=dfs(i+1,x,y,z)
ant=dfs(i+1,x+l[i],y,z)+10
anu=dfs(i+1,x,y+l[i],z)+10
anv=dfs(i+1,x,y,z+l[i])+10
return min(ans,ant,anu,anv)
print((dfs(0,0,0,0))) | p03111 |
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
ans = 10**9
for m in range(4**n):
length = [0, 0, 0, 0]
counts = [0, 0, 0, 0]
for d in range(n-1, -1, -1):
i = m//(4**d)
length[i] += l[d]
counts[i] += 1
m %= 4**d
if 0 in length[:3]:
continue
ans_tmp = 0
for i in range(3):
ans_tmp += abs([a,b,c][i] - length[i]) + 10*(counts[i]-1)
ans = min(ans, ans_tmp)
print(ans)
| inf = 10**9
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
def dfs(i, a_cur, b_cur, c_cur):
if i == n:
return abs(a_cur-a) + abs(b_cur-b) + abs(c_cur-c) - 30 if min(a_cur, b_cur, c_cur) > 0 else inf
ans0 = dfs(i+1, a_cur+l[i], b_cur, c_cur) + 10
ans1 = dfs(i+1, a_cur, b_cur+l[i], c_cur) + 10
ans2 = dfs(i+1, a_cur, b_cur, c_cur+l[i]) + 10
ans3 = dfs(i+1, a_cur, b_cur, c_cur)
return min(ans0, ans1, ans2, ans3)
print((dfs(0, 0, 0, 0))) | p03111 |
n,a,b,c,*L = list(map(int,open(0).read().split()))
L.sort(reverse = True)
from itertools import product
from copy import deepcopy
li1 = [4,1,2,3]
ans = 10**10
for v in product(li1,repeat = n):
#print(v)
num = 0
A,B,C,NO = [],[],[],[]
for i in range(n):
if v[i] == 1:
#if L[i] not in (a,b,c):
A.append(L[i])
elif v[i] == 2:
#if L[i] not in (a,b,c):
B.append(L[i])
elif v[i] == 3:
#if L[i] not in (a,b,c):
C.append(L[i])
elif v[i] == 4:
NO.append(L[i])
if A and B and C:
num +=abs(sum(A)-a) + max(0,(len(A)-1)*10) + abs(sum(B)-b) + max(0,(len(B)-1)*10)+ abs(sum(C)-c) + max(0,(len(C)-1)*10)
ans = min(ans,num)
#print(num,ans,A,B,C,max(0,(len(A)-1)*10),max(0,(len(B)-1)*10))
print(ans) | from itertools import product
n,a,b,c,*L = list(map(int,open(0).read().split()))
li1 = [1,2,3,4]
ans = 10**10
for v in product(li1,repeat = n):
num = 0
A,B,C = [],[],[]
for i in range(n):
if v[i] == 1:
A.append(L[i])
elif v[i] == 2:
B.append(L[i])
elif v[i] == 3:
C.append(L[i])
if A and B and C:
num +=abs(sum(A)-a) + max(0,(len(A)-1)*10) + abs(sum(B)-b) + max(0,(len(B)-1)*10)+ abs(sum(C)-c) + max(0,(len(C)-1)*10)
ans = min(ans,num)
print(ans) | p03111 |
N, *ABC = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
#print(min(min(func(l, abc)) for abc in [[A,B,C], [A,C,B], [B,A,C], [B,C,A], [C,A,B], [C,B,A]]))
def func(l, ABC, point=0):
if len(ABC)==0:
yield point
else:
x = ABC[0]
p = min(abs(x-y) for y in l)
if x+p in l:
lc = l.copy()
lc.remove(x+p)
yield from func(lc, ABC[1:], point+p)
if x-p in l:
lc = l.copy()
lc.remove(x-p)
yield from func(lc, ABC[1:], point+p)
from itertools import chain
def func2(l, p, A, B, C):
# for abc in [[A,B,C], [A,C,B], [B,A,C], [B,C,A], [C,A,B], [C,B,A]]:
# print(min(func(l, abc)))
return min(min(func(l, abc, p)) for abc in [[A,B,C], [A,C,B], [B,A,C], [B,C,A], [C,A,B], [C,B,A]])
def grouping(l, g, h, k):
if all(len(x)>0 for x in [g, h, k]):
yield g, h, k
if len(l)>0:
a, *l = l
yield from grouping(l, g+[a], h, k)
yield from grouping(l, g, h+[a], k)
yield from grouping(l, g, h, k+[a])
yield from grouping(l, g, h, k)
def func3(l, ABC):
for g in grouping(l, [], [], []):
p = sum(len(gg)-1 for gg in g)*10
yield func2(list(map(sum, g)), p, *ABC)
print((min(func3(l, ABC)))) | N, *ABC = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
def grouping(l, g, h, k):
if all(len(x)>0 for x in [g, h, k]):
yield g, h, k
if len(l)>0:
a, *l = l
yield from grouping(l, g+[a], h, k)
yield from grouping(l, g, h+[a], k)
yield from grouping(l, g, h, k+[a])
yield from grouping(l, g, h, k)
def func3(l, ABC):
for g in grouping(l, [], [], []):
p = sum(len(gg)-1 for gg in g)*10
l = list(map(sum, g))
yield sum(abs(x-y) for x,y in zip(l,ABC))+p
print((min(func3(l, ABC)))) | p03111 |
import sys
from itertools import product
inf = float('inf')
n, *target = list(map(int, sys.stdin.readline().split()))
target = [None] + target
*l, = list(map(int, sys.stdin.read().split()))
def main():
costs = []
for p in product(list(range(4)), repeat=n):
tmp = [[] for _ in range(4)]
p = list(p)
for i in range(n):
tmp[p[i]].append(l[i])
cost = [0] * 4
for i in range(1, 4):
if not tmp[i]:
break
cost[i] += 10 * (len(tmp[i]) - 1)
cost[i] += abs(target[i] - sum(tmp[i]))
else:
costs.append(sum(cost))
return min(costs)
if __name__ == '__main__':
ans = main()
print(ans) | import sys
from itertools import product
n, *abc = list(map(int, sys.stdin.readline().split()))
*l, = list(map(int, sys.stdin.read().split()))
def main():
cand = []
for p in product([0, 1, 2, 3], repeat=n):
group = [[] for _ in range(4)]
for i in range(n):
group[p[i]].append(l[i])
cost = 0
for i in range(1, 4):
if not group[i]:
break
cost += 10 * (len(group[i]) - 1)
group[i] = sum(group[i])
else:
group = group[1:]
for i in range(3):
cost += abs(abc[i] - group[i])
cand.append(cost)
print((min(cand)))
if __name__ == '__main__':
main() | p03111 |
import sys
from functools import lru_cache
inf = float('inf')
n, A, B, C, *l = list(map(int, sys.stdin.read().split()))
@lru_cache(None)
def cost(a, b, c, cnt, i):
if i == n:
if not (a and b and c): return inf
return abs(A - a) + abs(B - b) + abs(C - c) + 10 * (cnt - 3)
return min(cost(a, b, c, cnt, i+1),
cost(a+l[i], b, c, cnt+1, i+1),
cost(a, b+l[i], c, cnt+1, i+1),
cost(a, b, c+l[i], cnt+1, i+1))
def main():
print((cost(0, 0, 0, 0, 0)))
if __name__ == '__main__':
main() | import sys
inf = float('inf')
n, A, B, C, *l = list(map(int, sys.stdin.read().split()))
def cost(a, b, c, cnt, i):
if i == n:
if not (a and b and c): return inf
return abs(A - a) + abs(B - b) + abs(C - c) + 10 * (cnt - 3)
return min(cost(a, b, c, cnt, i+1),
cost(a+l[i], b, c, cnt+1, i+1),
cost(a, b+l[i], c, cnt+1, i+1),
cost(a, b, c+l[i], cnt+1, i+1))
def main():
print((cost(0, 0, 0, 0, 0)))
if __name__ == '__main__':
main() | p03111 |
import sys
# import bisect
from collections import Counter, deque, defaultdict
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
import itertools
from operator import attrgetter, itemgetter
# import math
# import numpy as np
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, a, b, c = list(map(int, readline().split()))
l = [int(eval(input())) for _ in range(n)]
ans = INF
base_idx = list(itertools.permutations(list(range(n)), r=3))
for bi in base_idx:
bamboo_length = [0] * 3
add_bamboo = list(itertools.product(list(range(4)), repeat=(n-3)))
rem_idx = [i for i in range(n) if i not in bi]
for ai in add_bamboo:
mp = 0
bamboo_length[0] = l[bi[0]]
bamboo_length[1] = l[bi[1]]
bamboo_length[2] = l[bi[2]]
for idx, num in enumerate(ai):
if num != 3:
bamboo_length[num] += l[rem_idx[idx]]
mp += 10
mp += abs(a - bamboo_length[0])
mp += abs(b - bamboo_length[1])
mp += abs(c - bamboo_length[2])
ans = min(mp, ans)
print(ans)
if __name__ == '__main__':
main()
| import sys
# import bisect
# from collections import Counter, deque, defaultdict
# import copy
# from heapq import heappush, heappop, heapify
# from fractions import gcd
import itertools
# from operator import attrgetter, itemgetter
# import math
# import numpy as np
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, a, b, c = list(map(int, readline().split()))
l = [int(eval(input())) for _ in range(n)]
ans = INF
selects = list(itertools.product(list(range(4)), repeat=n))
for select in selects:
mp = -30
bamboo_length = [0] * 3
for i, num in enumerate(select):
if num != 3:
bamboo_length[num] += l[i]
mp += 10
for length in bamboo_length:
if length == 0:
break
else:
mp += abs(a - bamboo_length[0])
mp += abs(b - bamboo_length[1])
mp += abs(c - bamboo_length[2])
ans = min(mp, ans)
print(ans)
if __name__ == '__main__':
main()
| p03111 |
from sys import setrecursionlimit
setrecursionlimit(10 ** 9)
n, a, b, c = [int(i) for i in input().split()]
L = [int(eval(input())) for i in range(n)]
INF = 10 ** 9
def dfs(i, L, A):
if all(a == 0 for a in A):
return 0
if n - L.count(0) < 3:
return INF
if i == n:
return INF
if L[i] == 0:
return dfs(i+1, L[:], A[:])
for j, a in enumerate(A):
if a == L[i]:
A[j] = 0
return dfs(i+1, L[:], A[:])
res = dfs(i+1, L[:], A[:])
for j, a in enumerate(A):
if a == 0:
continue
TL = L[:]
TL[i] = a
TA = A[:]
TA[j] = 0
d = abs(L[i] - a)
res = min(res, dfs(i+1, TL, TA) + d)
if L[i] > max(A):
return res
for j in range(i+1, n):
if L[j] == 0:
continue
TL = L[:]
TL[i] += TL[j]
TL[j] = 0
res = min(res, dfs(i, TL, A[:]) + 10)
return res
print((dfs(0, L[:], [a, b, c]))) | from sys import setrecursionlimit
setrecursionlimit(10 ** 9)
N, A, B, C = [int(i) for i in input().split()]
L = [int(eval(input())) for i in range(N)]
INF = 10 ** 9
def dfs(n, a, b, c):
if n == N:
return abs(a-A) + abs(b-B) + abs(c-C) - 30 if min(a, b, c) > 0 else INF
res = dfs(n+1, a+L[n], b, c) + 10
res = min(res, dfs(n+1, a, b+L[n], c) + 10)
res = min(res, dfs(n+1, a, b, c+L[n]) + 10)
res = min(res, dfs(n+1, a, b, c))
return res
print((dfs(0, 0, 0, 0))) | p03111 |
import sys
sys.setrecursionlimit(10**7)
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
ans = []
def f(i, anum, alen, bnum, blen, cnum, clen):
if i == n:
if alen * blen * clen == 0:
return
mp = abs(anum-a)+10*(alen-1) + abs(bnum-b)+10*(blen-1) + abs(cnum-c)+10*(clen-1)
ans.append(mp)
else:
f(i+1, anum+l[i], alen+1, bnum, blen, cnum, clen)
f(i+1, anum, alen, bnum+l[i], blen+1, cnum, clen)
f(i+1, anum, alen, bnum, blen, cnum+l[i], clen+1)
f(i+1, anum, alen, bnum, blen, cnum, clen)
f(0, 0, 0, 0, 0, 0, 0)
res = float('inf')
for i in ans:
res = min(res, i)
print(res) | import sys
sys.setrecursionlimit(10**7)
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
mp = float('inf')
def f(i, anum, alen, bnum, blen, cnum, clen):
global mp
if i == n:
if alen * blen * clen == 0:
return
mp = min(mp, abs(anum-a)+10*(alen-1) + abs(bnum-b)+10*(blen-1) + abs(cnum-c)+10*(clen-1))
else:
f(i+1, anum+l[i], alen+1, bnum, blen, cnum, clen)
f(i+1, anum, alen, bnum+l[i], blen+1, cnum, clen)
f(i+1, anum, alen, bnum, blen, cnum+l[i], clen+1)
f(i+1, anum, alen, bnum, blen, cnum, clen)
f(0, 0, 0, 0, 0, 0, 0)
print(mp) | p03111 |
N,A,B,C = list(map(int,input().split()))
L = [int(eval(input())) for _ in range(N)]
from itertools import product
ans = float("inf")
for p in product(list(range(4)),repeat=N):
a = [L[i] for i in range(N) if p[i]==1]
b = [L[i] for i in range(N) if p[i]==2]
c = [L[i] for i in range(N) if p[i]==3]
if a==[] or b==[] or c==[]:
continue
t = 0
for x in [a,b,c]:
if len(x)>=2:
t += (len(x)-1)*10
sumA = sum(a)
sumB = sum(b)
sumC = sum(c)
t += abs(A-sumA) + abs(B-sumB) + abs(C-sumC)
ans = min(ans,t)
print(ans) | # Python3 (3.4.3)
import sys
input = sys.stdin.readline
# -------------------------------------------------------------
# function
# -------------------------------------------------------------
# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N,A,B,C = list(map(int,input().split()))
L = [int(eval(input())) for _ in range(N)]
from itertools import product
ans = float("inf")
# 全パターン試す
# 0 : 使わない
# 1,2,3 : A,B,Cとして使う
for p in product(list(range(4)),repeat=N):
a = [L[i] for i in range(N) if p[i]==1]
b = [L[i] for i in range(N) if p[i]==2]
c = [L[i] for i in range(N) if p[i]==3]
if a==[] or b==[] or c==[]:
continue
t = 0
for x in [a,b,c]:
# 複数要素あるなら合成魔法を使って1つに
if len(x)>=2:
t += (len(x)-1)*10
sumA = sum(a)
sumB = sum(b)
sumC = sum(c)
# 目標との差分を 延長魔法or短縮魔法 で埋める
t += abs(A-sumA) + abs(B-sumB) + abs(C-sumC)
ans = min(ans,t)
print(ans) | p03111 |
N,A,B,C = list(map(int,input().split()))
l = [int(eval(input())) for i in range(N)]
INF = 10**9+7
def dfs(count,a,b,c):
if count == N:
if min(a,b,c) > 0:
return abs(a-A)+abs(b-B)+abs(c-C)-30
else:
return INF
non = dfs(count+1,a,b,c)
useA = dfs(count+1,a+l[count],b,c)+10
useB = dfs(count+1,a,b+l[count],c)+10
useC = dfs(count+1,a,b,c+l[count])+10
return min(non,useA,useB,useC)
print((dfs(0,0,0,0))) | N,A,B,C = list(map(int,input().split()))
L = [int(eval(input())) for i in range(N)]
def dfs(cnt,la,lb,lc,cost):
if cnt == N:
if la == 0 or lb == 0 or lc == 0:
return 10**10
else:
return cost+abs(A-la)+abs(B-lb)+abs(C-lc)-30
else:
a = dfs(cnt+1,la+L[cnt],lb,lc,cost+10)
b = dfs(cnt+1,la,lb+L[cnt],lc,cost+10)
c = dfs(cnt+1,la,lb,lc+L[cnt],cost+10)
d = dfs(cnt+1,la,lb,lc,cost)
return min(a,b,c,d)
print((dfs(0,0,0,0,0))) | p03111 |
n,a,b,c = list(map(int,input().split()))
l = [int(eval(input())) for i in range(n)]
def dfs(cnt,A,B,C):
if cnt == n:
if min(A,B,C) == 0:
return float('inf')
else:
return abs(a-A)+abs(b-B)+abs(c-C)-30
else:
ret1 = dfs(cnt+1,A+l[cnt],B,C)+10
ret2 = dfs(cnt+1,A,B+l[cnt],C)+10
ret3 = dfs(cnt+1,A,B,C+l[cnt])+10
ret4 = dfs(cnt+1,A,B,C)
return min(ret1,ret2,ret3,ret4)
print((dfs(0,0,0,0))) | N,A,B,C = list(map(int,input().split()))
L = [int(eval(input())) for i in range(N)]
def dfs(i,la,lb,lc,cost):
if i == N:
if la*lb*lc == 0:
return 10**20
else:
return abs(A-la)+abs(B-lb)+abs(C-lc)-30+cost
ret1 = dfs(i+1,la+L[i],lb,lc,cost+10)
ret2 = dfs(i+1,la,lb+L[i],lc,cost+10)
ret3 = dfs(i+1,la,lb,lc+L[i],cost+10)
ret4 = dfs(i+1,la,lb,lc,cost)
return min(ret1,ret2,ret3,ret4)
print((dfs(0,0,0,0,0))) | p03111 |
N = 0
N, A, B, C = [int(s) for s in input().split()]
bamboos = [int(eval(input())) for _ in range(N)]
def divide(l):
if len(l) == 0:
return []
if len(l) == 1:
return [
[[], [], []], # 使わない
[[l[0]], [], []], # A で使う
[[], [l[0]], []], # B で使う
[[], [], [l[0]]], # C で使う
]
res = []
for a, b, c in divide(l[1:]):
# 使わない
res.append([a, b, c])
# A で使う
res.append([l[0:1] + a, b, c])
# B で使う
res.append([a, l[0:1] + b, c])
# C で使う
res.append([a, b, l[0:1] + c])
return res
min_mp = -1
for a, b, c in divide(bamboos):
al, ac = sum(a), len(a)
bl, bc = sum(b), len(b)
cl, cc = sum(c), len(c)
if al == 0 or bl == 0 or cl == 0:
continue
# 合成に使った魔力
composite = 10 * ((ac - 1) + (bc - 1) + (cc - 1))
# 総合魔力
mp = abs(al - A) + abs(bl - B) + abs(cl - C) + composite
if mp < min_mp or min_mp == -1:
min_mp = mp
print(min_mp)
| N = 0
N, A, B, C = [int(s) for s in input().split()]
bamboos = [int(eval(input())) for _ in range(N)]
# def divide(l):
# if len(l) == 0:
# return []
# if len(l) == 1:
# return [
# [[], [], []], # 使わない
# [[l[0]], [], []], # A で使う
# [[], [l[0]], []], # B で使う
# [[], [], [l[0]]], # C で使う
# ]
# res = []
# for a, b, c in divide(l[1:]):
# # 使わない
# res.append([a, b, c])
# # A で使う
# res.append([l[0:1] + a, b, c])
# # B で使う
# res.append([a, l[0:1] + b, c])
# # C で使う
# res.append([a, b, l[0:1] + c])
# return res
# min_mp = -1
# for a, b, c in divide(bamboos):
# al, ac = sum(a), len(a)
# bl, bc = sum(b), len(b)
# cl, cc = sum(c), len(c)
# if al == 0 or bl == 0 or cl == 0:
# continue
# # 合成に使った魔力
# composite = 10 * ((ac - 1) + (bc - 1) + (cc - 1))
# # 総合魔力
# mp = abs(al - A) + abs(bl - B) + abs(cl - C) + composite
# if mp < min_mp or min_mp == -1:
# min_mp = mp
# print(min_mp)
# ------------------------
# dfs を使うともっと短くかける
# ------------------------
def dfs(l, a, b, c):
global A, B, C
INF = 10**18
if len(l) == 0:
if min(a, b, c) > 0:
return abs(a - A) + abs(b - B) + abs(c - C) - 30
else:
return INF
ret0 = dfs(l[1:], a, b, c) # l[0] を使わない
retA = dfs(l[1:], a + l[0], b, c) + 10 # l[0] を A で使う
retB = dfs(l[1:], a, b + l[0], c) + 10 # l[0] を B で使う
retC = dfs(l[1:], a, b, c + l[0]) + 10 # l[0] を C で使う
return min(ret0, retA, retB, retC)
print((dfs(bamboos, 0, 0, 0)))
| p03111 |
ri = lambda: int(eval(input()))
rl = lambda: list(map(int,input().split()))
N,A,B,C=rl()
l=[0]*N
for i in range(N):
l[i] = ri()
ans = float('inf')
for n in range(4**N):
a,b,c=0,0,0
ans_ = 0
for i in range(N):
sn = format(n>>(2*i),'0{}b'.format(N))[-2:]
if sn=='01':
a+=l[i]
ans_ += 10
elif sn=='10':
b+=l[i]
ans_ += 10
elif sn=='11':
c+=l[i]
ans_ += 10
if a!=0 and b!=0 and c!=0:
ans_ += abs(A-a)+abs(B-b)+abs(C-c) -30
if ans > ans_:
ans = ans_
print(ans) | ri = lambda: int(eval(input()))
rl = lambda: list(map(int,input().split()))
N,A,B,C=rl()
l=[ri() for _ in range(N)]
ans = 10**18
import itertools
for seq in itertools.product(list(range(4)),repeat=N):
a,b,c=0,0,0
rst = 0
for i in range(N):
if seq[i]==1:
a+=l[i]
rst+=10
elif seq[i]==2:
b+=l[i]
rst+=10
elif seq[i]==3:
c+=l[i]
rst+=10
if a*b*c != 0:
rst += abs(A-a)+abs(B-b)+abs(C-c)-30
if ans > rst:
ans = rst
print(ans) | p03111 |
# -*- coding: utf-8 -*-
import itertools
INF = 1e10
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
ans = INF
for prod in itertools.product('NABC', repeat=N):
if not ('A' in prod and 'B' in prod and 'C' in prod):
continue
D = {'A': [], 'B': [], 'C': [], 'N': []}
for i in range(N):
D[prod[i]].append(L[i])
tmp = max(len(D['A']) - 1, 0) * 10 + abs(sum(D['A']) - A)
tmp += max(len(D['B']) - 1, 0) * 10 + abs(sum(D['B']) - B)
tmp += max(len(D['C']) - 1, 0) * 10 + abs(sum(D['C']) - C)
ans = min(ans, tmp)
print(ans)
| # -*- coding: utf-8 -*-
import itertools
INF = 1e10
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
ans = INF
for prod in itertools.product('NABC', repeat=N):
if not ('A' in prod and 'B' in prod and 'C' in prod):
continue
D = {'A': [], 'B': [], 'C': [], 'N': []}
for i in range(N):
D[prod[i]].append(L[i])
tmp = (len(D['A']) - 1) * 10 + abs(sum(D['A']) - A)
tmp += (len(D['B']) - 1) * 10 + abs(sum(D['B']) - B)
tmp += (len(D['C']) - 1) * 10 + abs(sum(D['C']) - C)
ans = min(ans, tmp)
print(ans)
| p03111 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, A, B, C, L):
ans = sys.maxsize
S = (A, B, C, 0)
for l in product([0, 1, 2, 3], repeat=len(L)):
ta = 0
s = [A, B, C, 0]
for i, f in enumerate(l):
if s[f] != S[f] and f != 3:
ta += 10
s[f] -= L[i]
if any([s[i] == S[i] for i in range(3)]):
continue
ta += sum([abs(s[i]) for i in range(3)])
ans = min(ans, ta)
return ans
def main():
# N = read_int()
N, A, B, C = read_int_n()
L = [read_int() for _ in range(N)]
print(slv(N, A, B, C, L))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, A, B, C, L):
ans = sys.maxsize
S = (A, B, C)
for l in product([0, 1, 2, None], repeat=len(L)):
ta = 0
s = [A, B, C]
for i, f in enumerate(l):
if f is None:
continue
if s[f] != S[f]:
ta += 10
s[f] -= L[i]
if any(map(lambda x: x[0] == x[1], zip(s, S))):
continue
ta += sum(map(abs, s))
ans = min(ans, ta)
return ans
def main():
# N = read_int()
N, A, B, C = read_int_n()
L = [read_int() for _ in range(N)]
print(slv(N, A, B, C, L))
if __name__ == '__main__':
main()
| p03111 |
from itertools import product
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
inf=10**16
n,*abc=MI()
ll=[II() for _ in range(n)]
ans=inf
for pp in product(range(4),repeat=n):
ss=[0]*3
cnt=[0]*3
for l,p in zip(ll,pp):
if p==3:continue
ss[p]+=l
cnt[p]+=1
cur=0
for i in range(3):
if cnt[i]==0:
cur=inf
break
cur+=(cnt[i]-1)*10+abs(abc[i]-ss[i])
#print(pp,cur)
ans=min(ans,cur)
print(ans)
main()
| import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def main():
inf=10**9
n,*abc=MI()
abc.sort()
a,b,c=abc
dp={(0,0,0):0}
for _ in range(n):
l=II()
ndp={}
for xyz,s in dp.items():
ndp.setdefault(xyz,inf)
ndp[xyz]=min(ndp[xyz],s)
for i in range(3):
nx=list(xyz)
ns=s+10 if nx[i] else s
nx[i]+=l
t=tuple(sorted(nx))
ndp.setdefault(t,inf)
ndp[t]=min(ndp[t],ns)
dp=ndp
ans=inf
for (x,y,z),s in dp.items():
if x*y*z==0:continue
cur=abs(x-a)+abs(y-b)+abs(z-c)+s
ans=min(ans,cur)
print(ans)
main()
| p03111 |
from itertools import*
n,a,b,c,*l=list(map(int,open(0).read().split()))
d=[a,b,c]
ans=float("inf")
for i in product(list(range(4)),repeat=n):
take=[[],[],[]]
for k,j in enumerate(i): #0を捨てる
if j!=0:
take[j-1].append(l[k])
if all(take):
take2=list(map(sum,take))
#print(sum(abs(s-t)for s,t in zip(d,take2)),(sum(map(len,take))-3)*10)
ans=min(ans,sum(abs(s-t)for s,t in zip(d,take2))+(sum(map(len,take))-3)*10)
print(ans) | from itertools import*
n,a,b,c,*l=list(map(int,open(0).read().split()))
ans=float("inf")
for i in product(list(range(4)),repeat=n): #3を捨てる
take=[[],[],[]]
for k,j in enumerate(i):
if j==3:
continue
take[j].append(l[k])
*tmp,=list(map(len,take))
if all(tmp):
x,y,z=list(map(sum,take))
ans=min(ans, (sum(tmp)-3)*10 + abs(x-a) + abs(y-b) + abs(z-c) )
print(ans) | p03111 |
import itertools
N,A,B,C = list(map(int,input().split()))
comb = [] #0:使用しない,1:竹Aの材料,2:竹Bの材料,3:竹Cの材料
L = []
for i in range(N):
l = int(eval(input()))
L.append(l)
comb.append([0,1,2,3])
All_comb = list(itertools.product(*comb))
min_MP = float('inf')
for i in range(len(All_comb)):
tmp = All_comb[i]
Non_material = []
A_material = []
B_material = []
C_material = []
for j in range(len(tmp)):
if(tmp[j] == 0): Non_material.append(L[j])
elif(tmp[j] == 1): A_material.append(L[j])
elif(tmp[j] == 2): B_material.append(L[j])
elif(tmp[j] == 3): C_material.append(L[j])
a,b,c = len(A_material),len(B_material),len(C_material)
if((a>=1)and(b>=1)and(c>=1)):
sum_A,sum_B,sum_C = sum(A_material),sum(B_material),sum(C_material)
MP = abs(A-sum_A)+abs(B-sum_B)+abs(C-sum_C) +10*(a+b+c-3)
min_MP = min(MP,min_MP)
print(min_MP)
| import itertools
N,A,B,C = list(map(int,input().split()))
Comb = itertools.product([0,1,2,3],repeat=N)
L = []
for i in range(N):
l = int(eval(input()))
L.append(l)
# 各竹について
# 0 : 使用しない
# 1 : 竹Aの材料にする
# 2 : 竹Bの材料にする
# 3 : 竹Cの材料にする
# 竹A,B,Cの作成法 :
# とりあえず全部合成 → 目的の長さに合わせる
ans = float('inf')
for X in Comb:
tmp = 0
m_A,m_B,m_C = [],[],[]
for i in range(N):
if(X[i] == 1): m_A.append(L[i])
elif(X[i] == 2): m_B.append(L[i])
elif(X[i] == 3): m_C.append(L[i])
# 空の竹リストがないなら
if(len(m_A)*len(m_B)*len(m_C) != 0):
for take_list,take_len in zip([m_A,m_B,m_C],[A,B,C]):
tmp += (len(take_list)-1)*10 # 合成
tmp += (abs(take_len-sum(take_list)))*1 # 延長or短縮
ans = min(ans,tmp)
print(ans) | p03111 |
import itertools
n,a,b,c=(list(map(int,input().split())))
l=[int(eval(input())) for i in range(n)]
ans=10**9
for k in itertools.product(list(range(4)),repeat=n):
A=[[] for i in range(4)]
for i in range(n):
A[k[i]]+=[l[i]]
if A[1] and A[2] and A[3]:
tmp=10*(n-len(A[0])-3)
tmp+=abs(a-sum(A[1]))
tmp+=abs(b-sum(A[2]))
tmp+=abs(c-sum(A[3]))
ans=min(tmp,ans)
print(ans) | N,A,B,C=list(map(int,input().split()))
l=[int(eval(input())) for i in range(N)]
inf=10**9
def dfs(cur,a,b,c):
if cur==N:
return abs(a-A)+abs(b-B)+abs(c-C)-30 if min(a,b,c)>0 else inf
ret0 = dfs(cur+1,a,b,c)
ret1 = dfs(cur+1,a+l[cur],b,c)+10
ret2 = dfs(cur+1,a,b+l[cur],c)+10
ret3 = dfs(cur+1,a,b,c+l[cur])+10
return min(ret0,ret1,ret2,ret3)
print((dfs(0,0,0,0))) | p03111 |
n, A, B, C = (int(i) for i in input().split())
l = [int(eval(input())) for i in range(n)]
a = []
b = []
c = []
def furiwake(x):
global a
global b
global c
a = []
b = []
c = []
for i in range(1, n+1):
if dig4(x, i) == 0:
a.append(l[i-1])
if dig4(x, i) == 1:
b.append(l[i-1])
if dig4(x, i) == 2:
c.append(l[i-1])
def dig4(n, k):
return (n%(4**k))//(4**(k-1))
def cost():
costa = 10 * (len(a)-1) + abs(sum(a)-A)
costb = 10 * (len(b)-1) + abs(sum(b)-B)
costc = 10 * (len(c)-1) + abs(sum(c)-C)
return costa+costb+costc
ans = 1000000000
for i in range(1, 4**8):
furiwake(i)
if(len(a)*len(b)*len(c)):
ans = min(ans, cost())
print(ans) | N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for i in range(N)]
INF = 10 ** 9
def dfs(cur, a, b, c):
if cur == N:
return abs(a - A) + abs(b - B) + abs(c - C) - 30 if min(a, b, c) > 0 else INF
ret0 = dfs(cur + 1, a, b, c)
ret1 = dfs(cur + 1, a + l[cur], b, c) + 10
ret2 = dfs(cur + 1, a, b + l[cur], c) + 10
ret3 = dfs(cur + 1, a, b, c + l[cur]) + 10
return min(ret0, ret1, ret2, ret3)
print((dfs(0, 0, 0, 0))) | p03111 |
from itertools import product
from collections import Counter as ct
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
ans = 10 ** 10
for bit in product([0, 1, 2, 3], repeat=n):
if len(set(bit) - {0}) != 3:
continue
tmpa = 0
tmpb = 0
tmpc = 0
for i, j in enumerate(bit):
if j == 1:
tmpa += l[i]
elif j == 2:
tmpb += l[i]
elif j == 3:
tmpc += l[i]
mp = abs(a - tmpa) + abs(b - tmpb) + abs(c - tmpc)
tmp = ct(bit)
for i in range(1, 4):
mp += max(0, tmp[i] - 1) * 10
ans = min(ans, mp)
print(ans) | from itertools import product
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
ans = 10 ** 10
for bit in product([0, 1, 2, 3], repeat=n):
tmp = [0] * 4
mp = 0
for i, j in enumerate(bit):
if j != 3 and tmp[j] != 0:
mp += 10
tmp[j] += l[i]
if any([i == 0 for i in tmp[:3]]):
continue
mp += abs(a - tmp[0]) + abs(b - tmp[1]) + abs(c - tmp[2])
ans = min(ans, mp)
print(ans)
| p03111 |
from itertools import product
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
ans = 10 ** 10
for bit in product([0, 1, 2, 3], repeat=n):
tmp = [0] * 4
mp = 0
for i, j in enumerate(bit):
if j != 3 and tmp[j] != 0:
mp += 10
tmp[j] += l[i]
if any([i == 0 for i in tmp[:3]]):
continue
mp += abs(a - tmp[0]) + abs(b - tmp[1]) + abs(c - tmp[2])
ans = min(ans, mp)
print(ans)
| # dfs版
def dfs(d, A, B, C, f):
global ans
if d == n:
if not 0 in [A, B, C]:
ans = min(ans, abs(a - A) + abs(b - B) + abs(c - C) + f - 30)
return
dfs(d + 1, A, B, C, f)
dfs(d + 1, A + l[d], B, C, f + 10)
dfs(d + 1, A, B + l[d], C, f + 10)
dfs(d + 1, A, B, C + l[d], f + 10)
n, a, b, c = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
ans = 10 ** 10
dfs(0, 0, 0, 0, 0)
print(ans)
| p03111 |
# ABC119C
# Synthetic Kadomatsu
Enter = list(map(int, input().split()))
N = Enter[0]
L = [int(eval(input())) for _ in range(N)]
ans = 10 ** 10
# 4 bist search
for i in range(4**N):
mask = i
NowCost = 0
Group = [[] * 4 for _ in range(4)]
for j in range(N-1, -1, -1):
Group[mask%4].append(L[j])
mask //= 4
if len(Group[0]) == 0 or len(Group[1]) == 0 or len(Group[2]) == 0:
continue
for j in range(3):
NowCost += 10 * (len(Group[j]) - 1)
NowCost += abs(sum(Group[j]) - Enter[j+1])
ans = min(ans, NowCost)
print(ans)
| N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
INF = 10 ** 9
def dfs(cur, a, b, c):
if cur == N:
if min(a, b, c) > 0:
return abs(a-A)+abs(b-B)+abs(c-C)-30
else:
return INF
ret1 = dfs(cur+1, a, b, c)
ret2 = dfs(cur+1, a+L[cur], b, c) + 10
ret3 = dfs(cur+1, a, b+L[cur], c) + 10
ret4 = dfs(cur+1, a, b, c+L[cur]) + 10
return min(ret1, ret2, ret3, ret4)
print((dfs(0,0,0,0)))
| p03111 |
import itertools
n, a, b, c = list(map(int, input().split()))
L = [int(eval(input()))for _ in range(n)]
L_perm = list(itertools.permutations(L))
ans = 10**9
for l in L_perm:
for i in range(1, n-1):
A_tree = l[:i]
synthesis_A = 10 * (i-1)
fix_A = abs(a-sum(A_tree))
for j in range(i+1, n):
B_tree = l[i:j]
synthesis_B = 10 * (j-i-1)
fix_B = abs(b-sum(B_tree))
for k in range(j+1, n+1):
C_tree = l[j:k]
synthesis_C = 10 * (k-j-1)
fix_C = abs(c-sum(C_tree))
total = fix_A + fix_B + fix_C + synthesis_A + synthesis_B + synthesis_C
ans = min(ans, total)
print(ans) | import itertools
N, A, B, C = list(map(int,input().split()))
L = [int(eval(input())) for _ in range(N)]
ans = 10**9
for pattern in itertools.product(list(range(4)), repeat=N):
if not {1, 2, 3} <= set(pattern):
continue
trees = [0] * 3
synthesis_cost = -30
for num, length in zip(pattern, L):
if num == 0:
continue
trees[num-1] += length
synthesis_cost += 10
fix_cost = 0
for tree_length, target_length in zip(trees, [A, B, C]):
fix_cost += abs(target_length - tree_length)
total_cost = synthesis_cost + fix_cost
ans = min(ans, total_cost)
print(ans) | p03111 |
#!/usr/bin/env python3
import sys
INF = 10**9
def dfs(cur, l, ia, ib, ic):
if(cur == N):
return abs(ia-A) + abs(ib-B) + abs(ic-C) - 30 if min(ia,ib,ic) > 0 else INF
ret0 = dfs(cur+1, l, ia, ib, ic)
ret1 = dfs(cur+1, l, ia+l[cur], ib, ic) + 10
ret2 = dfs(cur+1, l, ia, ib+l[cur], ic) + 10
ret3 = dfs(cur+1, l, ia, ib, ic+l[cur]) + 10
return min(ret0, ret1, ret2, ret3)
def solve(N: int, A: int, B: int, C: int, l: "List[int]"):
print((dfs(0,l,0,0,0)))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
global N, A, B, C, l
N = int(next(tokens)) # type: int
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
C = int(next(tokens)) # type: int
l = [ int(next(tokens)) for _ in range(N) ] # type: "List[int]"
solve(N, A, B, C, l)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
INF = 10**9
def dfs(cur, ia, ib, ic):
if(cur == N):
return abs(ia-A) + abs(ib-B) + abs(ic-C) - 30 if min(ia,ib,ic) > 0 else INF
ret0 = dfs(cur+1, ia, ib, ic)
ret1 = dfs(cur+1, ia+l[cur], ib, ic) + 10
ret2 = dfs(cur+1, ia, ib+l[cur], ic) + 10
ret3 = dfs(cur+1, ia, ib, ic+l[cur]) + 10
return min(ret0, ret1, ret2, ret3)
def solve(N: int, A: int, B: int, C: int, l: "List[int]"):
print((dfs(0,0,0,0)))
return
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
global N, A, B, C, l
N = int(next(tokens)) # type: int
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
C = int(next(tokens)) # type: int
l = [ int(next(tokens)) for _ in range(N) ] # type: "List[int]"
solve(N, A, B, C, l)
if __name__ == '__main__':
main()
| p03111 |
n, a, b, c = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(n)]
targets = [a, b, c]
ans = 10**9
from itertools import product
for comb in product([0, 1, 2, 3], repeat=n):
if len(set(comb)) in [1, 2]:
continue
# a, b, c
ls = [[], [], []]
for i, c in enumerate(comb):
if c == 3:
continue
ls[c].append(L[i])
mps = 0
for idx, ll in enumerate(ls):
if len(ll) == 0:
break
tmp = (len(ll)-1)*10
mps += tmp
mps += abs(targets[idx] - sum(ll))
else:
ans = min(ans, mps)
print(ans)
| n, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(n)]
INF = 10**9
def rec(cur, a, b, c):
if cur == n:
return abs(a-A) + abs(b-B) + abs(c-C) - 30 if min(a, b, c) > 0 else INF
ret0 = rec(cur+1, a, b, c)
ret1 = rec(cur+1, a+L[cur], b, c) + 10
ret2 = rec(cur+1, a, b+L[cur], c) + 10
ret3 = rec(cur+1, a, b, c+L[cur]) + 10
return min(ret0, ret1, ret2, ret3)
print((rec(0, 0, 0, 0)))
| p03111 |
N, A, B, C = list(map(int, input().split()))
L = []
for _ in range(N):
L.append(int(eval(input())))
ans = float('inf')
for mask in range(pow(4, N)):
cost = 0
for i, l in enumerate([A, B, C]):
grp = []
for digit in range(N):
if mask // pow(4, digit) % 4 == i:
grp.append(L[digit])
if not grp:
cost = float('inf')
cost += (len(grp) - 1) * 10
cost += abs(l - sum(grp))
ans = min(ans, cost)
print(ans) | from itertools import product
N, A, B, C = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
ans = 10**18
for state in product(list(range(4)), repeat=N):
K = [[] for _ in range(4)]
for i, l in enumerate(L):
K[state[i]].append(l)
cost = 0
for d, D in zip((A, B, C), K):
if len(D) == 0:
cost += 10**18
cost += (len(D) - 1) * 10
cost += abs(d - sum(D))
ans = min(ans, cost)
print(ans)
| p03111 |
n,a,b,c = list(map(int,input().split()))
L = []
for i in range(n):
L.append(int(eval(input())))
import itertools
ans = 10**9
tmp = 0
for perm in itertools.permutations(list(range(n)),3):
ua,ub,uc = perm
la,lb,lc = L[ua],L[ub],L[uc]
for use in itertools.product([0,1,2,-1] ,repeat=n-3):
idx = 0
tmp = 0
ls = [la,lb,lc]
for i,l in enumerate(L):
if i== ua or i== ub or i== uc:
continue
else:
if use[idx]>-1:
ls[use[idx]] +=l
tmp+=10
idx+=1
tmp = tmp + abs(ls[0] -a) +abs(ls[1] -b)+abs(ls[2] -c)
ans=min(ans,tmp)
print(ans)
| n,a,b,c = list(map(int,input().split()))
L = []
for i in range(n):
L.append(int(eval(input())))
import itertools
ans = 10**9
tmp = 0
for use in itertools.product([0,1,2,-1] ,repeat=n):
tmp = 0
ls = [0,0,0]
for idx,u in enumerate(use):
if u>-1:
if ls[u] >0:
tmp+=10
ls[u]+=L[idx]
if ls[0] ==0 or ls[1] ==0 or ls[2] ==0:continue
tmp = tmp + abs(ls[0] -a) +abs(ls[1] -b)+abs(ls[2] -c)
ans = min(tmp,ans)
print(ans)
| p03111 |
N,A,B,C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
INF = 1<<20
score = INF
import itertools
for ms in itertools.product(list(range(-1,3)), repeat=N):
lens = [0]*3
tmp_score = -30
for i, group in enumerate(ms):
if group>=0:
lens[group] += l[i]
tmp_score += 10
if all(lens):
score = min(score, tmp_score + abs(lens[0]-A)+abs(lens[1]-B)+abs(lens[2]-C))
print(score)
| def main():
N,A,B,C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
INF = 1<<20
def perm(n, a, b, c):
if n == N:
if all([a, b, c]):
return abs(A-a)+abs(B-b)+abs(C-c)-30
else:
return INF
return min(
perm(n+1,a,b,c),
perm(n+1,a+l[n],b,c)+10,
perm(n+1,a,b+l[n],c)+10,
perm(n+1,a,b,c+l[n])+10
)
print((perm(0,0,0,0)))
main() | p03111 |
N, A, B, C = [int(a) for a in input().split(" ")]
ls = [int(eval(input())) for i in range(N)]
tab = [([float("inf")]*N, ref) for ref in (A, B, C)]
INF = float("inf")
from heapq import heappush, heappop, heapreplace
maxtarg = max(A, B, C)
# O(n)
def solve(ls):
n = len(ls)
qs = [[(-INF, -1)]*3 for i in range(3)]
# 3*n times
for ref, q in zip((A, B, C), qs):
for i in range(n):
val = -abs(ref-ls[i])
if q[0][0] < val:
heapreplace(q, (val, i))
ans = INF
# 9 times
for a, i in qs[0]:
for b, j in qs[1]:
for c, k in qs[2]:
if i!=j and j!=k and k!=i:
ans = min(ans, -(a+b+c))
return ans
def dfs(ls):
n = len(ls)
if n < 3: return INF
ans = solve(ls)
for i in range(n-1):
for j in range(i+1,n):
tmp = ls[i]+ls[j]
if min(maxtarg-ls[i], maxtarg-ls[j]) < 10:
continue
ls2 = ls[:i]+ls[i+1:]
ls2[j-1] = tmp
ans = min(ans, 10+dfs(ls2))
return ans
print((dfs(ls)))
| N, A, B, C = [int(a) for a in input().split(" ")]
ls = [int(eval(input())) for i in range(N)]
tab = [([float("inf")]*N, ref) for ref in (A, B, C)]
INF = float("inf")
from heapq import heappush, heappop, heapreplace
maxtarg = max(A, B, C)
# O(n)
def solve(ls):
n = len(ls)
qs = [[(-INF, -1)]*3 for i in range(3)]
# 3*n times
for ref, q in zip((A, B, C), qs):
for i in range(n):
val = -abs(ref-ls[i])
if q[0][0] < val:
heapreplace(q, (val, i))
ans = INF
# 9 times
for a, i in qs[0]:
for b, j in qs[1]:
for c, k in qs[2]:
if i!=j and j!=k and k!=i:
ans = min(ans, -(a+b+c))
return ans
dic = {}
def dfs(ls):
key = tuple(sorted(ls))
if key in dic:
return dic[key]
n = len(ls)
if n < 3: return INF
ans = solve(ls)
for i in range(n-1):
for j in range(i+1,n):
tmp = ls[i]+ls[j]
if min(maxtarg-ls[i], maxtarg-ls[j]) < 10:
continue
ls2 = ls[:i]+ls[i+1:]
ls2[j-1] = tmp
ans = min(ans, 10+dfs(ls2))
dic[key] = ans
return ans
print((dfs(ls)))
| p03111 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
n,a,b,c=list(map(int,input().split()))
L=[int(eval(input())) for _ in range(n)]
def dfs(v,Idx)->int:
# terminate condition
if(v==n):
score=0
Idx=tuple(Idx)
A,B,C=[],[],[]
for i,k in enumerate(Idx):
if(k==0): A.append(L[i])
elif(k==1): B.append(L[i])
elif(k==2): C.append(L[i])
if((not A) or (not B) or (not C)): return INF # 1つも竹が無いのはダメ
score+=(len(A)+len(B)+len(C)-3)*10
SA=sum(A)
SB=sum(B)
SC=sum(C)
score+=abs(SA-a)
score+=abs(SB-b)
score+=abs(SC-c)
return score
res=INF
for i in range(4):
res=min(res,dfs(v+1,Idx+[i]))
return res
print((dfs(0,[])))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
n,a,b,c=list(map(int,input().split()))
L=[int(eval(input())) for _ in range(n)]
def dfs(v,Idx)->int:
# terminate condition
if(v==n):
score=0
Idx=tuple(Idx)
A,B,C=[],[],[]
for i,k in enumerate(Idx):
if(k==0): A.append(L[i])
elif(k==1): B.append(L[i])
elif(k==2): C.append(L[i])
if((not A) or (not B) or (not C)): return INF # 1つも竹が無いのはダメ
score+=(len(A)+len(B)+len(C)-3)*10
SA=sum(A)
SB=sum(B)
SC=sum(C)
score+=abs(SA-a)
score+=abs(SB-b)
score+=abs(SC-c)
return score
res=INF
for i in range(4):
Idx[v]=i
res=min(res,dfs(v+1,Idx))
return res
print((dfs(0,[0]*n)))
resolve() | p03111 |
N, A, B, C= list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
K = 4
minmp = 1e8
for x in range(pow(4, N)):
v = x
c = [0] * K
s = [0] * K
i = 0
while v > 0:
m = v % K
c[m] += 1
s[m] += L[i]
i += 1
v //= K
if c[1] > 0 and c[2] > 0 and c[3] > 0:
minmp = min(minmp, (c[1] + c[2] + c[3] - 3) * 10 + abs(s[1] - A) + abs(s[2] - B) + abs(s[3] - C))
print(minmp)
| N, *P = list(map(int, input().split()))
L = [int(eval(input())) for _ in range(N)]
mp = sum(P) - 30
minmp = 1e10
Pcnt = [0] * 3
Ks = [-1] * N
while True:
i = N-1
while i >= 0:
pre = cur = Ks[i]
cur += 1
if cur >= 3:
cur = -1
Ks[i] = cur
for d, x in ((-1, pre), (1, cur)):
if x >= 0:
Pcnt[x] += d
mp -= abs(P[x])
P[x] -= d * L[i]
mp += abs(P[x]) + d * 10
if cur >= 0:
break
i -= 1
else:
break
if min(Pcnt) > 0:
minmp = min(minmp, mp)
print(minmp)
| p03111 |
import random as rng
import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)
def dump_impl(*objects):
print(*objects, file=sys.stderr)
def dump_dummy(*objects):
pass
dump = dump_impl if "DEBUG" in sys.argv else dump_dummy
N, A, B, C = map(int, input().split())
l = [int(input()) for i in range(N)]
ans = 10**20
for use in it.product({0, 1, 2, 3}, repeat=N):
ABC = {0: [], 1: [], 2: [], 3: []}
for i, u in enumerate(use):
dump(i, u, use)
ABC[u].append(l[i])
if any([len(ABC[u]) == 0 for u in {1, 2, 3}]):
continue
ans = min(ans, sum([abs(sum(ABC[i]) - x) + (len(ABC[i]) - 1)
* 10 for i, x in zip([1, 2, 3], [A, B, C])]))
print(ans)
| n, a, b, c = [int(it) for it in input().split()]
ls = [int(eval(input())) for it in range(n)]
def dfs(cur, tmpA, tmpB, tmpC):
if cur == n:
return abs(a - tmpA) + abs(b - tmpB) + abs(c - tmpC) if tmpA > 0 and tmpB > 0 and tmpC else 10**20
return min(
dfs(cur + 1, tmpA + ls[cur], tmpB, tmpC) + (10 if tmpA > 0 else 0),
dfs(cur + 1, tmpA, tmpB + ls[cur], tmpC) + (10 if tmpB > 0 else 0),
dfs(cur + 1, tmpA, tmpB, tmpC + ls[cur]) + (10 if tmpC > 0 else 0),
dfs(cur + 1, tmpA, tmpB, tmpC)
)
print((dfs(0, 0, 0, 0)))
| p03111 |
N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for i in range(N)]
INF = 10 ** 9
def dfs(cur, a, b, c):
if cur == N:
return abs(a - A) + abs(b - B) + abs(c - C) - 30 if min(a, b, c) > 0 else INF
ret0 = dfs(cur + 1, a, b, c)
ret1 = dfs(cur + 1, a + l[cur], b, c) + 10
ret2 = dfs(cur + 1, a, b + l[cur], c) + 10
ret3 = dfs(cur + 1, a, b, c + l[cur]) + 10
return min(ret0, ret1, ret2, ret3)
print((dfs(0, 0, 0, 0))) | N, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(N)]
def dfs(cur, a, b, c):
if cur == N:
return abs(a-A) + abs(b-B) + abs(c-C) - 30 if a * b * c != 0 else 10 ** 9
else:
ret0 = dfs(cur + 1, a, b, c)
reta = dfs(cur + 1, a + l[cur], b, c) + 10
retb = dfs(cur + 1, a, b + l[cur], c) + 10
retc = dfs(cur + 1, a, b, c + l[cur]) + 10
return min(ret0, reta, retb, retc)
print((dfs(0,0,0,0))) | p03111 |
from itertools import combinations
def f(in_A,in_B,in_C,A,B,C,ex_l,counter):
if (counter == len(ex_l)):
return abs(in_A-A)+abs(in_B-B)+abs(in_C-C)
else:
tmp = ex_l[counter]
counter +=1
a1 = f(in_A+tmp,in_B,in_C,A,B,C,ex_l,counter)+10
a2 = f(in_A,in_B+tmp,in_C,A,B,C,ex_l,counter)+10
a3 = f(in_A,in_B,in_C+tmp,A,B,C,ex_l,counter)+10
a4 = f(in_A,in_B,in_C,A,B,C,ex_l,counter)
return min(a1,a2,a3,a4)
N,A,B,C=list(map(int,input().split()))
l = []
for i in range(N):
l.append(int(eval(input())))
in_l = list(map(list,combinations(l,3)))
ex_l = [l[:] for _ in range(len(in_l))]
for i in range(len(in_l)):
ex_l[i].remove(in_l[i][0])
ex_l[i].remove(in_l[i][1])
ex_l[i].remove(in_l[i][2])
mp = []
for i in range(len(in_l)):
mp.append(f(in_l[i][0],in_l[i][1],in_l[i][2],A,B,C,ex_l[i],0))
mp.append(f(in_l[i][0],in_l[i][1],in_l[i][2],A,C,B,ex_l[i],0))
mp.append(f(in_l[i][0],in_l[i][1],in_l[i][2],B,A,C,ex_l[i],0))
mp.append(f(in_l[i][0],in_l[i][1],in_l[i][2],B,C,A,ex_l[i],0))
mp.append(f(in_l[i][0],in_l[i][1],in_l[i][2],C,A,B,ex_l[i],0))
mp.append(f(in_l[i][0],in_l[i][1],in_l[i][2],C,B,A,ex_l[i],0))
mp = min(mp)
print(mp) | n,a,b,c = list(map(int,input().split()))
l = []
ans = []
for i in range(n):
l.append(int(eval(input())))
def f(x,y,z,arr,ca,cb,cc):
global a
global b
global c
global ans
if arr:
f(x + arr[0], y, z, arr[1:],ca+1,cb,cc)
f(x, y + arr[0], z, arr[1:],ca,cb+1,cc)
f(x, y, z + arr[0], arr[1:],ca,cb,cc+1)
f(x, y, z, arr[1:],ca,cb,cc)
else:
if x > 0 and y > 0 and z > 0:
ans.append(abs(a-x) + abs(b-y) + abs(c-z) + 10 * (ca + cb + cc - 3))
f(0,0,0,l,0,0,0)
print((min(ans))) | p03111 |
n,a,b,c = list(map(int,input().split()))
l = []
ans = []
for i in range(n):
l.append(int(eval(input())))
def f(x,y,z,arr,ca,cb,cc):
global a
global b
global c
global ans
if arr:
f(x + arr[0], y, z, arr[1:],ca+1,cb,cc)
f(x, y + arr[0], z, arr[1:],ca,cb+1,cc)
f(x, y, z + arr[0], arr[1:],ca,cb,cc+1)
f(x, y, z, arr[1:],ca,cb,cc)
else:
if x > 0 and y > 0 and z > 0:
ans.append(abs(a-x) + abs(b-y) + abs(c-z) + 10 * (ca + cb + cc - 3))
f(0,0,0,l,0,0,0)
print((min(ans))) | n,a,b,c = list(map(int,input().split()))
l = []
ans = []
for i in range(n):
l.append(int(eval(input())))
def f(x,y,z,arr,cnt):
global a
global b
global c
global ans
if arr:
f(x + arr[0], y, z, arr[1:],cnt+1)
f(x, y + arr[0], z, arr[1:],cnt+1)
f(x, y, z + arr[0], arr[1:],cnt+1)
f(x, y, z, arr[1:],cnt)
else:
if x > 0 and y > 0 and z > 0:
ans.append(abs(a-x) + abs(b-y) + abs(c-z) + 10 * (cnt - 3))
f(0,0,0,l,0)
print((min(ans))) | p03111 |
#!/usr/bin/env python3
import sys
# import math
# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from operator import itemgetter # itemgetter(1), itemgetter('key')
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy # to copy multi-dimentional matrix without reference
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(eval(input()))
def mi(): return list(map(int, input().split()))
def mi_0(): return [int(x)-1 for x in input().split()]
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list([int(x)-1 for x in input().split()])
def li(): return list(eval(input()))
def calc_min_mp_without_merge(seq, a, b, c):
'合成魔法を使わずに seq の要素を作り出すのに必要な最小 MP を求める (O(xP3) = O(x^3))'
ans = inf
n = len(seq)
for pattern in permutations(list(range(n)), r=3):
i, j, k = pattern
ans = min(ans, abs(seq[i] - a) + abs(seq[j] - b) + abs(seq[k] - c))
# print(f"seq {seq} ans {ans}")
return ans
def calc_min_mp(L, a, b, c):
'ちょうど i 回合成魔法を使い i+1 個の L の要素を合体するとき、a, b, c の長さを作り出すのに必要な最小 MP を求める'
ans = calc_min_mp_without_merge(L, a, b, c)
n = len(L)
if n > 3:
for merge_pattern in combinations(list(range(n)), r=2):
new_seq = [L[ind] for ind in range(n) if ind not in merge_pattern]
new_bamboo = sum([L[ind] for ind in merge_pattern])
new_seq.append(new_bamboo)
ans = min(ans, calc_min_mp(new_seq, a, b, c) + 10)
return ans
n, a, b, c = mi()
L = [ii() for _ in range(n)]
print((calc_min_mp(L, a, b, c)))
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
import sys
# import math
# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits
# import re # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from operator import itemgetter # itemgetter(1), itemgetter('key')
# from collections import deque # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict # subclass of dict. defaultdict(facroty)
# from collections import Counter # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
from itertools import product, permutations # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate # accumulate(iter[, f])
# from functools import reduce # reduce(f, iter[, init])
# from functools import lru_cache # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy # to copy multi-dimentional matrix without reference
# from fractions import gcd # for Python 3.4 (previous contest @AtCoder)
def main():
mod = 1000000007 # 10^9+7
inf = float('inf') # sys.float_info.max = 1.79...e+308
# inf = 2 ** 64 - 1 # (for fast JIT compile in PyPy) 1.84...e+19
sys.setrecursionlimit(10**6) # 1000 -> 1000000
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(eval(input()))
def mi(): return list(map(int, input().split()))
def mi_0(): return [int(x)-1 for x in input().split()]
def lmi(): return list(map(int, input().split()))
def lmi_0(): return list([int(x)-1 for x in input().split()])
def li(): return list(eval(input()))
def calc_min_mp(L, a, b, c):
ans = inf
quaternary = product(list(range(4)), repeat=n)
for pattern in quaternary:
if pattern.count(1) and pattern.count(2) and pattern.count(3):
needed_mp = (n - pattern.count(0) - 3) * 10 # 合成魔法の使用回数
base_abc = [0, 0, 0] # base_a, base_b, base_c
for i, num in enumerate(pattern):
if num != 0:
base_abc[num - 1] += L[i]
needed_mp += abs(a - base_abc[0]) + abs(b - base_abc[1]) + abs(c - base_abc[2])
ans = min(ans, needed_mp)
return ans
n, a, b, c = mi()
L = [ii() for _ in range(n)]
print((calc_min_mp(L, a, b, c)))
if __name__ == "__main__":
main() | p03111 |
from itertools import product
import bisect
N, A, B, C = list(map(int, input().split()))
tl = [C,B,A]
ll = []
for _ in range(N):
ll.append(int(eval(input())))
ans = 10**8
ite = product(list(range(4)),repeat=N)
for pattern in ite:
bag = [[],[],[]]
singles = []
mp = 0
for i, p in enumerate(pattern):
if p == 3: singles.append(ll[i])
else: bag[p].append(ll[i])
zero_cnt = 0
for b in bag:
if not b: zero_cnt+=1
else: mp += (len(b)-1)*10
if not singles: zero_cnt+=1
if zero_cnt >= 2: continue
bamboos = []
for b in bag:
if b: bamboos.append(sum(b))
for s in singles:
bamboos.append(s)
bamboos.sort()
# print(bamboos)
for t in tl:
curr_min = 10000
curr_min_i = 0
for i, ba in enumerate(bamboos):
if abs(ba - t) < curr_min:
curr_min = abs(ba-t)
curr_min_i = i
mp += curr_min
bamboos.pop(curr_min_i)
ans = min(ans,mp)
print(ans) |
from itertools import product
def main():
n,a,b,c = list(map(int, input().split()))
targetl = [a,b,c]
targetl.sort()
ll = []
for _ in range(n):
l = int(eval(input()))
ll.append(l)
ans = 10**9
ite = product(list(range(4)),repeat=n)
ite = list(ite)
for it in ite:
bamboosl = [ [],[],[] ]
cost = -30
for i,v in enumerate(it):
if v != 3:
bamboosl[v].append(ll[i])
cost += 10
continue_f = False
for bamboos in bamboosl:
if not bamboos: continue_f = True
if continue_f: continue
longs = []
for bamboos in bamboosl:
curr_l = sum(bamboos)
longs.append(curr_l)
longs.sort()
for v1,v2 in zip(targetl,longs):
cost += abs(v1-v2)
ans = min(ans,cost)
print(ans)
if __name__ == "__main__":
main() | p03111 |
def base_10_to_n(X, n):
if (int(X/n)):
return base_10_to_n(int(X/n), n)+str(X%n)
return str(X%n)
def f(a,A):
if len(a) == 0:
return 1e12
return (len(a)-1)*10 + abs(sum(a)-A)
N,A,B,C = list(map(int,input().split()))
l = [int(eval(input())) for i in range(N)]
ans = 1e12
for i in range(4**N+1):
tmp = list(base_10_to_n(i,4).zfill(N))
a,b,c = [],[],[]
for s,t in zip(tmp,l):
if s == "1":
a.append(t)
elif s == "2":
b.append(t)
elif s == "3":
c.append(t)
ans = min(ans,f(a,A)+f(b,B)+f(c,C))
print(ans)
| def base_10_to_n(X, n):
if (int(X/n)):
return base_10_to_n(int(X/n), n)+str(X%n)
return str(X%n)
def f(a,la,A):
if la == 0:
return 1e12
return (la-1)*10 + abs(a-A)
N,A,B,C = list(map(int,input().split()))
l = [int(eval(input())) for i in range(N)]
ans = 1e12
for i in range(4**N+1):
tmp = list(base_10_to_n(i,4).zfill(N))
a,la,b,lb,c,lc = 0,0,0,0,0,0
for s,t in zip(tmp,l):
if s == "1":
a += t
la += 1
elif s == "2":
b += t
lb += 1
elif s == "3":
c += t
lc += 1
ans = min(ans,f(a,la,A)+f(b,lb,B)+f(c,lc,C))
print(ans) | p03111 |
import sys
#+++++
def aaa(ll,a,b,c):
ret=a+b+c
for i,v1 in enumerate(ll):
if v1==0:
continue
t1=abs(a-v1)
if ret < t1:
continue
for j,v2 in enumerate(ll):
if v2==0:
continue
if i==j:
continue
t2=t1 + abs(b-v2)
if ret < t2:
continue
for k,v3 in enumerate(ll):
if v3==0:
continue
if i==k or j==k:
continue
t3 = t2 + abs(c-v3)
ret=min(ret, t3)
return ret
def main():
n , a, b, c = list(map(int, input().split()))
bb=[]
for i in range(n):
bb.append(int(eval(input())))
ans=a+b+c
for i in range(4**n-1):
la=[]
lb=[]
lc=[]
l=[]
for j in range(n):
sd=(i%(4 ** (j+1)))//(4**j)
kk=bb[j]
pp=0
if sd == 0:
la.append(kk)
elif sd==1:
lb.append(kk)
elif sd==2:
lc.append(kk)
else:
l.append(kk)
pp=max(0,len(la)-1)+max(len(lb)-1,0)+max(0,len(lc)-1)
l=l+[sum(la),sum(lb),sum(lc)]
#print(l)
ans=min(ans,aaa(l,a,b,c)+pp*10)
print(ans)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
if __name__ == "__main__":
if sys.platform =='ios':
sys.stdin=open('inputFile.txt')
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | import sys
import queue
#+++++
def aaa(ll,a,b,c):
ret=a+b+c
for i,v1 in enumerate(ll):
if v1==0:
continue
t1=abs(a-v1)
if ret < t1:
continue
for j,v2 in enumerate(ll):
if v2==0:
continue
if i==j:
continue
t2=t1 + abs(b-v2)
if ret < t2:
continue
for k,v3 in enumerate(ll):
if v3==0:
continue
if i==k or j==k:
continue
t3 = t2 + abs(c-v3)
ret=min(ret, t3)
return ret
def mk_str(ll):
ll.sort()
return '_'.join([str(v) for v in ll])
def main():
n , a, b, c = list(map(int, input().split()))
est=lambda ll:aaa(ll,a,b,c)
bb=[]
for i in range(n):
bb.append(int(eval(input())))
cl=set()
ol=queue.PriorityQueue()
st=bb
ee=est(st)
cc=0
cl.add(mk_str(bb))
ol.put((ee+cc, (cc, bb)))
while True:
if ee == 0:
return cc
#to goal no join
rr=cc+ee
ol.put((rr, (rr, [a,b,c])))
#join 1
if len(st) > 3:
cc+=10
for i, v in enumerate(st):
kk=st[:]
m=kk.pop(i)
for j, _ in enumerate(kk):
kkk=kk[:]
kkk[j]+=m
stk=mk_str(kkk)
if stk not in cl:
cl.add(stk)
ol.put((cc, (cc, kkk)))
v,(cc, st) = ol.get()
ee = est(st)
print(ans)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
if __name__ == "__main__":
if sys.platform =='ios':
sys.stdin=open('inputFile.txt')
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | p03111 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.