input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
n = int(eval(input()))
numbers = list(map(int, input().split()))
def checkCondition():
for i in range(n-1):
if numbers[i] > numbers[i+1]:
if numbers[i] - numbers[i+1] > 1:
return False
for i in range(-1, -n, -1):
if numbers[i-1] - numbers[i] == 1:
numbers[i-1] -= 1
elif numbers[i-1] - numbers[i] > 1:
return False
return True
if n == 1:
print('Yes')
else:
if checkCondition():
print('Yes')
else:
print('No') | n = int(eval(input()))
numbers = list(map(int, input().split()))
def checkCondition():
for i in range(n-1):
if numbers[i] > numbers[i+1] + 1:
return False
for i in range(-1, -n, -1):
if numbers[i-1] - numbers[i] == 1:
numbers[i-1] -= 1
elif numbers[i-1] - numbers[i] > 1:
return False
return True
if n == 1:
print('Yes')
else:
if checkCondition():
print('Yes')
else:
print('No') | p02953 |
n = int(eval(input()))
numbers = list(map(int, input().split()))
def checkCondition():
for i in range(n-1):
if numbers[i] > numbers[i+1] + 1:
return False
for i in range(-1, -n, -1):
if numbers[i-1] - numbers[i] == 1:
numbers[i-1] -= 1
elif numbers[i-1] - numbers[i] > 1:
return False
return True
if n == 1:
print('Yes')
else:
if checkCondition():
print('Yes')
else:
print('No') | n = int(eval(input()))
numbers = list(map(int, input().split()))
def checkCondition():
for i in range(n-1):
if numbers[i] > numbers[i+1]:
if numbers[i] - numbers[i+1] > 1:
return False
for i in range(-1, -n, -1):
sub = numbers[i-1] - numbers[i]
if sub == 1:
numbers[i-1] -= 1
elif sub > 1:
return False
return True
if n == 1:
print('Yes')
else:
if checkCondition():
print('Yes')
else:
print('No') | p02953 |
import sys
import bisect
input = sys.stdin.readline
def main():
n=int(eval(input()))
h = list(map(int,input().split()))
ans="Yes"
for i in range(n-1):
b=h[0]
h.pop(0)
if(b>=min(h)+2):
ans="No"
if(ans=="No"):
break
print(ans)
main() | import sys
import bisect
input = sys.stdin.readline
def main():
n=int(eval(input()))
h = list(map(int,input().split()))
ans="Yes"
m=0
for i in range(n):
if(m>=h[i]+2):
ans="No"
else:
m=max(m,h[i])
if(ans=="No"):
break
print(ans)
main() | p02953 |
def c_build_stairs(N, H):
for i in range(N - 1):
if H[i] < H[i + 1]:
H[i + 1] -= 1
for i in range(N - 1):
if H[i] > H[i + 1]:
return 'No'
return 'Yes'
N = int(eval(input()))
H = [int(i) for i in input().split()]
print((c_build_stairs(N, H))) | def c_build_stairs(N, H):
for i in range(N - 1, 0, -1):
if H[i - 1] - H[i] >= 2:
return 'No'
elif H[i - 1] - H[i] == 1:
H[i - 1] -= 1
return 'Yes'
N = int(eval(input()))
H = [int(i) for i in input().split()]
print((c_build_stairs(N, H))) | p02953 |
N = int(eval(input()))
H = list(map(int, input().split()))
for i in range(N-1):
minh = min(H[i+1:]) # i+1以降のリストをスライス
if H[i] - minh >= 2:
print('No')
break
else:
continue
else:
print('Yes')
"""
# よく考えたら最大だけじゃダメだった
m = H.index(max(H)) # 複数の候補がある場合は最初のインデックスを返す
print(m)
for i in range(m+1, N):
if H[m] - H[i] >= 2:
print('No')
break
else:
continue
else:
print('Yes')
""" | N = int(eval(input()))
H = list(map(int, input().split()))
highest = 0
for i in range(N-1):
highest = max(highest, H[i])
if highest - 1 <= H[i+1]:
continue
else:
print('No')
break
else:
print('Yes')
| p02953 |
n=int(eval(input()))
h=list(map(int,input().split()))
for i in range(n-1):
for j in range(i,n):
if h[i]-h[j]>=2:
print('No')
exit()
print('Yes') | n=int(eval(input()))
h=list(map(int,input().split()))
for i in range(1,n):
if h[i]-1>=h[i-1]:
h[i]-=1
x=sorted(h)
print(('Yes' if x==h else 'No'))
| p02953 |
# -*- coding: utf-8 -*-
n = int(eval(input()))
h = [int(i) for i in input().split()]
flag = True
for i in reversed(list(range(n - 1))):
if h[i] - h[i + 1] == 1:
h[i] -= 1
elif h[i] > h[i + 1]:
flag = False
if flag:
print("Yes")
else:
print("No")
| # -*- coding: utf-8 -*-
n = int(eval(input()))
h = [int(i) for i in input().split()]
flag = True
for i in reversed(list(range(n - 1))):
if h[i] - h[i + 1] == 1:
h[i] -= 1
elif h[i] > h[i + 1]:
flag = False
break
if flag:
print("Yes")
else:
print("No")
| p02953 |
import sys
sys.setrecursionlimit(10**6)
def solve(n, h, cur, l):
if cur > n:
return True
else:
if l < h[cur]:
return solve(n, h, cur+1, h[cur]-1) or solve(n, h, cur+1, h[cur])
elif l == h[cur]:
return solve(n, h, cur+1, h[cur])
else:
return False
N = int(eval(input()))
H = [-1]+list(map(int, input().split()))+[(10**9)+1]
print(("Yes" if solve(N, H, 1, -1) else "No"))
| import sys
sys.setrecursionlimit(10**6)
def solve(n, h, cur, l):
if cur > n:
return True
else:
if l < h[cur]:
return solve(n, h, cur+1, h[cur]-1)
elif l == h[cur]:
return solve(n, h, cur+1, h[cur])
else:
return False
N = int(eval(input()))
H = [-1]+list(map(int, input().split()))+[(10**9)+1]
print(("Yes" if solve(N, H, 1, -1) else "No"))
| p02953 |
N = int(eval(input()))
H = [int(i) for i in input().split()]
t = 0
if N >= 2:
for i in range(N-1):
if H[i] >= min(H[i+1:N]) + 2:
t += 1
if t == 0:
print("Yes")
else:
print("No") | N = int(eval(input()))
H = [int(i) for i in input().split()]
t = 0
s = 0
if N >= 2:
for i in range(N-1):
if H[i] > H[i+1]:
t += 1
if t == 2:
s += 1
if H[i] < H[i+1]:
t = 0
if H[i] >= H[i+1] +2:
s += 1
if s == 0:
print("Yes")
else:
print("No") | p02953 |
n = int(eval(input()))
h=list(map(int,input().split()))
maxh = [i for i, x in enumerate(h) if x==max(h)]
minh = [i for i, x in enumerate(h) if x==min(h)]
if min(maxh)<max(minh) and max(h)-1>min(h):
print("No")
else:
print("Yes") | n = int(eval(input()))
h=list(map(int,input().split()))
def jud(n,h):
for i in list(reversed(list(range(0,n-1)))):
# print(h[i],h[i+1])
if h[i+1]-h[i]==-1:
h[i]-=1
# print(h[i])
continue
if h[i]-h[i+1]>1:
return "No"
break
return "Yes"
print((jud(n,h)))
| p02953 |
N = int(eval(input()))
H = list(map(int,input().split()))
for i in range(N - 1):
head = H[i]
remains = min(H[i + 1:])
if head - remains >= 2:
print("No")
break
else:
print("Yes") | N = int(eval(input()))
H = list(map(int,input().split()))
head = 0
for i in range(N):
if H[i] >= head:
head = H[i]
if head - H[i] >= 2:
print("No")
break
else:print("Yes") | p02953 |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
S,T=read().rstrip().decode().split()
ans=0
for s,t in zip(S,T):
if s!=t:
ans+=1
print(ans) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
S,T=read().rstrip().decode().split()
print((sum(s!=t for s,t in zip(S,T)))) | p02622 |
import os
import sys
from collections import Counter
class BinaryIndexedTree:
# http://hos.ac/slides/20140319_bit.pdf
def __init__(self, size):
"""
:param int size:
"""
self._bit = [0] * size
self._size = size
def add(self, i, w):
"""
i 番目に w を加える
:param int i:
:param int w:
"""
x = i + 1
while x <= self._size:
self._bit[x - 1] += w
x += x & -x
def sum(self, i):
"""
[0, i) の合計
:param int i:
"""
ret = 0
while i > 0:
ret += self._bit[i - 1]
i -= i & -i
return ret
def __len__(self):
return self._size
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
S = sys.stdin.buffer.readline().decode().rstrip()
counter = Counter(S)
# 回文にできるかどうかはかんたんに判定できる
if len(S) % 2 == 0:
ok = True
for c, cnt in list(counter.items()):
ok &= cnt % 2 == 0
else:
odds = 0
for c, cnt in list(counter.items()):
odds += cnt % 2 == 1
ok = odds == 1
if not ok:
print((-1))
exit()
# 左右に寄せる。
# 左側か右側かだけで転倒数を数える
counts = [0] * 26
ls = ''
mid = ''
rs = ''
invs = 0
for c in S:
n = ord(c) - ord('a')
counts[n] += 1
if counter[c] & 1:
if counts[n] <= counter[c] // 2:
ls += c
invs += len(rs) + len(mid)
elif counts[n] == counter[c] // 2 + 1:
mid += c
invs += len(rs)
else:
rs += c
else:
if counts[n] <= counter[c] // 2:
ls += c
invs += len(rs) + len(mid)
else:
rs += c
rs = rs[::-1]
# 目的の回文への置換回数と同じ回数で ls -> rs に置換できる
l_idx = [[] for _ in range(26)]
for i, c in enumerate(ls):
n = ord(c) - ord('a')
l_idx[n].append(i)
counts = [0] * 26
idx = []
for i, c in enumerate(rs):
n = ord(c) - ord('a')
idx.append(l_idx[n][counts[n]])
counts[n] += 1
# idx を昇順にする == ls と同じ並びにするまでの回数
invs2 = 0
bit = BinaryIndexedTree(size=len(ls))
for i in reversed(idx):
invs2 += bit.sum(i)
bit.add(i, 1)
ans = invs + invs2
# print(invs, invs2)
# print(ls, rs)
# print(idx)
print(ans)
| import os
import sys
from collections import Counter
class BinaryIndexedTree:
# http://hos.ac/slides/20140319_bit.pdf
def __init__(self, size):
"""
:param int size:
"""
self._bit = [0] * size
self._size = size
def add(self, i, w):
"""
i 番目に w を加える
:param int i:
:param int w:
"""
x = i + 1
while x <= self._size:
self._bit[x - 1] += w
x += x & -x
def sum(self, i):
"""
[0, i) の合計
:param int i:
"""
ret = 0
while i > 0:
ret += self._bit[i - 1]
i -= i & -i
return ret
def __len__(self):
return self._size
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
# PyPy だと文字列結合がめちゃくちゃ遅いっぽい
S = sys.stdin.buffer.readline().decode().rstrip()
counter = Counter(S)
# 回文にできるかどうかはかんたんに判定できる
if len(S) % 2 == 0:
ok = True
for c, cnt in list(counter.items()):
ok &= cnt % 2 == 0
else:
odds = 0
for c, cnt in list(counter.items()):
odds += cnt % 2 == 1
ok = odds == 1
if not ok:
print((-1))
exit()
# 左右に寄せる。
# 左側か右側かだけで転倒数を数える
counts = [0] * 26
ls = []
mid = []
rs = []
invs = 0
for c in S:
n = ord(c) - ord('a')
counts[n] += 1
if counter[c] & 1:
if counts[n] <= counter[c] // 2:
ls.append(c)
invs += len(rs) + len(mid)
elif counts[n] == counter[c] // 2 + 1:
mid.append(c)
invs += len(rs)
else:
rs.append(c)
else:
if counts[n] <= counter[c] // 2:
ls.append(c)
invs += len(rs) + len(mid)
else:
rs.append(c)
rs = rs[::-1]
# 目的の回文への置換回数と同じ回数で ls -> rs に置換できる
l_idx = [[] for _ in range(26)]
for i, c in enumerate(ls):
n = ord(c) - ord('a')
l_idx[n].append(i)
counts = [0] * 26
idx = []
for i, c in enumerate(rs):
n = ord(c) - ord('a')
idx.append(l_idx[n][counts[n]])
counts[n] += 1
# idx を昇順にする == ls と同じ並びにするまでの回数
invs2 = 0
bit = BinaryIndexedTree(size=len(ls))
for i in reversed(idx):
invs2 += bit.sum(i)
bit.add(i, 1)
ans = invs + invs2
# print(invs, invs2)
# print(ls, rs)
# print(idx)
print(ans)
| p03483 |
#coding:utf-8
N = int(eval(input()))
trees = [list(input().split()) for i in range(N)]
class BinaryTree:
def __init__(self,key,p=None,l=None,r=None):
self.key = key
self.p = p
self.l = l
self.r = r
def Insert(root,z):
y = None
x = root
while x != None:
y = x
if z.key < x.key:
x = x.l
else:
x = x.r
z.p = y
if y == None:
root = z
elif z.key < y.key:
y.l = z
else:
y.r = z
return root
def preOrder(x):
if x == None:
return
global preList
preList.append(x.key)
preOrder(x.l)
preOrder(x.r)
def inOrder(x):
if x == None:
return
inOrder(x.l)
global inList
inList.append(x.key)
inOrder(x.r)
def Find(x,z):
while x != None and z.key != x.key:
y = x
if z.key < x.key:
x = x.l
else:
x = x.r
return x
def Delete(x, z):
if z.l == None or z.r == None:
y = z
else:
y = getSuccessor(z)
if y.l != None:
x = y.l
else:
x = y.r
if x != None:
x.p = y.p
if y.p == None:
global root
root = x
elif y == y.p.l:
y.p.l = x
else:
y.p.r = x
if y != z:
z.key = y.key
def getSuccessor(x):
if x.r != None:
return getMinimum(x.r)
y = x.p
while y != None and x == y.r:
x = y
y = y.p
return y
def getMinimum(x):
while x.l != None:
x = x.l
return x
root = None
for data in trees:
if data[0] == "print":
inList = []
preList = []
inOrder(root)
a = " " + " ".join([str(num) for num in inList])
print(a)
preOrder(root)
a = " " + " ".join([str(num) for num in preList])
print(a)
else:
z = BinaryTree(int(data[1]))
if data[0] == "insert":
root = Insert(root,z)
elif data[0] == "find":
a = Find(root, z)
if a == None:
print("no")
else:
print("yes")
elif data[0] == "delete":
Delete(root, Find(root,z))
| #coding:utf-8
N = int(eval(input()))
trees = [list(input().split()) for i in range(N)]
class BinaryTree:
def __init__(self,key,p=None,l=None,r=None):
self.key = key
self.p = p
self.l = l
self.r = r
def Insert(root,z):
y = None
x = root
while x != None:
y = x
if z.key < x.key:
x = x.l
else:
x = x.r
z.p = y
if y == None:
root = z
elif z.key < y.key:
y.l = z
else:
y.r = z
return root
def preOrder(x):
if x == None:
return
global preList
preList.append(x.key)
preOrder(x.l)
preOrder(x.r)
def inOrder(x):
if x == None:
return
inOrder(x.l)
global inList
inList.append(x.key)
inOrder(x.r)
def Find(x,z):
while x != None and z.key != x.key:
y = x
if z.key < x.key:
x = x.l
else:
x = x.r
return x
def Delete(x, z):
if z.l == None or z.r == None:
y = z
else:
y = getSuccessor(z)
if y.l != None:
x = y.l
else:
x = y.r
if x != None:
x.p = y.p
if y.p == None:
pass
elif y == y.p.l:
y.p.l = x
else:
y.p.r = x
if y != z:
z.key = y.key
def getSuccessor(x):
if x.r != None:
return getMinimum(x.r)
y = x.p
while y != None and x == y.r:
x = y
y = y.p
return y
def getMinimum(x):
while x.l != None:
x = x.l
return x
root = None
for data in trees:
if data[0] == "print":
inList = []
preList = []
inOrder(root)
a = " " + " ".join([str(num) for num in inList])
print(a)
preOrder(root)
a = " " + " ".join([str(num) for num in preList])
print(a)
else:
z = BinaryTree(int(data[1]))
if data[0] == "insert":
root = Insert(root,z)
elif data[0] == "find":
a = Find(root, z)
if a == None:
print("no")
else:
print("yes")
elif data[0] == "delete":
Delete(root, Find(root,z))
| p02285 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
input:
18
insert 8
insert 2
insert 3
insert 7
insert 22
insert 1
find 1
find 2
find 3
find 4
find 5
find 6
find 7
find 8
print
delete 3
delete 7
print
output: finded + in_order + pre_order
yes
yes
yes
no
no
no
yes
yes
1 2 3 7 8 22
8 2 1 3 7 22
1 2 8 22
8 2 1 22
"""
import sys
import copy
class Node(object):
def __init__(self, data):
self.data = data
self.left, self.right = None, None
def insert(self, data):
"""
insert data according to BST rules
"""
if data < self.data:
if not self.left:
self.left = Node(data)
else:
self.left.insert(data)
# insert duplicate value to right
else:
if not self.right:
self.right = Node(data)
else:
self.right.insert(data)
return self.data
def find(self, data, parent=None):
"""
find node with given data
tree walk as insert goes
"""
if data < self.data:
if not self.left:
return None, None
return self.left.find(data=data, parent=self)
elif data > self.data:
if not self.right:
return None, None
return self.right.find(data=data, parent=self)
else:
return self, parent
def children_count(self):
"""
for choosing node deleting strategy
"""
cnt = 0
if self.left:
cnt += 1
if self.right:
cnt += 1
return cnt
def delete(self, data):
"""
delete node with given data
"""
node, parent = self.find(data)
if node:
children_count = node.children_count()
if children_count == 0:
# delete reference to parent
if parent.left is node:
parent.left = None
else:
parent.right = None
del node
elif children_count == 1:
# node's son becomes parents' son
if node.left:
n = node.left
else:
n = node.right
if parent:
if parent.left is node:
parent.left = n
else:
parent.right = n
del node
else:
successor = node.right
while successor.left:
successor = successor.left
copy_data = successor.data
self.delete(copy_data)
node.data = copy_data
def pre_order(node):
if node:
print('', node.data, end='')
pre_order(node.left)
pre_order(node.right)
return None
def in_order(node):
if node:
in_order(node.left)
print('', node.data, end='')
in_order(node.right)
return None
def action(command, content):
# start all action from tree_root
if command.startswith('in'):
tree_root.insert(int(content))
elif command.startswith('fi'):
if tree_root.find(int(content)) == (None, None):
print('no')
else:
print('yes')
elif command.startswith('de'):
tree_root.delete(int(content))
# print tree walk
else:
in_order(tree_root)
print('')
pre_order(tree_root)
print('')
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
array_length = int(_input[0])
command_list = list(map(lambda x: x.split(), _input[1:]))
# assert len(command_list) == array_length
flag, tree_root = False, None
for each in command_list:
command, content = each[0], each[-1]
if (not flag) and command.startswith('in'):
tree_root = Node(data=int(content))
flag = True
continue
action(command, content)
| #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
input:
18
insert 8
insert 2
insert 3
insert 7
insert 22
insert 1
find 1
find 2
find 3
find 4
find 5
find 6
find 7
find 8
print
delete 3
delete 7
print
output: finded + in_order + pre_order
yes
yes
yes
no
no
no
yes
yes
1 2 3 7 8 22
8 2 1 3 7 22
1 2 8 22
8 2 1 22
"""
import sys
class Node(object):
def __init__(self, data):
self.data = data
self.left, self.right = None, None
def insert(self, data):
"""
insert data according to BST rules
"""
if data < self.data:
if not self.left:
self.left = Node(data)
else:
self.left.insert(data)
# insert duplicate value to right
else:
if not self.right:
self.right = Node(data)
else:
self.right.insert(data)
return self.data
def find(self, data, parent=None):
"""
find node with given data
tree walk as insert goes
"""
if data < self.data:
if not self.left:
return None, None
return self.left.find(data=data, parent=self)
elif data > self.data:
if not self.right:
return None, None
return self.right.find(data=data, parent=self)
else:
return self, parent
def children_count(self):
"""
for choosing node deleting strategy
"""
cnt = 0
if self.left:
cnt += 1
if self.right:
cnt += 1
return cnt
def delete(self, data):
"""
delete node with given data
"""
node, parent = self.find(data)
if node:
children_count = node.children_count()
if children_count == 0:
# delete reference to parent
if parent.left is node:
parent.left = None
else:
parent.right = None
del node
elif children_count == 1:
# node's son becomes parents' son
if node.left:
n = node.left
else:
n = node.right
if parent:
if parent.left is node:
parent.left = n
else:
parent.right = n
del node
else:
# current node has two real children
# while the real successor couldn't have two real children
successor = node.right
while successor.left:
successor = successor.left
copy_data = successor.data
self.delete(copy_data)
node.data = copy_data
def pre_order(node):
if node:
print('', node.data, end='')
pre_order(node.left)
pre_order(node.right)
return None
def in_order(node):
if node:
in_order(node.left)
print('', node.data, end='')
in_order(node.right)
return None
def action(command, content):
# start all action from tree_root -- insert, find, delete
if command.startswith('in'):
tree_root.insert(int(content))
elif command.startswith('fi'):
if tree_root.find(int(content)) == (None, None):
print('no')
else:
print('yes')
elif command.startswith('de'):
tree_root.delete(int(content))
# print tree walk
else:
in_order(tree_root)
print('')
pre_order(tree_root)
print('')
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
array_length = int(_input[0])
command_list = list(map(lambda x: x.split(), _input[1:]))
# assert len(command_list) == array_length
flag, tree_root = False, None
for each in command_list:
command, content = each[0], each[-1]
if (not flag) and command.startswith('in'):
tree_root = Node(data=int(content))
flag = True
continue
action(command, content)
| p02285 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
input:
18
insert 8
insert 2
insert 3
insert 7
insert 22
insert 1
find 1
find 2
find 3
find 4
find 5
find 6
find 7
find 8
print
delete 3
delete 7
print
output: finded + in_order + pre_order
yes
yes
yes
no
no
no
yes
yes
1 2 3 7 8 22
8 2 1 3 7 22
1 2 8 22
8 2 1 22
"""
import sys
class Node(object):
def __init__(self, data):
self.data = data
self.left, self.right = None, None
def insert(self, data):
"""
insert data according to BST rules
"""
if data < self.data:
if not self.left:
self.left = Node(data)
else:
self.left.insert(data)
# insert duplicate value to right
else:
if not self.right:
self.right = Node(data)
else:
self.right.insert(data)
return self.data
def find(self, data, parent=None):
"""
find node with given data
tree walk as insert goes
"""
if data < self.data:
if not self.left:
return None, None
return self.left.find(data=data, parent=self)
elif data > self.data:
if not self.right:
return None, None
return self.right.find(data=data, parent=self)
else:
return self, parent
def children_count(self):
"""
for choosing node deleting strategy
"""
cnt = 0
if self.left:
cnt += 1
if self.right:
cnt += 1
return cnt
def delete(self, data):
"""
delete node with given data
"""
node, parent = self.find(data)
if node:
children_count = node.children_count()
if children_count == 0:
# delete reference to parent
if parent.left is node:
parent.left = None
else:
parent.right = None
del node
elif children_count == 1:
# node's son becomes parents' son
if node.left:
n = node.left
else:
n = node.right
if parent:
if parent.left is node:
parent.left = n
else:
parent.right = n
del node
else:
# current node has two real children
# while the real successor couldn't have two real children
successor = node.right
while successor.left:
successor = successor.left
copy_data = successor.data
self.delete(copy_data)
node.data = copy_data
def pre_order(node):
if node:
print('', node.data, end='')
pre_order(node.left)
pre_order(node.right)
return None
def in_order(node):
if node:
in_order(node.left)
print('', node.data, end='')
in_order(node.right)
return None
def action(_command, _content):
# start all action from tree_root -- insert, find, delete
if _command.startswith('in'):
tree_root.insert(int(_content))
elif _command.startswith('fi'):
if tree_root.find(int(_content)) == (None, None):
print('no')
else:
print('yes')
elif _command.startswith('de'):
tree_root.delete(int(_content))
# print tree walk
else:
in_order(tree_root)
print('')
pre_order(tree_root)
print('')
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
array_length = int(_input[0])
command_list = list(map(lambda x: x.split(), _input[1:]))
# assert len(command_list) == array_length
flag, tree_root = False, None
for each in command_list:
command, content = each[0], each[-1]
if not flag:
if not command.startswith('in'):
raise SystemExit('Please insert tree root first.')
flag, tree_root = True, Node(data=int(content))
continue
action(command, content)
| #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
input:
18
insert 8
insert 2
insert 3
insert 7
insert 22
insert 1
find 1
find 2
find 3
find 4
find 5
find 6
find 7
find 8
print
delete 3
delete 7
print
output: finded + in_order + pre_order
yes
yes
yes
no
no
no
yes
yes
1 2 3 7 8 22
8 2 1 3 7 22
1 2 8 22
8 2 1 22
"""
import sys
class Node(object):
__slots__ = ('data', 'left', 'right')
def __init__(self, data):
self.data = data
self.left, self.right = None, None
def insert(self, data):
"""
insert data according to BST rules
"""
if data < self.data:
if not self.left:
self.left = Node(data)
else:
self.left.insert(data)
# insert duplicate value to right
else:
if not self.right:
self.right = Node(data)
else:
self.right.insert(data)
return self.data
def find(self, data, parent=None):
"""
find node with given data
tree walk as insert goes
"""
if data < self.data:
if not self.left:
return None, None
return self.left.find(data=data, parent=self)
elif data > self.data:
if not self.right:
return None, None
return self.right.find(data=data, parent=self)
else:
return self, parent
def children_count(self):
"""
for choosing node deleting strategy
"""
cnt = 0
if self.left:
cnt += 1
if self.right:
cnt += 1
return cnt
def delete(self, data):
"""
delete node with given data
"""
node, parent = self.find(data)
if node:
children_count = node.children_count()
if children_count == 0:
# delete reference to parent
if parent.left is node:
parent.left = None
else:
parent.right = None
del node
elif children_count == 1:
# node's son becomes parents' son
if node.left:
n = node.left
else:
n = node.right
if parent:
if parent.left is node:
parent.left = n
else:
parent.right = n
del node
else:
# current node has two real children
# while the real successor couldn't have two real children
successor = node.right
while successor.left:
successor = successor.left
copy_data = successor.data
self.delete(copy_data)
node.data = copy_data
def pre_order(node):
if node:
print('', node.data, end='')
pre_order(node.left)
pre_order(node.right)
return None
def in_order(node):
if node:
in_order(node.left)
print('', node.data, end='')
in_order(node.right)
return None
def action(_command, _content):
# start all action from tree_root -- insert, find, delete, print
if _command.startswith('in'):
tree_root.insert(int(_content))
elif _command.startswith('fi'):
if tree_root.find(int(_content)) == (None, None):
print('no')
else:
print('yes')
elif _command.startswith('de'):
tree_root.delete(int(_content))
# print tree walk
else:
in_order(tree_root)
print('')
pre_order(tree_root)
print('')
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
array_length = int(_input[0])
command_list = list(map(lambda x: x.split(), _input[1:]))
# assert len(command_list) == array_length
flag, tree_root = False, None
for each in command_list:
command, content = each[0], each[-1]
if not flag:
if not command.startswith('in'):
raise SystemExit('Please insert tree root first.')
flag, tree_root = True, Node(data=int(content))
continue
action(command, content)
| p02285 |
class Node:
def __init__(self, key):
self.key = key
self.right = None
self.left = None
class BST:
root = None
def insert(self, key):
x = self.root
y = None
z = Node(key)
while x != None:
y = x
if(z.key < y.key):
x = x.left
elif(y.key < z.key):
x = x.right
if y is None:
# 初回
self.root = z
else:
# yがターゲットになっているので
if z.key < y.key:
y.left = z
elif y.key < z.key:
y.right = z
def preorder(self, par):
if par is not None:
print(" {}".format(par.key), end="")
self.preorder(par.left)
self.preorder(par.right)
def inorder(self, par):
if par is not None:
self.inorder(par.left)
print(" {}".format(par.key), end="")
self.inorder(par.right)
def find(self, key):
x = self.root
y = None
z = Node(key)
flag = False
while x is not None:
y = x
if(z.key < y.key):
x = x.left
elif(y.key < z.key):
x = x.right
else:
flag = True
break
return flag
def delete(self, key):
if self.find(key):
x = self.root
y = None
while x is not None:
y = x
if(key < y.key):
x = x.left
elif(y.key < key):
x = x.right
else:
# rootが対象のノードの場合
break
if(x.key == key):
break
# yが親、子のxがdeleteの対象
x_children = [c for c in [x.left, x.right] if c is not None]
if len(x_children) == 0:
# 親から子の情報を削除
for c in [y.left, y.right]:
if c is not None and c.key == key:
# yの左右どっちにcがあるのか同定してx_children[0]をぶちこむ
which_side = [i for i, x in enumerate([y.left, y.right]) if x is not None and x.key == c.key][0]
if which_side == 0:
# 左側
y.left = None
else:
# 右側
y.right = None
elif len(x_children) == 1:
# 子の子を親の子にする（字面が妙な雰囲気）
for c in [y.left, y.right]:
if c is not None and c.key == key:
# yの左右どっちにcがあるのか同定してx_children[0]をぶちこむ
which_side = [i for i, x in enumerate([y.left, y.right]) if x is not None and x.key == c.key][0]
if which_side == 0:
# 左側
y.left = x_children[0]
else:
# 右側
y.right = x_children[0]
else:
# print("ふたこぶ")
# print("key: {}".format(key))
# 削除予定の子から左側のうち最大のものをとってきて、削除予定のやつを削除したのちそこに入れる
# とやったらなぜか右側の最小値で出すのが想定される解らしい どっちでもあってんだろが
min_child = x.right
# 一つ上の親を保持
par = x
while True:
if min_child.left is None:
break
par = min_child
min_child = min_child.left
# print("min_childの親が知りたい {}".format(par.key))
if(par.key == key):
# 初っ端で終了した（下る世代の数が1）
pass
else:
par.left = None
min_child.right = x.right
# 大本の削除対象のxの親であるyの左右どちらがxであるか同定し更新
x_side = [i for i, s in enumerate([y.left, y.right]) if s is not None and s.key == x.key][0]
# それを直接min_childとする
if x_side == 0:
# 左
y.left = min_child
else:
# 右
y.right = min_child
min_child.left = x.left
# print("---------------------------")
n = int(input())
bst = BST()
for _ in range(n):
query = input().split()
if query[0] == "insert":
bst.insert(int(query[1]))
elif query[0] == "find":
print("yes" if bst.find(int(query[1])) else "no")
elif query[0] == "print":
# 中間巡回順, 先行巡回順
root = bst.root
bst.inorder(root)
print()
bst.preorder(root)
print()
elif query[0] == "delete":
bst.delete(int(query[1]))
| class Node:
def __init__(self, key):
self.key = key
self.right = None
self.left = None
class BST:
root = None
def insert(self, key):
x = self.root
y = None
z = Node(key)
while x != None:
y = x
if(z.key < y.key):
x = x.left
elif(y.key < z.key):
x = x.right
if y is None:
# 初回
self.root = z
else:
# yがターゲットになっているので
if z.key < y.key:
y.left = z
elif y.key < z.key:
y.right = z
def preorder(self, par):
if par is not None:
print(" {}".format(par.key), end="")
self.preorder(par.left)
self.preorder(par.right)
def inorder(self, par):
if par is not None:
self.inorder(par.left)
print(" {}".format(par.key), end="")
self.inorder(par.right)
def find(self, key):
x = self.root
y = None
z = Node(key)
flag = False
while x is not None:
y = x
if(z.key < y.key):
x = x.left
elif(y.key < z.key):
x = x.right
else:
flag = True
break
return flag
def delete(self, key):
if self.find(key):
x = self.root
y = None
while x is not None:
y = x
if(key < y.key):
x = x.left
elif(y.key < key):
x = x.right
else:
# rootが対象のノードの場合
break
if(x.key == key):
break
# yが親、子のxがdeleteの対象
x_children = [c for c in [x.left, x.right] if c is not None]
if len(x_children) == 0:
# 親から子の情報を削除
for c in [y.left, y.right]:
if c is not None and c.key == key:
# yの左右どっちにcがあるのか同定してx_children[0]をぶちこむ
which_side = [i for i, x in enumerate([y.left, y.right]) if x is not None and x.key == c.key][0]
if which_side == 0:
# 左側
y.left = None
else:
# 右側
y.right = None
elif len(x_children) == 1:
# 子の子を親の子にする（字面が妙な雰囲気）
for c in [y.left, y.right]:
if c is not None and c.key == key:
# yの左右どっちにcがあるのか同定してx_children[0]をぶちこむ
which_side = [i for i, x in enumerate([y.left, y.right]) if x is not None and x.key == c.key][0]
if which_side == 0:
# 左側
y.left = x_children[0]
else:
# 右側
y.right = x_children[0]
else:
# 削除予定の子から左側のうち最大のものをとってきて、削除予定のやつを削除したのちそこに入れる
# とやったらなぜか右側の最小値で出すのが想定される解らしい どっちでもあってんだろが
min_child = x.right
# 一つ上の親を保持
par = x
while True:
if min_child.left is None:
break
par = min_child
min_child = min_child.left
if(par.key == key):
# 初っ端で終了した（下る世代の数が1）
pass
else:
# 下る世代の数が1より多い
par.left = None
min_child.right = x.right
# 大本の削除対象のxの親であるyの左右どちらがxであるか同定し更新
x_side = [i for i, s in enumerate([y.left, y.right]) if s is not None and s.key == x.key][0]
# それを直接min_childとする
if x_side == 0:
# 左
y.left = min_child
else:
# 右
y.right = min_child
# 更新
min_child.left = x.left
n = int(input())
bst = BST()
for _ in range(n):
query = input().split()
if query[0] == "insert":
bst.insert(int(query[1]))
elif query[0] == "find":
print("yes" if bst.find(int(query[1])) else "no")
elif query[0] == "print":
# 中間巡回順, 先行巡回順
root = bst.root
bst.inorder(root)
print()
bst.preorder(root)
print()
elif query[0] == "delete":
bst.delete(int(query[1]))
| p02285 |
import sys, os
from io import StringIO
class BinaryTree:
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
self.parent = None
def __init__(self):
self.root = None
self.output = StringIO()
def insert(self, key):
if self.root is None:
self.root = self.Node(key)
else:
root = self.root
temp = None
while True:
temp = root
if key > root.key:
root = root.right
if root is None:
temp.right = self.Node(key)
n = temp.right
n.parent = temp
break
else:
root = root.left
if root is None:
temp.left = self.Node(key)
n = temp.left
n.parent = temp
break
def ini_print_inorder(self):
self.output = StringIO()
self.print_inorder(self.root)
return self.output.getvalue()
def ini_print_preorder(self):
self.output = StringIO()
self.print_preorder(self.root)
return self.output.getvalue()
def print_inorder(self, node):
if node is not None:
self.print_inorder(node.left)
print(node.key, end = " ", file = self.output)
self.print_inorder(node.right)
def print_preorder(self, node):
if node is not None:
print(node.key, end = " ", file = self.output)
self.print_preorder(node.left)
self.print_preorder(node.right)
def test_insert(self, keys):
for k in keys:
self.insert(k)
def ini_find(self, key):
print(self.find(key))
def find(self, key):
root = self.root
while root is not None:
if key == root.key:
return "yes"
elif key < root.key:
root = root.left
else:
root = root.right
return "no"
def get_successor(self, node):
parent = node
while True:
node = node.left
if node is None:
return parent, parent.parent
parent = node
return None
def delete(self, key):
root = self.root
temp = root
act = ""
while root is not None:
if key == root.key:
# print(root.key, root.left, root.right, root.parent)
rest = None
new_leaf = None
if root.left is None:
new_leaf = root.right
elif root.right is None:
new_leaf = root.left
else:
new_leaf, new_leaf_parent = self.get_successor(root.right)
rest = 1
rest_left = root.left
rest_right = root.right
if new_leaf == rest_right:
rest_right = None
# print(rest_left.key, new_leaf.key, new_leaf_parent.key)
if act != "":
setattr(temp, act, new_leaf)
# print(new_leaf)
if new_leaf is not None:
new_node = getattr(temp, act)
setattr(new_node, "parent", temp)
# print(act, temp.key, key, new_leaf.key, new_node.parent.key)
else:
self.root = new_leaf
if rest is not None:
temp = getattr(temp, act)
if rest_right is not None:
setattr(temp, "right", rest_right)
setattr(rest_right, "parent", temp)
setattr(temp, "left", rest_left)
setattr(rest_left, "parent", temp)
setattr(new_leaf_parent, "left", None)
# print("00", temp.key, new_leaf.key, new_leaf.parent.key, new_leaf_parent.key)
return
else:
temp = root
if key < root.key:
root = root.left
act = "left"
else:
root = root.right
act = "right"
b = BinaryTree()
length = int(input())
for _ in range(length):
comm = input()
if comm[0] == "i":
com, num = comm.split(" ")
b.insert(int(num))
elif comm[0] == "p":
print(" ", end = "")
print((b.ini_print_inorder())[:-1])
print(" ", end = "")
print(b.ini_print_preorder()[:-1])
elif comm[0] == "f":
com, num = comm.split(" ")
b.ini_find(int(num))
else:
com, num = comm.split(" ")
b.delete(int(num))
| import sys, os
from io import StringIO
class BinaryTree:
class Node:
def __init__(self, key):
self.key = key
self.left = None
self.right = None
self.parent = None
def __init__(self):
self.root = None
self.output = StringIO()
def insert(self, key):
if self.root is None:
self.root = self.Node(key)
else:
root = self.root
temp = None
while True:
temp = root
if key > root.key:
root = root.right
if root is None:
temp.right = self.Node(key)
n = temp.right
n.parent = temp
break
else:
root = root.left
if root is None:
temp.left = self.Node(key)
n = temp.left
n.parent = temp
break
def ini_print_inorder(self):
self.output = StringIO()
self.print_inorder(self.root)
return self.output.getvalue()
def ini_print_preorder(self):
self.output = StringIO()
self.print_preorder(self.root)
return self.output.getvalue()
def print_inorder(self, node):
if node is not None:
self.print_inorder(node.left)
print(node.key, end = " ", file = self.output)
self.print_inorder(node.right)
def print_preorder(self, node):
if node is not None:
print(node.key, end = " ", file = self.output)
self.print_preorder(node.left)
self.print_preorder(node.right)
def test_insert(self, keys):
for k in keys:
self.insert(k)
def ini_find(self, key):
print(self.find(key))
def find(self, key):
root = self.root
while root is not None:
if key == root.key:
return "yes"
elif key < root.key:
root = root.left
else:
root = root.right
return "no"
def get_successor(self, node):
parent = node
while True:
node = node.left
if node is None:
return parent, parent.parent
parent = node
return None
def delete(self, key):
root = self.root
temp = root
act = ""
while root is not None:
if key == root.key:
# print(root.key, root.left, root.right, root.parent)
rest = None
new_leaf = None
if root.left is None:
new_leaf = root.right
elif root.right is None:
new_leaf = root.left
else:
new_leaf, new_leaf_parent = self.get_successor(root.right)
rest = 1
rest_left = root.left
rest_right = root.right
if new_leaf == rest_right:
rest_right = None
# print(rest_left.key, new_leaf.key, new_leaf_parent.key)
if act != "":
setattr(temp, act, new_leaf)
# print(new_leaf)
if new_leaf is not None:
new_node = getattr(temp, act)
setattr(new_node, "parent", temp)
# print(act, temp.key, key, new_leaf.key, new_node.parent.key)
else:
self.root = new_leaf
if rest is not None:
temp = getattr(temp, act)
if rest_right is not None:
setattr(temp, "right", rest_right)
setattr(rest_right, "parent", temp)
setattr(temp, "left", rest_left)
setattr(rest_left, "parent", temp)
setattr(new_leaf_parent, "left", None)
# print("00", temp.key, new_leaf.key, new_leaf.parent.key, new_leaf_parent.key)
return
else:
temp = root
if key < root.key:
root = root.left
act = "left"
else:
root = root.right
act = "right"
b = BinaryTree()
length = int(input())
for comm in sys.stdin:
if comm[0] == "i":
com, num = comm.split(" ")
b.insert(int(num))
elif comm[0] == "p":
print(" ", end = "")
print((b.ini_print_inorder())[:-1])
print(" ", end = "")
print(b.ini_print_preorder()[:-1])
elif comm[0] == "f":
com, num = comm.split(" ")
b.ini_find(int(num))
else:
com, num = comm.split(" ")
b.delete(int(num))
| p02285 |
import heapq
class Heapq:
def __init__(self, arr, desc=False):
if desc:
arr = [-a for a in arr]
self.sign = -1 if desc else 1
self.hq = arr
heapq.heapify(self.hq)
def pop(self):
return heapq.heappop(self.hq) * self.sign
def push(self, a):
heapq.heappush(self.hq, a * self.sign)
def top(self):
return self.hq[0] * self.sign
n = int(eval(input()))
A = list(map(int,input().split()))
heap_l = Heapq(A[:n])
heap_r = Heapq(A[2*n:],desc=True)
max_l = [0]*(n+1)
min_r = [0]*(n+1)
max_l[0] = sum(A[:n])
min_r[0] = sum(A[2*n:])
for i in range(n):
p = heap_l.pop()
heap_l.push(max(A[n+i],p))
max_l[i+1] = max_l[i]+max(0,A[n+i]-p)
q = heap_r.pop()
heap_r.push(min(A[-1-i-n],q))
min_r[i+1] = min_r[i]+min(0,A[-1-i-n]-q)
ans = -float('inf')
for i in range(n+1):
ans = max(ans,max_l[i]-min_r[-1-i])
print(ans) | from heapq import heappop, heappush, heapify
N = int(eval(input()))
A = list(map(int, input().split()))
L = A[:N]
heapify(L)
sumL = [sum(A[:N])]
for i in range(N):
x = heappop(L)
if x < A[N + i]:
sumL.append(sumL[-1] - x + A[N + i])
heappush(L, A[N + i])
else:
sumL.append(sumL[-1])
heappush(L, x)
R = list([-x for x in A[2 * N:]])
heapify(R)
sumR = [sum(A[2 * N:])]
for i in range(N):
x = -heappop(R)
if x > A[2 * N - 1 - i]:
sumR.append(sumR[-1] - x + A[2 * N - 1 - i])
heappush(R, -A[2 * N - 1 - i])
else:
sumR.append(sumR[-1])
heappush(R, -x)
res = -10**18
for i in range(N + 1):
res = max(res, sumL[i] - sumR[-1 - i])
print(res) | p03714 |
with open(0) as f:
N, *a = list(map(int, f.read().split()))
F = [x for x in a[:N]] #Fの要素は加えるか取り除くかの2択
C = [x for x in a[N:2*N]]
B = [-x for x in a[2*N:]] #Bの要素は引くか取り除くかの二択
import heapq as hq
hq.heapify(F)
hq.heapify(B)
#Cを二分し、前半はFと、後半はBとで演算を行う
#演算方法(c in C)
#前半：cがF[0]より大きければF[0]を取り除くN個の一つとし、cをスコアに加える
#後半：-cがB[0]より大きければB[0]を取り除くN個の一つとし、cをスコアから引く
#どちらも場合も条件を満たさない場合はそのｃを取り除くN個の一つとする
#計算量：O(N*N*logN)
#途中計算をメモして計算量軽減
from copy import deepcopy
memoF = [[]] * (N+1) #C[:i]を前半としたときのFとの演算結果
memoF[0] = deepcopy(F)
memoB = [[]] * (N+1) #C[i:]を後半としたときのBとの演算結果
memoB[N] = deepcopy(B)
for i in range(N):
if C[i] > F[0]:
hq.heapreplace(F, C[i])
if -C[N-1-i] > B[0]:
hq.heapreplace(B, -C[N-1-i])
memoF[i+1] = deepcopy(F)
memoB[N-1-i] = deepcopy(B)
Scores = [sum(memoF[i])+sum(memoB[i]) for i in range(N+1)]
ans = max(Scores)
print(ans) | with open(0) as f:
N, *a = list(map(int, f.read().split()))
F = [x for x in a[:N]] #Fの要素は加えるか取り除くかの2択
C = [x for x in a[N:2*N]]
B = [-x for x in a[2*N:]] #Bの要素は引くか取り除くかの二択
import heapq as hq
#ヒープにして常に最小値を追跡
hq.heapify(F)
hq.heapify(B)
#Cを二分し、前半はFと、後半はBとで演算を行う
#演算方法(c in C)
#前半：cがF[0]より大きければF[0]を取り除くN個の一つとし、cをスコアに加える
#後半：-cがB[0]より大きければB[0]を取り除くN個の一つとし、cをスコアから引く
#どちらも場合も条件を満たさない場合はそのｃを取り除くN個の一つとする
#計算量：O(N*N*logN)
#途中計算をメモして計算量軽減
from copy import deepcopy
memoF = [0] * (N+1) #C[:i]を前半としたときのFとの演算結果の要素和
memoF[0] = sum(F)
memoB = [0] * (N+1) #C[i:]を後半としたときのBとの演算結果の要素和
memoB[N] = sum(B)
for i in range(N):
if C[i] > F[0]:
memoF[i+1] = memoF[i] + C[i] - hq.heapreplace(F, C[i])
else:
memoF[i+1] = memoF[i]
if -C[N-1-i] > B[0]:
memoB[N-1-i] = memoB[N-i] - C[N-1-i] - hq.heapreplace(B, -C[N-1-i])
else:
memoB[N-1-i] = memoB[N-i]
Scores = [memoF[i]+memoB[i] for i in range(N+1)]
ans = max(Scores)
print(ans) | p03714 |
import heapq
N = int(eval(input()))
A = list(map(int, input().split()))
# 準備
left, right = A[:N], A[-N:]
right = list([-x for x in right])
left_sum, right_sum = [sum(left)], [-sum(right)]
heapq.heapify(left)
heapq.heapify(right)
# left処理
for i in range(N, 2*N):
heapq.heappush(left, A[i])
low = heapq.heappop(left)
left_sum.append(left_sum[-1] + A[i] - low)
# right処理
for i in range(2*N-1, N-1, -1):
heapq.heappush(right, -A[i])
high = -heapq.heappop(right)
right_sum.append(right_sum[-1] + A[i] - high)
# rightを逆順にしてleftの挙動と合わせる
right_sum = right_sum[::-1]
ans = max([l-r for l, r in zip(left_sum, right_sum)])
print(ans)
| import heapq
N = int(eval(input()))
A = list(map(int, input().split()))
Left, Right = A[:N], list([-a for a in A[-N:]])
heapq.heapify(Left)
heapq.heapify(Right)
Left_SUM, Right_SUM = [sum(Left)], [-sum(Right)]
M = A[N:2*N]
# 左側
for k in range(N):
lo = heapq.heappushpop(Left, M[k])
Left_SUM.append(Left_SUM[-1] + M[k] - lo)
# 右側
for k in reversed(list(range(N))):
hi = -heapq.heappushpop(Right, -M[k])
Right_SUM.append(Right_SUM[-1] + M[k] - hi)
# 最大値を計算
ans = max([l - r for l, r in zip(Left_SUM, Right_SUM[::-1])])
print(ans)
| p03714 |
import heapq
import copy
n = int(eval(input()))
alist = list(map(int, input().split()))
ante, post = alist[:n], alist[-n:]
startante = sum(ante)
startpost = sum(post)
post = list([-x for x in post])
heapq.heapify(ante)
heapq.heapify(post)
ans = None
for k in range(n+1):
_ante = copy.deepcopy(ante)
_post = copy.deepcopy(post)
antesum = startante
postsum = startpost
for a in alist[n: n+k]:
minante = heapq.heappushpop(_ante, a)
antesum = antesum + a - minante
for a in alist[n+k: 2*n]:
maxpost = heapq.heappushpop(_post, -a)
postsum = postsum + a + maxpost
if ans is None:
ans = antesum - postsum
elif ans < antesum - postsum:
ans = antesum - postsum
print(ans)
| import heapq
n = int(eval(input()))
alist = list(map(int, input().split()))
ante, post = alist[:n], alist[-n:]
antesums = [0 for _ in range(n+1)]
postsums = [0 for _ in range(n+1)]
antesums[0] = sum(ante)
postsums[0] = sum(post)
post = list([-x for x in post])
heapq.heapify(ante)
heapq.heapify(post)
for k in range(n):
minante = heapq.heappushpop(ante, alist[n+k])
antesums[k+1] = antesums[k] + alist[n+k] - minante
maxpost = heapq.heappushpop(post, -alist[2*n-k-1])
postsums[k+1] = postsums[k] + alist[2*n-k-1] + maxpost
ans = -sum(alist)
for k in range(n+1):
if ans < antesums[k] - postsums[-k-1]:
ans = antesums[k] - postsums[-k-1]
print(ans)
| p03714 |
N=int(eval(input()))
A=list(map(int,input().split()))
from collections import deque
import bisect
x,y,z=[],[],[]
for i in range(3*N):
if 0<=i<N:x.append(A[i])
elif N<=i<2*N:y.append(A[i])
elif 2*N<=i<3*N:z.append(A[i])
a=x+y
a.sort()
mae=[sum(a[N:2*N])]
line=N-1
used=set()
for i in range(N-1,-1,-1):
while line in used:
line-=1
idx=bisect.bisect_left(a,y[i])
while idx in used:
idx+=1
used|={idx,}
if line<idx:
mae.append(mae[-1]-a[idx]+a[line])
line-=1
elif line==idx:
mae.append(mae[-1])
line-=1
else:
mae.append(mae[-1])
b=y+z
b.sort()
ushiro=[-1*sum(b[0:N])]
line=N
used=set()
for i in range(N):
while line in used:
line+=1
idx=bisect.bisect_left(b,y[i])
while idx in used:
idx+=1
used|={idx,}
if idx<line:
ushiro.append(ushiro[-1]+b[idx]-b[line])
line+=1
elif idx==line:
ushiro.append(ushiro[-1])
line+=1
else:
ushiro.append(ushiro[-1])
ans=-1*float('inf')
for i in range(N+1):
ans=max(ans,mae[i]+ushiro[N-i])
print(ans) | from heapq import heappush,heappop
dataX=[]
dataY=[]
mae=dict()
ushiro=dict()
N=int(eval(input()))
A=list(map(int,input().split()))
X=A[0:N]
Y=A[N:2*N]
Z=A[2*N:3*N]
for i in range(N):
heappush(dataX,X[i])
heappush(dataY,-1*Z[i])
mae[0]=sum(X)
ushiro[0]=-1*sum(Z)
for i in range(1,N+1):
mae[i]=mae[i-1]+Y[i-1]
heappush(dataX,Y[i-1])
mae[i]-=heappop(dataX)
ushiro[i]=ushiro[i-1]-Y[N-i]
heappush(dataY,-1*Y[N-i])
ushiro[i]-=heappop(dataY)
ans=-1*float('inf')
for i in range(N+1):
ans=max(ans,mae[i]+ushiro[N-i])
print(ans) | p03714 |
N = int(eval(input()))
import heapq as h
A = list(map(int, input().split()))
# use 0 based index
sum_red, sum_blue = [], []
head = A[:N]
tail = [-x for x in A[-N:]]
h.heapify(head)
h.heapify(tail)
sum_red.append(sum(head))
sum_blue.append(-sum(tail))
for k in range(N, 2*N):
h.heappushpop(head, A[k])
sum_red.append(sum(head))
h.heappushpop(tail, -A[-k-1])
sum_blue.append(-sum(tail))
print((max([r-b for r, b in zip(sum_red, sum_blue[::-1])])))
| N = int(eval(input()))
import heapq as h
A = list(map(int, input().split()))
# use 0 based index
sum_red, sum_blue = [], []
head = A[:N]
tail = [-x for x in A[-N:]]
h.heapify(head)
h.heapify(tail)
sum_red.append(sum(head))
sum_blue.append(-sum(tail))
# keypoint: いちいちsumすると線形時間かかるのでsum_hoge[-1]でアクセスする
for k in range(N, 2*N):
num_sub = h.heappushpop(head, A[k])
sum_red.append(sum_red[-1]-num_sub+A[k])
num_sub = -h.heappushpop(tail, -A[-k-1])
sum_blue.append(sum_blue[-1]-num_sub+A[-k-1])
print((max([r-b for r, b in zip(sum_red, sum_blue[::-1])])))
| p03714 |
import heapq
N = int( eval(input()))
A = list( map( int, input().split()))
fsum = [0]*(N+1)
bsum = [0]*(N+1)
forward = A[:N]
back = A[2*N:]
back = list([-x for x in back])
heapq.heapify(forward)
heapq.heapify(back)
fsum[0] = sum(forward)
bsum[N] = -sum(back)
for i in range(1,N+1):
heapq.heappushpop(forward, A[N+i-1])
fsum[i] = sum(forward)
heapq.heappushpop(back, -A[2*N-i])
bsum[N-i] = -sum(back)
ans = fsum[0] - bsum[0]
for i in range(1,N+1):
ans = max(ans, fsum[i] - bsum[i])
print(ans) | import heapq
N = int( eval(input()))
A = list( map( int, input().split()))
fsum = [0]*(N+1)
bsum = [0]*(N+1)
forward = A[:N]
back = A[2*N:]
back = list([-x for x in back])
heapq.heapify(forward)
heapq.heapify(back)
fsum[0] = sum(forward)
fsumnow = fsum[0]
bsum[N] = -sum(back)
bsumnow = bsum[N]
for i in range(1,N+1):
heapq.heappush(forward, A[N+i-1])
fsumnow += A[N+i-1]
fsumnow -= heapq.heappop(forward)
fsum[i] = fsumnow
heapq.heappush(back, -A[2*N-i])
bsumnow += A[2*N-i]
bsumnow += heapq.heappop(back)
bsum[N-i] = bsumnow
ans = fsum[0] - bsum[0]
for i in range(1,N+1):
ans = max(ans, fsum[i] - bsum[i])
print(ans) | p03714 |
N=int(eval(input()))
alist=list(map(int,input().split()))
#dp[3N][N]
dp=[[0 for _ in range(N+1)] for _ in range(3*N+1)]
for i in range(1,3*N+1):
for j in range(1,N+1):
if i<j:
break
dp[i][j]=max(dp[i-1][j],alist[i-1]+dp[i-1][j-1])
#print(dp)
alist_rev=alist[::-1]
dp_rev=[[float("inf") for _ in range(N+1)] for _ in range(3*N+1)]
dp_rev[0][0]=0
for i in range(1,3*N+1):
dp_rev[i][0]=0
for j in range(1,N+1):
if i<j:
break
dp_rev[i][j]=min(dp_rev[i-1][j],alist_rev[i-1]+dp_rev[i-1][j-1])
#print(dp_rev)
slist=[]
for i in range(3*N+1):
slist.append(dp[i][N])
slist_rev=[]
for i in range(3*N+1):
slist_rev.append(dp_rev[-i-1][N])
#print(slist)
#print(slist_rev)
answer=-float("inf")
for i in range(N,2*N+1):
score=slist[i]-slist_rev[i]
answer=max(score,answer)
print(answer) | N=int(eval(input()))
alist=list(map(int,input().split()))
answer=-float("inf")
for i in range(N,2*N+1):
alist1=alist[:i]
alist2=alist[i:]
#print(alist1,alist2)
alist1.sort(reverse=True)
alist2.sort()
maxn_a1=sum(alist1[:N])
minn_a2=sum(alist2[:N])
#print(maxn_a1,minn_a2)
answer=max(answer,maxn_a1-minn_a2)
print(answer) | p03714 |
import copy as cp
n = int(eval(input()))
a = input().split()
a = [int(m) for m in a]
t1 = []
t2 = []
t3 = []
for i in range(3 * n):
if i < (3 * n) // 3:
t1.append(a[i])
elif (3 * n) // 3 <= i < (3 * n) // 3 * 2:
t2.append(a[i])
else:
t3.append(a[i])
t1.sort()
t3.sort(reverse=True)
t2c = cp.deepcopy(t2)
t1c = cp.deepcopy(t1)
t3c = cp.deepcopy(t3)
y = []
for i in range(n + 1):
if i == 0:
u = sum(t1c)
for j in range(n + 1):
if j == 0:
w = sum(t3c)
x = u - w
y.append(x)
else:
t3c.sort(reverse=True)
t3c = t3c[1:] + t2c[-1:]
t2c = t2c[:-1]
w = sum(t3c)
x = u - w
y.append(x)
t1c = t1
t2c = t2
t3c = t3
else:
t1c.sort()
t1c = t1c[1:] + t2c[0:1]
t2c = t2c[1:]
u = sum(t1c)
for j in range(n + 1 - i):
if j == 0:
w = sum(t3c)
x = u - w
y.append(x)
else:
t3c.sort(reverse=True)
t3c = t3c[1:] + t2c[-1:]
t2c = t2c[:-1]
w = sum(t3c)
x = u - w
y.append(x)
t2c = t2
t3c = t3
t1c = t1
print((max(y))) | from heapq import heappush, heappop
n = int(eval(input()))
a = input().split()
a = [int(m) for m in a]
t1 = []
t2 = []
mt3 = []
for i in range(3 * n):
if i < (3 * n) // 3:
t1.append(a[i])
elif (3 * n) // 3 <= i < (3 * n) // 3 * 2:
t2.append(a[i])
else:
mt3.append(-a[i])
t1.sort()
mt3.sort()
t1sumli = [sum(t1)]
t3sumli = [-sum(mt3)]
for i in range(n):
pp = heappop(t1)
heappush(t1, max(pp, t2[i]))
t1sumli.append(t1sumli[-1] - pp + max(pp, t2[i]))
for i in range(n - 1, -1, -1):
qq = -heappop(mt3)
heappush(mt3, -min(qq, t2[i]))
t3sumli.append(t3sumli[-1] - qq + min(qq, t2[i]))
sumli = []
for i in range(n + 1):
sumli.append(t1sumli[i] - t3sumli[-i-1])
print((max(sumli))) | p03714 |
from heapq import heapify, heapreplace
n = int(eval(input()))
a = list(map(int, input().split()))
a1 = a[:n]
heapify(a1)
a2 = a[n:2*n]
a3 = [-i for i in a[2*n:]]
heapify(a3)
b1 = [sum(a1)]
b2 = [sum(a3)]
for i in range(n):
b1.append(a2[i]-heapreplace(a1, a2[i]))
b2.append(-heapreplace(a3, -a2[n-i-1])-a2[n-i-1])
for i in range(n):
b1[i+1] += b1[i]
b2[i+1] += b2[i]
accu = []
mx = b1[0]
for i in b1:
mx = max(mx, i)
accu.append(mx)
ans = -10**16
mx = b2[0]
for i in range(n+1):
mx = max(mx, b2[i])
ans = max(ans, mx+accu[n-i])
print(ans) | from heapq import heapify, heappushpop
n = int(eval(input()))
a = list(map(int, input().split()))
a1 = a[:n]
heapify(a1)
a2 = a[n:2*n]
a3 = [-i for i in a[2*n:]]
heapify(a3)
b1 = [sum(a1)]
b2 = [sum(a3)]
for i in range(n):
b1.append(b1[-1]+a2[i]-heappushpop(a1, a2[i]))
b2.append(b2[-1]-heappushpop(a3, -a2[n-i-1])-a2[n-i-1])
ans = b1[0]+b2[n]
for i in range(n+1):
ans = max(ans, b1[i]+b2[n-i])
print(ans) | p03714 |
def f(a):
q=a[:n];s=sum(q);heapify(q);yield s
for e in a[n:2*n]:s+=e-heappushpop(q,e);yield s
from heapq import*;r=reversed;n,*a=list(map(int,open(0).read().split()));print((max(list(map(sum,list(zip(f(a),r(list(f([-e for e in r(a)])))))))))) | def f(a):
q=a[:n];s=sum(q);heapify(q);yield s
for e in a[n:2*n]:s+=e-heappushpop(q,e);yield s
from heapq import*;n,*a=list(map(int,open(0).read().split()));print((max(list(map(sum,list(zip(f(a),list(f([-e for e in a[::-1]]))[::-1]))))))) | p03714 |
def f(x):
y=x[:n];heapify(y);z=sum(y);s=[z]
for i in x[n:n*2]:z+=i-heappushpop(y,i);s+=[z]
return s
from heapq import*;n,*a=list(map(int,open(0).read().split()));print((max(list(map(sum,list(zip(f([-i for i in a[n:][::-1]]),f(a)[::-1]))))))) | def f(x):
y=x[:n];heapify(y);z=sum(y);yield z
for i in x[n:n*2]:z+=i-heappushpop(y,i);yield z
from heapq import*;n,*a=list(map(int,open(0).read().split()));print((max(list(map(sum,list(zip(f([-i for i in a[n:][::-1]]),list(f(a))[::-1]))))))) | p03714 |
import heapq
N=int(eval(input()))
A=list(map(int, input().split()))
A_rev = [-x for x in A[::-1]]#逆順にして各要素を-1倍する
ans=-float("inf")
for k in range(N, 2*N+1):
left=A[:k]
right=A_rev[:(3*N-k)]
heapq.heapify(left)
heapq.heapify(right)
for _ in range(k-N):
heapq.heappop(left)
for _ in range(2*N-k):
heapq.heappop(right)
ans= max(sum(left)+sum(right), ans)
print(ans) | #########################ABC解説実装#########################
import heapq
N=int(eval(input()))
A=list(map(int, input().split()))
left, right = A[:N], [-1 * i for i in A[2*N:]]
sum_left, sum_right = sum(left), sum(right)
results = [0] * (N+1)
results[0] = sum_left
results[N] = sum_right
heapq.heapify(left)
heapq.heapify(right)
for i in range(N, 2*N):
v = A[i]
p = heapq.heappushpop(left, v)
sum_left += v - p
results[i-N+1] += sum_left
for i in range(2*N-1, N-1, -1):
v = -1 * A[i]
p = heapq.heappushpop(right, v)
sum_right += v - p
results[i-N] += sum_right
print((max(results))) | p03714 |
import heapq
N = int(eval(input()))
a_list = list(map(int, input().split()))
max_score = - float("inf")
red_list = a_list[:N]
blue_list = [-a for a in a_list[2 * N:]]
heapq.heapify(red_list)
heapq.heapify(blue_list)
red_sum = [sum(red_list)]
blue_sum = [sum(blue_list)]
for i in range(N, 2 * N):
heapq.heappush(red_list, a_list[i])
item = heapq.heappop(red_list)
red_sum.append(max(red_sum[-1], red_sum[-1] + a_list[i] - item))
for i in range(2 * N - 1, N - 1, -1):
heapq.heappush(blue_list, -a_list[i])
item = heapq.heappop(blue_list)
blue_sum.append(max(blue_sum[-1], blue_sum[-1] - a_list[i] - item))
for i in range(N+1):
score = red_sum[i] + blue_sum[-(i + 1)]
if max_score < score:
max_score = score
print(max_score)
| import heapq
N = int(eval(input()))
a_list = list(map(int, input().split()))
max_score = - float("inf")
red_list = a_list[:N]
blue_list = [-a for a in a_list[2 * N:]]
heapq.heapify(red_list)
heapq.heapify(blue_list)
red_sum = [sum(red_list)]
blue_sum = [sum(blue_list)]
for i in range(N, 2 * N):
heapq.heappush(red_list, a_list[i])
item = heapq.heappop(red_list)
red_sum.append(red_sum[-1] + a_list[i] - item)
for i in range(2 * N - 1, N - 1, -1):
heapq.heappush(blue_list, -a_list[i])
item = heapq.heappop(blue_list)
blue_sum.append(blue_sum[-1] - a_list[i] - item)
for i in range(N+1):
score = red_sum[i] + blue_sum[-(i + 1)]
if max_score < score:
max_score = score
print(max_score)
| p03714 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
def main():
N = I()
A = LI()
wakeme = N
Aleftsum = [0 for _ in range(3*N+1)]
leftA = [x for x in A[:N]]
heapq.heapify(leftA)
subsum = sum(leftA)
Aleftsum[wakeme] = subsum
for i in range(N):
heapq.heappush(leftA, A[wakeme + i])
subsum += A[wakeme + i]
subsum -= heapq.heappop(leftA)
Aleftsum[wakeme+i+1] = subsum
Arightsum = [0 for _ in range(3*N+1)]
rightA = [-x for x in A[-N:]]
heapq.heapify(rightA)
subsum = sum(rightA)
wakeme = 2*N
Arightsum[wakeme] = -subsum
for i in range(1, N+1):
heapq.heappush(rightA, -A[wakeme-i])
subsum -= A[wakeme - i]
subsum -= heapq.heappop(rightA)
Arightsum[wakeme - i] = -subsum
ans = -inf
for i in range(N, 2*N+1):
ans = max(ans, Aleftsum[i] - Arightsum[i])
print(ans)
main()
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
def main():
N = I()
A = LI()
wakeme = N
Aleftsum = [0 for _ in range(3*N+1)]
Arightsum = [0 for _ in range(3*N+1)]
leftA = [x for x in A[:N]]
rightA = [-x for x in A[-N:]]
heapq.heapify(leftA)
heapq.heapify(rightA)
lsum = sum(leftA)
rsum = sum(rightA)
Aleftsum[wakeme] = lsum
Arightsum[2*N] = -rsum
# [0, N)から[0, 2N)までの和が欲しい
# Aleftsum(i): [0, i)までの上位N個の和
# [2N, 3N)から[N, 3N)までの和が欲しい
# Arightsum(i): [i, 3N)までの上位N個の和
for i in range(N):
# [0, N+1)から[0, 2N)までやる。
# [0, wakeme + i + 1)の和を計算する。
# wakeme=Nなので、wakeme + i + 1 = 2N -> i = N - 1
newl = A[wakeme + i]
lsum += newl
lsum -= heapq.heappushpop(leftA, newl)
Aleftsum[wakeme+i+1] = lsum
# [2N-1, 3N)から[N, 3N)までやる。
# r_wakeme = 2N-1として、
# r_wakeme - i = 2N - 1 -> i=0
# r_wakeme - i = N -> i=N-1
newr = A[2*N-1 - i]
rsum -= newr
rsum -= heapq.heappushpop(rightA, -newr)
Arightsum[2*N-1 - i] = -rsum
ans = -inf
for i in range(N, 2*N+1):
ans = max(ans, Aleftsum[i] - Arightsum[i])
print(ans)
main()
| p03714 |
from heapq import heapify, heappop, heappush
from collections import deque
n = int(eval(input()))
a = list(map(int, input().split()))
L = a[:n]
sum_l = [sum(L)]
heapify(L)
ML = a[n:2 * n]
ML = deque(ML)
R = list([(-1) * x for x in a[2 * n:]])
sum_r = [sum(R)] # あとでReverseする
heapify(R)
MR = list([(-1) * x for x in a[n:2 * n]])
MR = deque(MR)
for i in range(n):
add_to_l = ML.popleft()
heappush(L, add_to_l)
subtract_to_l = heappop(L)
t = sum_l[-1] + add_to_l - subtract_to_l
sum_l.append(t)
# print(sum_l)
for i in range(n):
add_to_r = MR.pop()
heappush(R, add_to_r)
subtract_to_r = heappop(R)
t = sum_r[-1] + add_to_r - subtract_to_r
sum_r.append(t)
# print(sum_r)
sum_r = sum_r[::-1]
ans = sum_l[0] + sum_r[0]
for i in range(1, n + 1):
t = sum_l[i] + sum_r[i]
ans = max(ans, t)
print(ans) | def main():
from heapq import heappush, heappushpop
n = int(eval(input()))
*a, = list(map(int, input().split())) # [0,n),[n,2n),[2n,3n)
to_rm = [0] * (n * 3)
h = []
for x in a[:n]:
heappush(h, x)
mid = tuple(enumerate(a[n:n * 2], n))
t = 0
for i, x in mid:
mi = heappushpop(h, x)
t += mi
to_rm[i] = -t
h = []
for x in a[n * 2:n * 3]:
heappush(h, -x)
t = 0
for i, x in reversed(mid):
ma = -heappushpop(h, -x)
t += ma
to_rm[i - 1] += t
tot = sum(a)
ret = -10 ** 30
s = sum(a[:n - 1])
for tail in range(n - 1, n * 2):
s += a[tail]
ret = max(ret, s - (tot - s) + to_rm[tail]) # [0,tail]=前半
print(ret)
if __name__ == '__main__':
main()
| p03714 |
# -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/arc074/editorial.pdf
・優先度付きキュー
"""
import sys
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 9)
from heapq import heappush, heappushpop
N = int(eval(input()))
aN = list(map(int, input().split()))
mids = aN[N:N*2]
L = []
R = []
for i in range(N):
# とりあえず前後半確定の部分をキューに詰める
heappush(L, aN[i])
heappush(R, -aN[i+N*2])
# 未確定の真ん中1/3について調べていく
l_sum = [0] * (N+1)
l_sum[0] = sum(aN[:N])
for i in range(N):
# ある値をpushして最小値をpopする
num = heappushpop(L, mids[i])
# それに合わせて合計値も更新
l_sum[i+1] = l_sum[i] + mids[i] - num
# 後半部分は逆方向からやる
r_sum = [0] * (N+1)
r_sum[N] = sum(aN[N*2:])
for i in range(N-1, -1, -1):
# 正負逆転させれば最大値にも使える
num = -(heappushpop(R, -mids[i]))
r_sum[i] = r_sum[i+1] + mids[i] - num
ans = -float('inf')
for i in range(N+1):
ans = max(l_sum[i] - r_sum[i], ans)
print(ans)
| # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/arc074/editorial.pdf
・優先度付きキュー
"""
import sys
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 9)
from heapq import heapify, heappushpop
N = int(eval(input()))
aN = list(map(int, input().split()))
mids = aN[N:N*2]
# とりあえず前後半確定の部分をキューに詰める
L = aN[:N]
R = [-aN[i] for i in range(N*2, N*3)]
heapify(L)
heapify(R)
# 未確定の真ん中1/3について調べていく
l_sum = [0] * (N+1)
l_sum[0] = sum(aN[:N])
for i in range(N):
# ある値をpushして最小値をpopする
num = heappushpop(L, mids[i])
# それに合わせて合計値も更新
l_sum[i+1] = l_sum[i] + mids[i] - num
# 後半部分は逆方向からやる
r_sum = [0] * (N+1)
r_sum[N] = sum(aN[N*2:])
for i in range(N-1, -1, -1):
# 正負逆転させれば最大値にも使える
num = -(heappushpop(R, -mids[i]))
r_sum[i] = r_sum[i+1] + mids[i] - num
ans = -float('inf')
for i in range(N+1):
ans = max(l_sum[i] - r_sum[i], ans)
print(ans)
| p03714 |
import heapq, copy
N = int(eval(input()))
A = [int(i) for i in input().split()]
Aleft = copy.deepcopy(A[:N])
sumLeft = sum(Aleft)
heapq.heapify(Aleft)
Aright = sorted(copy.deepcopy(A[N:]))
Rlim = Aright[N-1]
sumRight = sum(Aright[:N])
score = sumLeft - sumRight
for i in range(N):
a = A[N+i]
heapq.heappush(Aleft, a)
sumLeft += a - heapq.heappop(Aleft)
Aright.remove(a)
if a <= Rlim:
Rlim = Aright[N-1]
sumRight += Rlim - a
score = max(score, sumLeft - sumRight)
print(score) | import heapq
N = int(eval(input()))
A = [int(i) for i in input().split()]
sumLeft = [0] * (N+1) #A[:N+i]中のN要素の和の最大値のリスト
sumLeft[0] = sum(A[:N])
Aleft = A[:N]
heapq.heapify(Aleft)
sumRight = [0] * (N+1) #A[N+i:]中のN要素の和の最小値のリスト
sumRight[-1] = sum(A[2*N:])
Aright = [-1*i for i in A[2*N:]] #最大値をpopするために要素を-1倍しておく
heapq.heapify(Aright)
for i in range(1, N+1):
a = A[N+i-1]
b = -1 * A[2*N-i]
sumLeft[i] = sumLeft[i-1] + a - heapq.heappushpop(Aleft, a)
sumRight[-1-i] = sumRight[-i] + heapq.heappushpop(Aright, b) - b
score = sumLeft[0] - sumRight[0]
for i in range(1, N+1):
score = max(score, sumLeft[i] - sumRight[i])
print(score) | p03714 |
import itertools
import copy
N=eval(input())
a=[]
a=list(map(int, input().split()))
#print N
#print a
n_l=[ i for i in range(len(a))]
#print n_l
c = list(itertools.combinations(n_l,N))
#c=[(3,1)]
#print c
score=0.1
for i in c:
a_t=copy.deepcopy(a)
#print "#Loop start"
#print i
for j in range(N):
a_t.pop(i[j]-j)
#print a_t
a1=list(zip(*[iter(a_t)]*N))
#print a1
if score==0.1 or score<sum(a1[0])-sum(a1[1]):
score=sum(a1[0])-sum(a1[1])
#print "score::"+str(score)
print(score) | import itertools
from heapq import heapify,heappush,heappop
N=eval(input())
a=[]
a=list(map(int, input().split()))
a1=a[0:N]
#print a1
heapify(a1)
l1=[]
sum_a1=sum(a1)
l1.append(sum_a1)
# Max
for i in range(N,2*N):
if a[i]>a1[0]:
sum_a1=sum_a1+a[i]-a1[0]
heappop(a1)
heappush(a1, a[i])
l1.append(sum_a1)
l2=[]
a2=[ -x for x in a[2*N:3*N]]
heapify(a2)
sum_a2=-1*sum(a2)
l2.append(sum_a2)
# Min
for i in reversed(list(range(N,2*N))):
if a[i]<-1*a2[0]:
sum_a2=sum_a2+a[i]-(-1*a2[0])
heappop(a2)
heappush(a2,-1*a[i])
l2.append(sum_a2)
ans=[]
for i in range(N+1):
ans.append(l1[i]-l2[N-i])
print(max(ans))
| p03714 |
import itertools
import datetime
from heapq import heapify,heappush,heappop
N=eval(input())
a=[]
a=list(map(int, input().split()))
a1=a[:N]
#print a1
heapify(a1)
l1=[]
sum_a1=sum(a1)
l1.append(sum_a1)
# Max
for i in range(N,2*N):
if a[i]>a1[0]:
sum_a1=sum_a1+a[i]-a1[0]
heappop(a1)
heappush(a1, a[i])
l1.append(sum_a1)
l2=[]
a2=[ -x for x in a[2*N:]]
heapify(a2)
sum_a2=-1*sum(a2)
l2.append(sum_a2)
# Min
for i in reversed(list(range(N,2*N))):
if a[i]<-1*a2[0]:
sum_a2=sum_a2+a[i]-(-1*a2[0])
heappop(a2)
heappush(a2,-1*a[i])
l2.append(sum_a2)
ans=[]
for i in range(N+1):
heappush(ans, -1*(l1[i]-l2[N-i]))
print(ans[0]*-1)
| n=int(eval(input()))
import heapq
a=list(map(int, input().split()))
q=a[:n]
heapq.heapify(q)
x=[sum(q)]
for k in range(n,2*n):
v=heapq.heappushpop(q,a[k])
x.append(x[-1]+a[k]-v)
a=a[::-1]
q=[-v for v in a[:n]]
heapq.heapify(q)
y=[-sum(q)]
for k in range(n,2*n):
v=-heapq.heappushpop(q,-a[k])
y.append(y[-1]+a[k]-v)
print((max(v-w for v,w in zip(x,y[::-1])))) | p03714 |
from heapq import heapify,heappush, heappop
N=eval(input())
A=list(map( int, input().split() ))
q=A[:N]
heapify(q)
q_sum=sum(q)
B=[ float("-inf") for i in range(3*N)]
B[N-1]=q_sum
for i in range(N,2*N):
x=A[i]
if x>q[0]:
tmp=heappop(q)
q_sum-=tmp
q_sum+=x
heappush(q,x)
B[i]=q_sum
q=[x*-1 for x in A[2*N:]]
heapify(q)
q_sum=sum(q)*-1
B[2*N-1]-=q_sum
for i in range(2*N-1,N-1,-1):
x=A[i]*-1
if q[0]<x:
tmp=heappop(q)
q_sum-=tmp*-1
q_sum+=x*-1
heappush(q,x)
B[i-1]-=q_sum
print(max(B)) | from heapq import heapify,heappush, heappop
N=eval(input())
A=list(map(int, input().split()))
hq1=A[:N]
heapify(hq1)
sum1=sum(hq1)
T1=[]
T1.append(sum1)
for i in range(N, 2*N):
x=A[i]
if hq1[0]<x:
u=heappop(hq1)
heappush(hq1,x)
sum1+=(x-u)
T1.append(sum1)
hq2=[x*-1 for x in A[2*N:]]
sum2=-1*sum(hq2)
heapify(hq2)
T2=[]
T2.append(sum2)
for i in range(2*N-1,N-1,-1):
x=A[i]
if x*-1 > hq2[0]<x:
u=heappop(hq2)
heappush(hq2,x*-1)
sum2+=u+x
T2.append(sum2)
T2.reverse()
ans=float("-inf")
for x, y in zip(T1, T2):
ans=max(ans , x-y)
print(ans)
| p03714 |
from heapq import heappush, heappop
n=int(eval(input()))
a=list(map(int,input().split()))
l=[]
for v in a[:n]:
heappush(l,v)
suml=[sum(a[:n])]
for i in range(n):
suml.append(suml[i]+a[n+i])
heappush(l,a[n+i])
suml[i+1]-=heappop(l)
r=[]
for v in a[2*n:]:
heappush(r,(10**10-v,v))
sumr=[sum(a[2*n:])]
for i in range(n):
sumr.append(sumr[i]+a[2*n-i-1])
heappush(r,(10**10-a[2*n-i-1],a[2*n-i-1]))
_,t=heappop(r)
sumr[i+1]-=t
ans=-10**20
for i in range(n+1):
ans=max(ans,suml[i]-sumr[n-i])
print(ans) | def f(a):
q=a[:n];s=sum(q);heapify(q)
for e in a[n:n-~n]:yield s;s+=e-heappushpop(q,e)
from heapq import*;n,*a=list(map(int,open(0).read().split()));print((max(list(map(sum,list(zip(f(a),list(f([-e for e in a[::-1]]))[::-1]))))))) | p03714 |
import heapq
def solve():
n = int(input())
ar = input().split(' ')
iar = [int(s) for s in ar]
early = iar[:n]
mid = iar[n:-n]
late = iar[-n:]
heapq.heapify(early)
tmpsum = sum(early)
esums = [tmpsum]
for i in range(n):
heapq.heappush(early, mid[i])
emin = heapq.heappop(early)
tmpsum += (mid[i] - emin)
esums.append(tmpsum)
#print esums
lateinv = [-x for x in late]
heapq.heapify(lateinv)
tmpsum = sum(lateinv)
lsums = [tmpsum]
for i in range(1,n+1):
heapq.heappush(lateinv, -mid[-i])
lmax = heapq.heappop(lateinv)
tmpsum += (-mid[-i] - lmax)
lsums.append(tmpsum)
#print lsums
best = float("-inf")
for i in range(n+1):
score = esums[i] + lsums[n-i]
#print 'i=',i,',n-i=',n-i,',esums[i]=',esums[i],',lsums[n-i]=',lsums[n-i],'score=',score
if(best < score) : best = score
return best
if __name__ == '__main__' :
print(solve()) | import heapq
N = int(eval(input()))
src = list(map(int,input().split()))
lsum = sum(src[:N])
lmem = [lsum]
lq = src[:N][:]
heapq.heapify(lq)
for a in src[N:2*N]:
if a <= lq[0]:
lmem.append(lmem[-1])
else:
lsum += a - heapq.heappop(lq)
heapq.heappush(lq, a)
lmem.append(lsum)
rq = [-a for a in src[-N:]]
rsum = sum(rq)
rmem = [rsum]
heapq.heapify(rq)
for a in reversed(src[N:2*N]):
if -a <= rq[0]:
rmem.append(rmem[-1])
else:
rsum += -a - heapq.heappop(rq)
heapq.heappush(rq, -a)
rmem.append(rsum)
ans = -float('inf')
for l,r in zip(lmem, rmem[::-1]):
ans = max(ans, l+r)
print(ans) | p03714 |
import heapq
N = int(eval(input()))
A = list(map(int, input().split()))
L = A[:N]
heapq.heapify(L)
sum_L = [0] * (N+1)
sum_L[0] = sum(L)
for i in range(N):
min_L = heapq.heappushpop(L, A[N+i])
sum_L[i+1] = sum_L[i] + A[N+i] - min_L
#print(L, i, A[N+i], min_L, sum_L)
R = A[N*2:]
rev_R = list([x*(-1) for x in R])
heapq.heapify(rev_R)
sum_R = [0] * (N+1)
sum_R[N] = sum(R)
for i in range(N-1, -1, -1):
max_R = heapq.heappushpop( rev_R, A[N+i]*(-1) ) * (-1)
sum_R[i] = sum_R[i+1] + A[N+i] - max_R
# print(rev_R, i, A[N+i], max_R, sum_R)
ans = -10**14
for i in range(N+1):
ans = max(ans, sum_L[i] - sum_R[i])
print(ans) | import heapq
N = int(eval(input()))
A = list(map(int, input().split()))
L = A[:N]
heapq.heapify(L)
sum_L = [0] * (N+1)
sum_L[0] = sum(L)
for i in range(N):
min_L = heapq.heappushpop(L, A[N+i])
sum_L[i+1] = sum_L[i] + A[N+i] - min_L
#print(L, i, A[N+i], min_L, sum_L)
R = A[N*2:]
rev_R = list([-x for x in R])
heapq.heapify(rev_R)
sum_R = [0] * (N+1)
sum_R[N] = sum(R)
for i in range(N-1, -1, -1):
max_R = -heapq.heappushpop(rev_R, -A[N+i])
sum_R[i] = sum_R[i+1] + A[N+i] - max_R
#print(rev_R, i, A[N+i], max_R, sum_R)
ans = -10**14
for i in range(N+1):
ans = max(ans, sum_L[i] - sum_R[i])
print(ans) | p03714 |
import heapq
n=int(eval(input()))
A=[int(i) for i in input().split()]
AL=A[:n]
AR=[]
for i in range(2*n,3*n):
AR.append(-A[i])
ALS,ARS=[0]*(n+1),[0]*(n+1)
ALS[0],ARS[0]=sum(AL),-sum(AR)
heapq.heapify(AL)
heapq.heapify(AR)
for i in range(n):
heapq.heappushpop(AL,A[n+i])
ALS[i+1]+=sum(AL)
heapq.heappushpop(AR,-A[2*n-i-1])
ARS[i+1]+=-sum(AR)
ARS=ARS[::-1]
ans=-float("inf")
for i in range(n+1):
ans=max(ans,ALS[i]-ARS[i])
print(ans) | import heapq
n=int(eval(input()))
A=[int(i) for i in input().split()]
AL=A[:n]
AR=[0]*n
for i in range(2*n,3*n):
AR[i-2*n]-=A[i]
ALS,ARS=[0]*(n+1),[0]*(n+1)
ALS[0],ARS[0]=sum(AL),sum(AR)
heapq.heapify(AL)
heapq.heapify(AR)
for i in range(n):
l,r=A[n+i],-A[2*n-i-1]
heapq.heappush(AL,l)
ALS[i+1]=ALS[i]+l-heapq.heappop(AL)
heapq.heappush(AR,r)
ARS[i+1]=ARS[i]+r-heapq.heappop(AR)
ans=-float("inf")
for i in range(n+1):
ans=max(ans,ALS[i]+ARS[n-i])
print(ans) | p03714 |
from heapq import heappop, heappush
inf = float('inf')
N = int(eval(input()))
A = list(map(int,input().split()))
# sum_max[k] : [0,k)のうちN個までの総和の最大値
# sum_min[k] : (3N-1-k,3N-1]のうちN個までの総和の最小値
sum_max = [0]*(3*N+1)
sum_min = [0]*(3*N+1)
def init_max():
res = 0
hq = []
for i, a in enumerate(A):
if len(hq) < N:
heappush(hq,a)
res += a
else:
if hq[0] < a:
res -= heappop(hq)
heappush(hq,a)
res += a
sum_max[i+1] = res
def init_min():
res = 0
hq = []
for i, a in enumerate(A[::-1]):
if len(hq) < N:
heappush(hq,-a)
res += a
else:
if -hq[0] > a:
res -= -heappop(hq)
heappush(hq,-a)
res += a
sum_min[i+1] = res
init_max()
init_min()
ans = -inf
for k in range(N,2*N+1):
res = sum_max[k] - sum_min[3*N-k]
ans = max(ans, res)
print(ans) | from heapq import heappop, heappush
inf = float('inf')
N = int(eval(input()))
A = list(map(int,input().split()))
l = []
res = 0
for i in range(N):
heappush(l, A[i])
res += A[i]
ls = []
ls.append(res)
for i in range(N, 2*N):
heappush(l, A[i])
res += A[i]
res -= heappop(l)
ls.append(res)
A.reverse()
s = []
res = 0
for i in range(N):
heappush(s, -A[i])
res += A[i]
ss = []
ss.append(res)
for i in range(N, 2*N):
heappush(s, -A[i])
res += A[i]
res -= -heappop(s)
ss.append(res)
ss.reverse()
ans = -inf
for i in range(N+1):
score = ls[i] - ss[i]
ans = max(ans, score)
print(ans) | p03714 |
def main():
from sys import setrecursionlimit, stdin, stderr
from os import environ
from collections import defaultdict, deque, Counter
from math import ceil, floor
from itertools import accumulate, combinations, combinations_with_replacement, product
setrecursionlimit(10**6)
dbg = (lambda *something: stderr.write("\033[92m{}\033[0m".format(str(something)+'\n'))) if 'TERM_PROGRAM' in environ else lambda *x: 0
input = lambda: stdin.readline().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(eval(input()))
P = 10**9+7
INF = 10**12
N = II()
positions = deque()
for i in range(N):
positions.append(LMIIS())
#縦、横の最短距離
v = []
h = []
for i in range(2**N):
v.append([INF]*N)
h.append([INF]*N)
for i in range(2**N):
v_lines = deque([0])
h_lines = deque([0])
for j in range(N):
if 2 ** j & i:
v_lines.append(positions[j][0])
h_lines.append(positions[j][1])
for j,(x,y,p) in enumerate(positions):
min_x = INF
min_y = INF
for x_c in v_lines:
min_x = min(min_x, abs(x_c - x)*p)
for y_c in h_lines:
min_y = min(min_y, abs(y_c - y)*p)
v[i][j] = min_x
h[i][j] = min_y
ans = [INF]*(N+1)
#for pattern in product(range(3),repeat=N):
n_bit_mask = (1<<N)-1
for pattern_v in range(2**N):
pattern_h = h_mask = n_bit_mask^pattern_v
pattern_h += 1
while pattern_h > 0:
pattern_h -= 1
pattern_h &= h_mask
pattern = pattern_h|pattern_v
key = 0
for i in range(N):
if 2**i & pattern:
key += 1
# for p in pattern:
# pattern_v *= 2
# pattern_h *= 2
# if p == 1:
# pattern_v += 1
# elif p == 2:
# pattern_h += 1
# else:a
# key -= 1
sum_diff = 0
for i in range(N):
sum_diff += min(v[pattern_v][i],h[pattern_h][i])
ans[key] = min(ans[key], sum_diff)
print(('\n'.join(map(str,ans))))
main() | def main():
from sys import setrecursionlimit, stdin, stderr
from os import environ
from collections import defaultdict, deque, Counter
from math import ceil, floor
from itertools import accumulate, combinations, combinations_with_replacement, product
setrecursionlimit(10**6)
dbg = (lambda *something: stderr.write("\033[92m{}\033[0m".format(str(something)+'\n'))) if 'TERM_PROGRAM' in environ else lambda *x: 0
input = lambda: stdin.readline().rstrip()
LMIIS = lambda: list(map(int,input().split()))
II = lambda: int(eval(input()))
P = 10**9+7
INF = 10**12
N = II()
positions = deque()
for i in range(N):
positions.append(LMIIS())
#縦、横の最短距離
v = []
h = []
for i in range(2**N):
v.append([INF]*N)
h.append([INF]*N)
for i in range(2**N):
v_lines = deque([0])
h_lines = deque([0])
for j in range(N):
if 2 ** j & i:
v_lines.append(positions[j][0])
h_lines.append(positions[j][1])
for j,(x,y,p) in enumerate(positions):
min_x = INF
min_y = INF
for x_c in v_lines:
min_x = min(min_x, abs(x_c - x)*p)
for y_c in h_lines:
min_y = min(min_y, abs(y_c - y)*p)
v[i][j] = min_x
h[i][j] = min_y
ans = [INF]*(N+1)
#for pattern in product(range(3),repeat=N):
n_bit_mask = (1<<N)-1
for pattern in range(2**N):
cities = [i for i in range(N) if 2**i&pattern==0]
key = N - len(cities)
pattern_v = pattern
pattern_h = 0
while True:
sum_diff = 0
for i in cities:
sum_diff += min(v[pattern_v][i],h[pattern_h][i])
ans[key] = min(ans[key], sum_diff)
if pattern_v == 0:
break
pattern_v = (pattern_v-1)&pattern
pattern_h = pattern - pattern_v
print(('\n'.join(map(str,ans))))
main() | p02604 |
import bisect
import copy
import heapq
import sys
import itertools
import math
from functools import lru_cache
from collections import deque
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7
def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
def main():
N = int(eval(input()))
P = read_lists(N)
C = [10 ** 12] * (N + 1)
CX = [[0] * N for _ in range(2 ** N)]
CY = [[0] * N for _ in range(2 ** N)]
LX = [0] * (2 ** N)
LY = [0] * (2 ** N)
for T in range(2 ** N):
X = {0}
Y = {0}
S = set()
for i in range(N):
if (T >> i) & 1:
X.add(P[i][0])
Y.add(P[i][1])
S.add(i)
for j, (xp, yp, _) in enumerate(P):
if j in S:
continue
CX[T][j] = min(abs(xp - x) for x in X)
CY[T][j] = min(abs(yp - y) for y in Y)
LX[T] = len(X)
LY[T] = len(Y)
for T in itertools.product((0, 1, 2), repeat=N):
tx = 0
ty = 0
for i, t in enumerate(T):
if t == 1:
tx |= (1 << i)
elif t == 2:
ty |= (1 << i)
c = 0
for n in range(N):
c += min(CX[tx][n], CY[ty][n]) * P[n][2]
p = LX[tx] + LY[ty] - 2
C[p] = min(C[p], c)
print(("\n".join(map(str, C))))
if __name__ == "__main__":
main()
| import bisect
import copy
import heapq
import sys
import itertools
import math
from functools import lru_cache
from collections import deque
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 10 ** 9 + 7
def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
def main():
N = int(eval(input()))
P = read_lists(N)
# N = 15
# P = [(i ** 2 + 1, i ** 2 + 1, i ** 2 + 1) for i in range(N)]
C = [1 << 62] * (N + 1)
# CX = [None for _ in range(2 ** N)]
# CY = [None for _ in range(2 ** N)]
CX = [1 << 62] * (N * 2 ** N)
CY = [1 << 62] * (N * 2 ** N)
LX = [0] * (2 ** N)
LY = [0] * (2 ** N)
for K in range(2 ** N):
X = {0}
Y = {0}
for i in range(N):
if (K >> i) & 1:
X.add(P[i][0])
Y.add(P[i][1])
# CXX = [0] * N
# CYY = [0] * N
for j, (xp, yp, cp) in enumerate(P):
for x in X:
# CXX[j] = min(abs(xp - x) * cp, CXX[j])
CX[K * N + j] = min(abs(xp - x) * cp, CX[K * N + j])
for y in Y:
CY[K * N + j] = min(abs(yp - y) * cp, CY[K * N + j])
# CYY[j] = min(abs(yp - y) * cp, CYY[j])
LX[K] = len(X)
LY[K] = len(Y)
# CX[K] = tuple(CXX)
# CY[K] = tuple(CYY)
for T in range(2 ** N):
p = format(T, "160b").count("1")
if C[p] == 0:
continue
r = 1 << 62
tx = T
while True:
ty = T - tx
c = 0
for n in range(N):
c += min(CX[tx * N + n], CY[ty * N + n])
r = min(r, c)
if tx == 0:
break
tx = (tx - 1) & T
C[p] = min(C[p], r)
print(("\n".join(map(str, C))))
if __name__ == "__main__":
main()
| p02604 |
INF = 10 ** 12
N = int(eval(input()))
X = [0] * N
Y = [0] * N
P = [0] * N
for i in range(N):
X[i], Y[i], P[i] = list(map(int,input().split()))
score_X = []
for i in range(2 ** N):
x = []
I = i
for j in range(N):
i = I
score = abs(X[j]) * P[j]
for k in range(N):
if i & 1:
score = min(score, abs(X[j] - X[k]) * P[j])
i >>= 1
x.append(score)
score_X.append(x)
score_Y = []
for i in range(2 ** N):
y = []
I = i
for j in range(N):
i = I
score = abs(Y[j]) * P[j]
for k in range(N):
if i & 1:
score = min(score, abs(Y[j] - Y[k]) * P[j])
i >>= 1
y.append(score)
score_Y.append(y)
ans = [INF] * (N + 1)
for i in range(2 ** N):
cnt = 0
for j in range(N):
if (i >> j) & 1:
cnt += 1
for j in range(i, -1, -1):
j &= i
score = 0
for k in range(N):
if not (i >> k) & 1:
score += min(score_X[j][k], score_Y[i - j][k])
ans[cnt] = min(ans[cnt], score)
for i in range(N + 1):
print((ans[i])) | INF = 10 ** 12
N = int(eval(input()))
X = [0] * N
Y = [0] * N
P = [0] * N
for i in range(N):
X[i], Y[i], P[i] = list(map(int,input().split()))
score_X = []
for i in range(2 ** N):
x = []
I = i
for j in range(N):
i = I
score = abs(X[j]) * P[j]
for k in range(N):
if i & 1:
score = min(score, abs(X[j] - X[k]) * P[j])
i >>= 1
x.append(score)
score_X.append(x)
score_Y = []
for i in range(2 ** N):
y = []
I = i
for j in range(N):
i = I
score = abs(Y[j]) * P[j]
for k in range(N):
if i & 1:
score = min(score, abs(Y[j] - Y[k]) * P[j])
i >>= 1
y.append(score)
score_Y.append(y)
ans = [INF] * (N + 1)
for i in range(2 ** N):
cnt = 0
for j in range(N):
if (i >> j) & 1:
cnt += 1
j = i
while True:
score = 0
for k in range(N):
if not (i >> k) & 1:
score += min(score_X[j][k], score_Y[i - j][k])
ans[cnt] = min(ans[cnt], score)
if j == 0:
break
j = (j - 1) & i
for i in range(N + 1):
print((ans[i])) | p02604 |
N = int(eval(input()))
X = []; Y = []; P = []
INF = float("inf")
for i in range(N):
x,y,p = list(map(int,input().split()))
X.append(x);Y.append(y);P.append(p)
ans = [INF for _ in range(N+1)] #0本置いた時からN本置いた時までN+1個
def calc(A):
n = len(A) #Aにはいくつ入っているか。つまり、xoryで選ばれたものはいくつあるか。
A.sort()
res = [INF for _ in range(n+1)] #道が0本からn本
for s in range(1<<n): #選ばれたものを全探索
p = [] #最初の大通り
for i in range(n):
if (s>>i)&1 == 1: #bitが立っている位置は道があるので追加
p.append(A[i][0])
#p.sort()
now = 0 #現在の移動距離
pi = 0 #i個目の町の位置よりも小さい位置
for i in range(n): #i個目の町に注目
#m = INF
x = A[i][0] #xoryとして選ばれた町のi番目の位置。
while pi+1 < len(p) and p[pi+1] < x:
pi += 1
m = abs(x)
if pi < len(p):
m = min(m,abs(x-p[pi]))
if pi+1 < len(p):
m = min(m,abs(x-p[pi+1]))
#for j in range(len(p)): #すべての道に対して愚直に最短距離を求める。
# m = min(m,abs(p[j]-A[i][0]))
now += m*A[i][1] #最短距離×人数
b = len(p) #道を何本追加したか。1を引くのは最初の大通り。
res[b] = min(res[b],now)
return res
for s in range(1<<N): #x軸にするかをbitで全探索
AX = [];AY = [] #Aは選ばれた村を追加していく。2**N回これは更新される。
for i in range(N):
if (s>>i)&1 == 1: #x軸で見る
AX.append((X[i],P[i]))
else:
AY.append((Y[i],P[i]))
dx = calc(AX)
dy = calc(AY)
for i in range(len(dx)):
for j in range(len(dy)):
ans[i+j] = min(ans[i+j],dx[i]+dy[j])
for t in ans:
print(t) | N = int(eval(input()))
X = []; Y = []; P = []
INF = float("inf")
for i in range(N):
x,y,p = list(map(int,input().split()))
X.append(x);Y.append(y);P.append(p)
ans = [INF for _ in range(N+1)] #0本置いた時からN本置いた時までN+1個
def calc(A):
n = len(A) #Aにはいくつ入っているか。つまり、xoryで選ばれたものはいくつあるか。
A.sort()
dp = [[INF]*(n+1) for _ in range(n+1)] #i個目までカバーしてj個目まで道を置いた。
dp[0][0] = 0
for l in range(n):
for r in range(l+1,n+1):
now = INF
for k in range(l,r):
s = 0
for i in range(l,r):
s += abs(A[i][0]-A[k][0])*A[i][1]
now = min(now,s)
for j in range(n):
dp[r][j+1] = min(dp[r][j+1], dp[l][j]+now)
now = 0
for i in range(l,r):
now += abs(A[i][0])*A[i][1]
for j in range(n+1):
dp[r][j] = min(dp[r][j], dp[l][j]+now)
res = [INF for _ in range(n+1)] #道が0本からn本
for j in range(n+1):
res[j] = dp[n][j]
return res
for s in range(1<<N): #x軸にするかをbitで全探索
AX = [];AY = [] #Aは選ばれた村を追加していく。2**N回これは更新される。
for i in range(N):
if (s>>i)&1 == 1: #x軸で見る
AX.append((X[i],P[i]))
else:
AY.append((Y[i],P[i]))
dx = calc(AX)
dy = calc(AY)
for i in range(len(dx)):
for j in range(len(dy)):
ans[i+j] = min(ans[i+j],dx[i]+dy[j])
for t in ans:
print(t) | p02604 |
# Fast IO (only use in integer input)
# TLE
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
N = int(eval(input()))
Resident = []
for i in range(N):
x,y,p = list(map(int,input().split()))
Resident.append((x,y,p))
def abs(N):
if N >= 0:
return N
else:
return -N
minCost = [-1] * (N+1)
preCalRange = 1 << N
horizontalLineDistance = []
verticalLineDistance = []
for i in range(preCalRange):
railRoad = bin(i)[2:]
railRoad = '0' * (N - len(railRoad)) + railRoad
horizontalLineDistance.append([])
verticalLineDistance.append([])
for j in range(N):
horizontalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
verticalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
for k in range(N):
if railRoad[k] == '1' and abs(Resident[j][0] - Resident[k][0]) < horizontalLineDistance[i][j]:
horizontalLineDistance[i][j] = abs(Resident[j][0] - Resident[k][0])
if railRoad[k] == '1' and abs(Resident[j][1] - Resident[k][1]) < verticalLineDistance[i][j]:
verticalLineDistance[i][j] = abs(Resident[j][1] - Resident[k][1])
totalCases = 3 ** N
power2 = [1]
for i in range(N):
power2.append(power2[-1] * 2)
for i in range(1 << N):
numNewRailroad = bin(i)[2:].count('1')
for j in range(i,-1,-1):
j &= i
goodList1 = horizontalLineDistance[j]
goodList2 = verticalLineDistance[i - j]
cost = 0
for k in range(N):
cost += Resident[k][2] * min(goodList1[k], goodList2[k])
if minCost[numNewRailroad] == -1 or minCost[numNewRailroad] > cost:
minCost[numNewRailroad] = cost
for elem in minCost:
print(elem)
main() | # Fast IO (only use in integer input)
# TLE
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
N = int(eval(input()))
Resident = []
for i in range(N):
x,y,p = list(map(int,input().split()))
Resident.append((x,y,p))
def abs(N):
if N >= 0:
return N
else:
return -N
minCost = [-1] * (N+1)
preCalRange = 1 << N
horizontalLineDistance = []
verticalLineDistance = []
for i in range(preCalRange):
railRoad = bin(i)[2:]
railRoad = '0' * (N - len(railRoad)) + railRoad
horizontalLineDistance.append([])
verticalLineDistance.append([])
for j in range(N):
horizontalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
verticalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
for k in range(N):
if railRoad[k] == '1' and abs(Resident[j][0] - Resident[k][0]) < horizontalLineDistance[i][j]:
horizontalLineDistance[i][j] = abs(Resident[j][0] - Resident[k][0])
if railRoad[k] == '1' and abs(Resident[j][1] - Resident[k][1]) < verticalLineDistance[i][j]:
verticalLineDistance[i][j] = abs(Resident[j][1] - Resident[k][1])
power2 = [1]
for i in range(N):
power2.append(power2[-1] * 2)
loopCount = power2[N]
for i in range(loopCount):
numNewRailroad = bin(i)[2:].count('1')
j = i
while j >= 0:
j &= i
goodList1 = horizontalLineDistance[j]
goodList2 = verticalLineDistance[i - j]
cost = 0
for k in range(N):
cost += Resident[k][2] * min(goodList1[k], goodList2[k])
if minCost[numNewRailroad] == -1 or minCost[numNewRailroad] > cost:
minCost[numNewRailroad] = cost
j -= 1
for elem in minCost:
print(elem)
main() | p02604 |
# Fast IO (only use in integer input)
# TLE
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
N = int(eval(input()))
Resident = []
for i in range(N):
x,y,p = list(map(int,input().split()))
Resident.append((x,y,p))
def abs(N):
if N >= 0:
return N
else:
return -N
minCost = [-1] * (N+1)
preCalRange = 1 << N
horizontalLineDistance = []
verticalLineDistance = []
for i in range(preCalRange):
railRoad = bin(i)[2:]
railRoad = '0' * (N - len(railRoad)) + railRoad
horizontalLineDistance.append([])
verticalLineDistance.append([])
for j in range(N):
horizontalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
verticalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
for k in range(N):
if railRoad[k] == '1' and abs(Resident[j][0] - Resident[k][0]) < horizontalLineDistance[i][j]:
horizontalLineDistance[i][j] = abs(Resident[j][0] - Resident[k][0])
if railRoad[k] == '1' and abs(Resident[j][1] - Resident[k][1]) < verticalLineDistance[i][j]:
verticalLineDistance[i][j] = abs(Resident[j][1] - Resident[k][1])
power2 = [1]
for i in range(N):
power2.append(power2[-1] * 2)
loopCount = power2[N]
for i in range(loopCount):
numNewRailroad = bin(i)[2:].count('1')
j = i
while j >= 0:
j &= i
goodList1 = horizontalLineDistance[j]
goodList2 = verticalLineDistance[i - j]
cost = 0
for k in range(N):
cost += Resident[k][2] * min(goodList1[k], goodList2[k])
if minCost[numNewRailroad] == -1 or minCost[numNewRailroad] > cost:
minCost[numNewRailroad] = cost
j -= 1
for elem in minCost:
print(elem)
main() | # Fast IO (only use in integer input)
# TLE
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
N = int(eval(input()))
Resident = []
for i in range(N):
x,y,p = list(map(int,input().split()))
Resident.append((x,y,p))
def abs(N):
if N >= 0:
return N
else:
return -N
minCost = [float("inf")] * (N+1)
preCalRange = 1 << N
horizontalLineDistance = []
verticalLineDistance = []
for i in range(preCalRange):
railRoad = bin(i)[2:]
railRoad = '0' * (N - len(railRoad)) + railRoad
horizontalLineDistance.append([])
verticalLineDistance.append([])
for j in range(N):
horizontalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
verticalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
for k in range(N):
if railRoad[k] == '1' and abs(Resident[j][0] - Resident[k][0]) < horizontalLineDistance[i][j]:
horizontalLineDistance[i][j] = abs(Resident[j][0] - Resident[k][0])
if railRoad[k] == '1' and abs(Resident[j][1] - Resident[k][1]) < verticalLineDistance[i][j]:
verticalLineDistance[i][j] = abs(Resident[j][1] - Resident[k][1])
power2 = [1]
for i in range(N):
power2.append(power2[-1] * 2)
loopCount = power2[N]
for i in range(loopCount):
numNewRailroad = bin(i)[2:].count('1')
j = i
while j >= 0:
j &= i
goodList1 = horizontalLineDistance[j]
goodList2 = verticalLineDistance[i - j]
cost = 0
for k in range(N):
cost += Resident[k][2] * min(goodList1[k], goodList2[k])
if minCost[numNewRailroad] > cost:
minCost[numNewRailroad] = cost
j -= 1
for elem in minCost:
print(elem)
main() | p02604 |
# Fast IO (only use in integer input)
# TLE
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
N = int(eval(input()))
Resident = []
for i in range(N):
x,y,p = list(map(int,input().split()))
Resident.append((x,y,p))
def abs(N):
if N >= 0:
return N
else:
return -N
minCost = [float("inf")] * (N+1)
preCalRange = 1 << N
horizontalLineDistance = []
verticalLineDistance = []
for i in range(preCalRange):
railRoad = bin(i)[2:]
railRoad = '0' * (N - len(railRoad)) + railRoad
horizontalLineDistance.append([])
verticalLineDistance.append([])
for j in range(N):
horizontalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
verticalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
for k in range(N):
if railRoad[k] == '1' and abs(Resident[j][0] - Resident[k][0]) < horizontalLineDistance[i][j]:
horizontalLineDistance[i][j] = abs(Resident[j][0] - Resident[k][0])
if railRoad[k] == '1' and abs(Resident[j][1] - Resident[k][1]) < verticalLineDistance[i][j]:
verticalLineDistance[i][j] = abs(Resident[j][1] - Resident[k][1])
power2 = [1]
for i in range(N):
power2.append(power2[-1] * 2)
loopCount = power2[N]
for i in range(loopCount):
numNewRailroad = bin(i)[2:].count('1')
j = i
while j >= 0:
j &= i
cost = 0
for k in range(N):
cost += Resident[k][2] * min(horizontalLineDistance[j][k], verticalLineDistance[i - j][k])
if minCost[numNewRailroad] > cost:
minCost[numNewRailroad] = cost
j -= 1
for elem in minCost:
print(elem)
main() | # Fast IO (only use in integer input)
# TLE
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
N = int(eval(input()))
Resident = []
for i in range(N):
x,y,p = list(map(int,input().split()))
Resident.append((x,y,p))
minCost = [float("inf")] * (N+1)
preCalRange = 1 << N
horizontalLineDistance = []
verticalLineDistance = []
for i in range(preCalRange):
railRoad = bin(i)[2:]
railRoad = '0' * (N - len(railRoad)) + railRoad
horizontalLineDistance.append([])
verticalLineDistance.append([])
for j in range(N):
horizontalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
verticalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
for k in range(N):
if railRoad[k] == '1' and abs(Resident[j][0] - Resident[k][0]) < horizontalLineDistance[i][j]:
horizontalLineDistance[i][j] = abs(Resident[j][0] - Resident[k][0])
if railRoad[k] == '1' and abs(Resident[j][1] - Resident[k][1]) < verticalLineDistance[i][j]:
verticalLineDistance[i][j] = abs(Resident[j][1] - Resident[k][1])
power2 = [1]
for i in range(N):
power2.append(power2[-1] * 2)
loopCount = power2[N]
for i in range(loopCount):
numNewRailroad = bin(i)[2:].count('1')
j = i
while j >= 0:
j &= i
goodList1 = horizontalLineDistance[j]
goodList2 = verticalLineDistance[i - j]
cost = 0
for k in range(N):
cost += Resident[k][2] * min(goodList1[k], goodList2[k])
if minCost[numNewRailroad] > cost:
minCost[numNewRailroad] = cost
j -= 1
for elem in minCost:
print(elem)
main() | p02604 |
# Fast IO (only use in integer input)
# TLE
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
N = int(eval(input()))
Resident = []
for i in range(N):
x,y,p = list(map(int,input().split()))
Resident.append((x,y,p))
minCost = [float("inf")] * (N+1)
preCalRange = 1 << N
horizontalLineDistance = []
verticalLineDistance = []
for i in range(preCalRange):
railRoad = bin(i)[2:]
railRoad = '0' * (N - len(railRoad)) + railRoad
horizontalLineDistance.append([])
verticalLineDistance.append([])
for j in range(N):
horizontalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
verticalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
for k in range(N):
if railRoad[k] == '1' and abs(Resident[j][0] - Resident[k][0]) < horizontalLineDistance[i][j]:
horizontalLineDistance[i][j] = abs(Resident[j][0] - Resident[k][0])
if railRoad[k] == '1' and abs(Resident[j][1] - Resident[k][1]) < verticalLineDistance[i][j]:
verticalLineDistance[i][j] = abs(Resident[j][1] - Resident[k][1])
power2 = [1]
for i in range(N):
power2.append(power2[-1] * 2)
loopCount = power2[N]
for i in range(loopCount):
numNewRailroad = bin(i)[2:].count('1')
j = i
while j >= 0:
j &= i
goodList1 = horizontalLineDistance[j]
goodList2 = verticalLineDistance[i - j]
cost = 0
for k in range(N):
cost += Resident[k][2] * min(goodList1[k], goodList2[k])
if minCost[numNewRailroad] > cost:
minCost[numNewRailroad] = cost
j -= 1
for elem in minCost:
print(elem)
main() | # Fast IO (only use in integer input)
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def main():
N = int(eval(input()))
Resident = []
for i in range(N):
x,y,p = list(map(int,input().split()))
Resident.append((x,y,p))
minCost = [float("inf")] * (N+1)
preCalRange = 1 << N
horizontalLineDistance = []
verticalLineDistance = []
for i in range(preCalRange):
railRoad = bin(i)[2:]
railRoad = '0' * (N - len(railRoad)) + railRoad
horizontalLineDistance.append([])
verticalLineDistance.append([])
for j in range(N):
horizontalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
verticalLineDistance[i].append(min(abs(Resident[j][0]),abs(Resident[j][1])))
for k in range(N):
if railRoad[k] == '1' and abs(Resident[j][0] - Resident[k][0]) < horizontalLineDistance[i][j]:
horizontalLineDistance[i][j] = abs(Resident[j][0] - Resident[k][0])
if railRoad[k] == '1' and abs(Resident[j][1] - Resident[k][1]) < verticalLineDistance[i][j]:
verticalLineDistance[i][j] = abs(Resident[j][1] - Resident[k][1])
loopCount = 1 << N
for i in range(loopCount):
numNewRailroad = bin(i)[2:].count('1')
j = i
while j >= 0:
j &= i
goodList1 = horizontalLineDistance[j]
goodList2 = verticalLineDistance[i - j]
cost = 0
for k in range(N):
cost += Resident[k][2] * min(goodList1[k], goodList2[k])
if minCost[numNewRailroad] > cost:
minCost[numNewRailroad] = cost
j -= 1
for elem in minCost:
print(elem)
main() | p02604 |
# writer解(c++)を写経した．answerのfor文のところ何やってるかさっぱりわかりませんが…
# https://atcoder.jp/contests/m-solutions2020/submissions/15122924
import sys
input = sys.stdin.readline
INF = 10**13
def main():
N = int(eval(input()))
T = [[int(i) for i in input().split()] for j in range(N)]
X_dist = [[0]*N for _ in range(1 << N)]
Y_dist = [[0]*N for _ in range(1 << N)]
# bitという道路群を建設したときの，各集落の評価距離
# bit 001001 とかの1が立っている集落に道を作る
for bit in range(1 << N):
cur_x = [0]
cur_y = [0]
for i in range(N):
if bit & (1 << i):
cur_x.append(T[i][0])
cur_y.append(T[i][1])
for i in range(N):
X_dist[bit][i] = T[i][2]*min(abs(cx - T[i][0]) for cx in cur_x)
Y_dist[bit][i] = T[i][2]*min(abs(cy - T[i][1]) for cy in cur_y)
# これはなに？
answer = [INF] * (N+1)
for i in range(1 << N):
cnt = 0
for j in range(N):
if (i >> j) & 1:
cnt += 1
j = i
while j >= 0:
j &= i
cost = 0
for k in range(N):
if not((i >> k) & 1):
cost += min(X_dist[j][k], Y_dist[i - j][k])
answer[cnt] = min(answer[cnt], cost)
j -= 1
for ans in answer:
print(ans)
if __name__ == '__main__':
main()
| # writer解(c++)を写経した．answerのfor文のところ何やってるかさっぱりわかりませんが…
# https://atcoder.jp/contests/m-solutions2020/submissions/15122924
import sys
input = sys.stdin.readline
INF = 10**13
def main():
N = int(eval(input()))
T = [[int(i) for i in input().split()] for j in range(N)]
X_dist = [[0]*N for _ in range(1 << N)]
Y_dist = [[0]*N for _ in range(1 << N)]
# bitという道路群を建設したときの，各集落の評価距離
# bit 001001 とかの1が立っている集落に道を作る
for bit in range(1 << N):
cur_x = [0]
cur_y = [0]
for i in range(N):
if bit & (1 << i):
cur_x.append(T[i][0])
cur_y.append(T[i][1])
for i, (x, y, p) in enumerate(T):
X_dist[bit][i] = p*min(abs(cx - x) for cx in cur_x)
Y_dist[bit][i] = p*min(abs(cy - y) for cy in cur_y)
# これはなに？
answer = [INF] * (N+1)
for i in range(1 << N):
cnt = 0
for j in range(N):
if (i >> j) & 1:
cnt += 1
j = i
while j >= 0:
j &= i
cost = 0
for k in range(N):
if not((i >> k) & 1):
cost += min(X_dist[j][k], Y_dist[i - j][k])
answer[cnt] = min(answer[cnt], cost)
j -= 1
for ans in answer:
print(ans)
if __name__ == '__main__':
main()
| p02604 |
import sys
input = sys.stdin.readline
INF = 10**13
def main():
N = int(eval(input()))
T = [[int(i) for i in input().split()] for j in range(N)]
X_dist = [[0]*N for _ in range(1 << N)]
Y_dist = [[0]*N for _ in range(1 << N)]
for bit in range(1 << N):
cur_x = [0]
cur_y = [0]
for i in range(N):
if bit & (1 << i):
cur_x.append(T[i][0])
cur_y.append(T[i][1])
for i, (x, y, p) in enumerate(T):
X_dist[bit][i] = p*min(abs(cx - x) for cx in cur_x)
Y_dist[bit][i] = p*min(abs(cy - y) for cy in cur_y)
answer = [INF] * (N+1)
count = 0
for i in range(1 << N):
cnt = bin(i).count("1")
j = i
while j >= 0:
j &= i
cost = 0
for k in range(N):
count += 1
if not((i >> k) & 1):
cost += min(X_dist[j][k], Y_dist[i - j][k])
answer[cnt] = min(answer[cnt], cost)
j -= 1
for ans in answer:
print(ans)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
INF = 10**13
def main():
N = int(eval(input()))
T = [[int(i) for i in input().split()] for j in range(N)]
X_dist = [[0]*N for _ in range(1 << N)]
Y_dist = [[0]*N for _ in range(1 << N)]
for bit in range(1 << N):
cur_x = [0]
cur_y = [0]
for i in range(N):
if bit & (1 << i):
cur_x.append(T[i][0])
cur_y.append(T[i][1])
for i, (x, y, p) in enumerate(T):
X_dist[bit][i] = p*min(abs(cx - x) for cx in cur_x)
Y_dist[bit][i] = p*min(abs(cy - y) for cy in cur_y)
answer = [INF] * (N+1)
for i in range(1 << N):
cnt = bin(i).count("1")
j = i
while j >= 0:
j &= i
cost = 0
for k in range(N):
if not((i >> k) & 1):
cost += min(X_dist[j][k], Y_dist[i - j][k])
answer[cnt] = min(answer[cnt], cost)
j -= 1
for ans in answer:
print(ans)
if __name__ == '__main__':
main()
| p02604 |
n = int(eval(input()))
towns = [tuple(map(int, input().split())) for _ in range(n)]
INF = 10 ** 18
ans = [INF] * (n + 1)
default_dist = [min(abs(x), abs(y)) for x, y, p in towns]
for bit in range(1 << n):
k = (bit & 0x5555) + (bit >> 1 & 0x5555)
k = (k & 0x3333) + (k >> 2 & 0x3333)
k = (k & 0x0f0f) + (k >> 4 & 0x0f0f)
k = (k & 0x00ff) + (k >> 8 & 0x00ff)
i = 0
t = bit
selected = []
is_selected = [False] * n
while t:
if t & 1:
selected.append(towns[i])
is_selected[i] = True
t >>= 1
i += 1
for bit2 in range(1 << k):
cost = 0
for i in range(n):
if is_selected[i]:
continue
town_dist = default_dist[i]
t = bit2
x, y, p = towns[i]
for j in range(k):
if t & 1:
town_dist = min(town_dist, abs(selected[j][1] - y))
else:
town_dist = min(town_dist, abs(selected[j][0] - x))
t >>= 1
cost += town_dist * p
ans[k] = min(ans[k], cost)
print(('\n'.join(map(str, ans))))
| import sys
n, *towns = list(map(int, sys.stdin.buffer.read().split()))
xxx = towns[0::3]
yyy = towns[1::3]
ppp = towns[2::3]
INF = 10 ** 18
ans = [INF] * (n + 1)
precalc_dist_x = []
precalc_dist_y = []
for bit in range(1 << n):
dists_x = []
dists_y = []
for i in range(n):
x = xxx[i]
y = yyy[i]
dist_x = abs(x)
dist_y = abs(y)
t = bit
j = 0
while t:
if t & 1:
dist_x = min(dist_x, abs(xxx[j] - x))
dist_y = min(dist_y, abs(yyy[j] - y))
t >>= 1
j += 1
dists_x.append(dist_x * ppp[i])
dists_y.append(dist_y * ppp[i])
precalc_dist_x.append(dists_x)
precalc_dist_y.append(dists_y)
for bit in range(1 << n):
k = (bit & 0x5555) + (bit >> 1 & 0x5555)
k = (k & 0x3333) + (k >> 2 & 0x3333)
k = (k & 0x0f0f) + (k >> 4 & 0x0f0f)
k = (k & 0x00ff) + (k >> 8 & 0x00ff)
vertical = bit
while vertical:
cost = 0
pcx = precalc_dist_x[vertical]
pcy = precalc_dist_y[vertical ^ bit]
for i in range(n):
cost += min(pcx[i], pcy[i])
ans[k] = min(ans[k], cost)
vertical = (vertical - 1) & bit
cost = 0
pcx = precalc_dist_x[0]
pcy = precalc_dist_y[bit]
for i in range(n):
cost += min(pcx[i], pcy[i])
ans[k] = min(ans[k], cost)
print(('\n'.join(map(str, ans))))
| p02604 |
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 solve():
xc = [[0] * n for _ in range(1 << n)]
yc = [[0] * n for _ in range(1 << n)]
for s in range(1 << n):
for i,(x, y, p) in enumerate(xyp):
xcost = abs(x)
ycost = abs(y)
for j, (lx, ly, _) in enumerate(xyp):
if s >> j & 1 == 0: continue
xcost = min(xcost, abs(x - lx))
ycost = min(ycost, abs(y - ly))
xc[s][i] = xcost * p
yc[s][i] = ycost * p
ans = [inf] * (n + 1)
for s in range(1 << n):
k = bin(s).count("1")
xs = (1 << n) - 1
while xs > 0:
xs &= s
xcs=xc[xs]
ycs=yc[s-xs]
ans[k]=min(ans[k], sum(min(xcs[i], ycs[i]) for i in range(n)))
xs -= 1
for a in ans: print(a)
inf = 10 ** 16
n = II()
xyp = LLI(n)
solve()
| 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 solve():
xc = [[0] * n for _ in range(1 << n)]
yc = [[0] * n for _ in range(1 << n)]
for s in range(1 << n):
xcs = xc[s]
ycs = yc[s]
for i, (x, y, p) in enumerate(xyp):
xcost = abs(x)
ycost = abs(y)
for j, (lx, ly, _) in enumerate(xyp):
if s >> j & 1 == 0: continue
if abs(x - lx) < xcost: xcost = abs(x - lx)
if abs(y - ly) < ycost: ycost = abs(y - ly)
xcs[i] = xcost * p
ycs[i] = ycost * p
# print(xc)
ans = [inf] * (n + 1)
for s in range(1 << n):
k = bin(s).count("1")
xs = (1 << n) - 1
while xs > 0:
xs &= s
xcs = xc[xs]
ycs = yc[s - xs]
cur = 0
for i in range(n): cur += min(xcs[i], ycs[i])
if cur < ans[k]: ans[k] = cur
xs -= 1
for a in ans: print(a)
inf = 10 ** 16
n = II()
xyp = LLI(n)
solve()
| p02604 |
import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
l = [list(map(int,input().split())) for i in range(n)]
xcal = [[0]*n for i in range(1<<n)]
ycal = [[0]*n for i in range(1<<n)]
for i in range(1<<n):
for j in range(n):
xcal[i][j] = abs(l[j][0])
ycal[i][j] = abs(l[j][1])
for k in range(n):
if (i>>k) & 1:
xcal[i][j] = min(xcal[i][j],abs(l[j][0]-l[k][0]))
ycal[i][j] = min(ycal[i][j],abs(l[j][1]-l[k][1]))
ans = [float("INF")]*(n+1)
for i in range(1<<n):
count = 0
for j in range(n):
if i >> j & 1:
count += 1
j = i
while j >= 0:
j &= i
cost = 0
for k in range(n):
if not (i>>k & 1):
cost += min(xcal[j][k],ycal[i-j][k])*l[k][2]
ans[count] = min(ans[count],cost)
j -= 1
for i in ans:
print(i)
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
def main():
n = int(eval(input()))
l = [list(map(int,input().split())) for i in range(n)]
xcal = [[0]*n for i in range(1<<n)]
ycal = [[0]*n for i in range(1<<n)]
for i in range(1<<n):
for j in range(n):
xcal[i][j] = abs(l[j][0])
ycal[i][j] = abs(l[j][1])
for k in range(n):
if (i>>k) & 1:
xcal[i][j] = min(xcal[i][j],abs(l[j][0]-l[k][0]))
ycal[i][j] = min(ycal[i][j],abs(l[j][1]-l[k][1]))
xcal[i][j] *= l[j][2]
ycal[i][j] *= l[j][2]
ans = [float("INF")]*(n+1)
for i in range(1<<n):
count = 0
for j in range(n):
if i >> j & 1:
count += 1
j = i
while j >= 0:
j &= i
cost = 0
for k in range(n):
if not (i>>k & 1):
cost += min(xcal[j][k],ycal[i-j][k])
if cost > ans[count]:
break
ans[count] = min(ans[count],cost)
j -= 1
for i in ans:
print(i)
if __name__ == "__main__":
main() | p02604 |
from itertools import product
def sol():
N = int(input())
XYP = [tuple(map(int, input().split())) for _ in range(N)]
X = [x for x, _, _ in XYP]
Y = [y for _, y, _ in XYP]
P = [p for _, _, p in XYP]
INF = 10**18
def calcCost(AP, A):
ret = [[INF] * N for _ in range(1 << N)]
for state in range(1 << N):
useA = [a for i, a in enumerate(A) if (state & (1 << i)) != 0]
for i, (a, p) in enumerate(AP):
cost = abs(a)
for z in useA:
cost = min(cost, abs(a - z))
ret[state][i] = cost * p
return ret
costX = calcCost([(x, p) for x, _, p in XYP], X)
costY = calcCost([(y, p) for _, y, p in XYP], Y)
ans = [INF] * (N + 1)
for state in product((0, 1, 2), repeat=N):
stateX = 0
stateY = 0
M = N
for s in state:
stateX <<= 1
stateY <<= 1
if s == 0: M -= 1
if s == 1: stateX |= 1
if s == 2: stateY |= 1
cx, cy = costX[stateX], costY[stateY]
cost = 0
for s in map(min, zip(cx, cy)):
cost += s
if cost >= ans[M]:
break
else:
ans[M] = cost
print(*ans, sep='\n')
sol()
| from itertools import product
def sol():
N = int(input())
XYP = [tuple(map(int, input().split())) for _ in range(N)]
X = [x for x, _, _ in XYP]
Y = [y for _, y, _ in XYP]
P = [p for _, _, p in XYP]
INF = 10**18
def calcCost(AP, A):
ret = [[INF] * N for _ in range(1 << N)]
for state in range(1 << N):
useA = [a for i, a in enumerate(A) if (state & (1 << i)) != 0]
for i, (a, p) in enumerate(AP):
cost = abs(a)
for z in useA:
cost = min(cost, abs(a - z))
ret[state][i] = cost * p
return ret
costX = calcCost([(x, p) for x, _, p in XYP], X)
costY = calcCost([(y, p) for _, y, p in XYP], Y)
ans = [INF] * (N + 1)
for state in product((0, 1, 2), repeat=N):
stateX = 0
stateY = 0
M = N
for s in state:
stateX <<= 1
stateY <<= 1
if s == 0: M -= 1
if s == 1: stateX |= 1
if s == 2: stateY |= 1
cx, cy = costX[stateX], costY[stateY]
cost = 0
for i in range(N):
cost += min(cx[i], cy[i])
if cost >= ans[M]:
break
else:
ans[M] = cost
print(*ans, sep='\n')
sol()
| p02604 |
from itertools import product
def sol():
N = int(input())
XYP = [tuple(map(int, input().split())) for _ in range(N)]
X = [x for x, _, _ in XYP]
Y = [y for _, y, _ in XYP]
P = [p for _, _, p in XYP]
INF = 10**18
def calcCost(AP, A):
ret = [[INF] * N for _ in range(1 << N)]
for state in range(1 << N):
useA = [a for i, a in enumerate(A) if (state & (1 << i)) != 0]
for i, (a, p) in enumerate(AP):
cost = abs(a)
for z in useA:
cost = min(cost, abs(a - z))
ret[state][i] = cost * p
return ret
costX = calcCost([(x, p) for x, _, p in XYP], X)
costY = calcCost([(y, p) for _, y, p in XYP], Y)
ans = [INF] * (N + 1)
for state in product((0, 1, 2), repeat=N):
stateX = 0
stateY = 0
M = N
for s in state:
stateX <<= 1
stateY <<= 1
if s == 0: M -= 1
if s == 1: stateX |= 1
if s == 2: stateY |= 1
cx, cy = costX[stateX], costY[stateY]
cost = 0
for i in range(N):
cost += min(cx[i], cy[i])
if cost >= ans[M]:
break
else:
ans[M] = cost
print(*ans, sep='\n')
sol()
| from itertools import product
def sol():
N = int(input())
XYP = [tuple(map(int, input().split())) for _ in range(N)]
XYP.sort(key=lambda xyp: abs(xyp[0] * xyp[1] * xyp[2]), reverse=True)
X = [x for x, _, _ in XYP]
Y = [y for _, y, _ in XYP]
P = [p for _, _, p in XYP]
INF = 10**18
def calcCost(AP, A):
ret = [[INF] * N for _ in range(1 << N)]
for state in range(1 << N):
useA = [a for i, a in enumerate(A) if (state & (1 << i)) != 0]
for i, (a, p) in enumerate(AP):
cost = abs(a)
for z in useA:
cost = min(cost, abs(a - z))
ret[state][i] = cost * p
return ret
costX = calcCost([(x, p) for x, _, p in XYP], X)
costY = calcCost([(y, p) for _, y, p in XYP], Y)
ans = [INF] * (N + 1)
for state in product((0, 1, 2), repeat=N):
stateX = 0
stateY = 0
M = N
for s in state:
stateX <<= 1
stateY <<= 1
if s == 0: M -= 1
if s == 1: stateX |= 1
if s == 2: stateY |= 1
cx, cy = costX[stateX], costY[stateY]
cost = 0
for i in range(N):
cost += min(cx[i], cy[i])
if cost >= ans[M]:
break
else:
ans[M] = cost
print(*ans, sep='\n')
sol()
| p02604 |
from itertools import product
def sol():
N = int(input())
XYP = [tuple(map(int, input().split())) for _ in range(N)]
XYP.sort(key=lambda xyp: abs(xyp[0] * xyp[1] * xyp[2]), reverse=True)
X = [x for x, _, _ in XYP]
Y = [y for _, y, _ in XYP]
P = [p for _, _, p in XYP]
INF = 10**18
def calcCost(AP, A):
ret = [[INF] * N for _ in range(1 << N)]
for state in range(1 << N):
useA = [a for i, a in enumerate(A) if (state & (1 << i)) != 0]
for i, (a, p) in enumerate(AP):
cost = abs(a)
for z in useA:
cost = min(cost, abs(a - z))
ret[state][i] = cost * p
return ret
costX = calcCost([(x, p) for x, _, p in XYP], X)
costY = calcCost([(y, p) for _, y, p in XYP], Y)
ans = [INF] * (N + 1)
for state in product((0, 1, 2), repeat=N):
stateX = 0
stateY = 0
M = N
for s in state:
stateX <<= 1
stateY <<= 1
if s == 0: M -= 1
if s == 1: stateX |= 1
if s == 2: stateY |= 1
cx, cy = costX[stateX], costY[stateY]
cost = 0
for i in range(N):
cost += min(cx[i], cy[i])
if cost >= ans[M]:
break
else:
ans[M] = cost
print(*ans, sep='\n')
sol()
| from itertools import product
def sol():
N = int(input())
XYP = [tuple(map(int, input().split())) for _ in range(N)]
XYP.sort(key=lambda xyp: xyp[2], reverse=True)
X = [x for x, _, _ in XYP]
Y = [y for _, y, _ in XYP]
INF = 10**18
def calcCost(AP, A):
ret = [[INF] * N for _ in range(1 << N)]
for state in range(1 << N):
useA = [a for i, a in enumerate(A) if (state & (1 << i)) != 0]
for i, (a, p) in enumerate(AP):
cost = abs(a)
for z in useA:
cost = min(cost, abs(a - z))
ret[state][i] = cost * p
return ret
costX = calcCost([(x, p) for x, _, p in XYP], X)
costY = calcCost([(y, p) for _, y, p in XYP], Y)
ans = [INF] * (N + 1)
for state in product((0, 1, 2), repeat=N):
stateX = 0
stateY = 0
M = N
for s in state:
stateX <<= 1
stateY <<= 1
if s == 0: M -= 1
if s == 1: stateX |= 1
if s == 2: stateY |= 1
cx, cy = costX[stateX], costY[stateY]
cost = 0
for i in range(N):
cost += min(cx[i], cy[i])
if cost >= ans[M]:
break
else:
ans[M] = cost
print(*ans, sep='\n')
sol()
| p02604 |
from itertools import product
from random import randint, seed
from time import time
seed(time())
def sol():
N = int(input())
XYP = [tuple(map(int, input().split())) for _ in range(N)]
XYP.sort(key=lambda xyp: xyp[2], reverse=(randint(0, 3) != 0))
X = [x for x, _, _ in XYP]
Y = [y for _, y, _ in XYP]
INF = 10**18
def calcCost(AP, A):
ret = [[INF] * N for _ in range(1 << N)]
for state in range(1 << N):
useA = [a for i, a in enumerate(A) if (state & (1 << i)) != 0]
for i, (a, p) in enumerate(AP):
cost = abs(a)
for z in useA:
cost = min(cost, abs(a - z))
ret[state][i] = cost * p
return ret
costX = calcCost([(x, p) for x, _, p in XYP], X)
costY = calcCost([(y, p) for _, y, p in XYP], Y)
ans = [INF] * (N + 1)
for state in product((0, 1, 2), repeat=N):
stateX = 0
stateY = 0
M = N
for s in state:
stateX <<= 1
stateY <<= 1
if s == 0: M -= 1
if s == 1: stateX |= 1
if s == 2: stateY |= 1
cx, cy = costX[stateX], costY[stateY]
cost = 0
for i in range(N):
cost += min(cx[i], cy[i])
if cost >= ans[M]:
break
else:
ans[M] = cost
print(*ans, sep='\n')
sol()
| from itertools import product
INF = 10**18
N = int(input())
def calcCost(AP, A):
ret = [[INF] * N for _ in range(1 << N)]
for state in range(1 << N):
useA = [a for i, a in enumerate(A) if (state & (1 << i)) != 0]
for i, (a, p) in enumerate(AP):
cost = abs(a)
for z in useA:
cost = min(cost, abs(a - z))
ret[state][i] = cost * p
return ret
def sol():
XYP = [tuple(map(int, input().split())) for _ in range(N)]
XYP.sort(key=lambda xyp: xyp[2], reverse=True)
X = [x for x, _, _ in XYP]
Y = [y for _, y, _ in XYP]
costX = calcCost([(x, p) for x, _, p in XYP], X)
costY = calcCost([(y, p) for _, y, p in XYP], Y)
ans = [INF] * (N + 1)
for state in product((0, 1, 2), repeat=N):
stateX = 0
stateY = 0
M = N
for s in state:
stateX <<= 1
stateY <<= 1
if s == 0: M -= 1
if s == 1: stateX |= 1
if s == 2: stateY |= 1
cx, cy = costX[stateX], costY[stateY]
cost = 0
for i in range(N):
cost += min(cx[i], cy[i])
if cost >= ans[M]:
break
else:
ans[M] = cost
print(*ans, sep='\n')
sol()
| p02604 |
import bisect
N=int(eval(input()))
city=[]
for i in range(N):
x,y,p=list(map(int,input().split()))
city.append((x,y,p))
xx=[[abs(city[j][0]) for j in range(N)] for i in range(2**N)]
yy=[[abs(city[j][1]) for j in range(N)] for i in range(2**N)]
for i in range(2**N):
X=[0]
rest=[]
for j in range(N):
if i>>j&1==1:
X.append(city[j][0])
xx[i][j]=0
else:
rest.append(j)
for j in rest:
res=10**15
for k in X:
res=min(res,abs(city[j][0]-k))
xx[i][j]=res
for i in range(2**N):
Y=[0]
rest=[]
for j in range(N):
if i>>j&1==1:
Y.append(city[j][1])
yy[i][j]=0
else:
rest.append(j)
for j in rest:
res=10**15
for k in Y:
res=min(res,abs(city[j][1]-k))
yy[i][j]=res
ans=[10**15 for i in range(N+1)]
for i in range(3**N):
rest=i
X=0
Y=0
count=0
amari=[]
for j in range(N):
r=rest%3
if r==1:
count+=1
X+=2**j
elif r==2:
count+=1
Y+=2**j
else:
amari.append(j)
rest//=3
res=0
for j in amari:
x=xx[X][j]
y=yy[Y][j]
res+=min(x,y)*city[j][2]
ans[count]=min(ans[count],res)
for i in range(N+1):
print((ans[i]))
| import bisect
N=int(eval(input()))
city=[]
for i in range(N):
x,y,p=list(map(int,input().split()))
city.append((x,y,p))
xx=[[abs(city[j][0]) for j in range(N)] for i in range(2**N)]
yy=[[abs(city[j][1]) for j in range(N)] for i in range(2**N)]
for i in range(2**N):
X=[0]
rest=[]
for j in range(N):
if i>>j&1==1:
X.append(city[j][0])
xx[i][j]=0
else:
rest.append(j)
for j in rest:
res=10**15
for k in X:
res=min(res,abs(city[j][0]-k))
xx[i][j]=res
for i in range(2**N):
Y=[0]
rest=[]
for j in range(N):
if i>>j&1==1:
Y.append(city[j][1])
yy[i][j]=0
else:
rest.append(j)
for j in rest:
res=10**15
for k in Y:
res=min(res,abs(city[j][1]-k))
yy[i][j]=res
ans=[10**15 for i in range(N+1)]
for i in range(2**N):
cond=i
rest=[j for j in range(N) if i>>j &1==0]
count=N-len(rest)
while True:
X=cond
Y=i-cond
temp=0
for j in rest:
temp+=min(xx[X][j],yy[Y][j])*city[j][2]
ans[count]=min(ans[count],temp)
if cond==0:
break
else:
cond=(cond-1)&i
for i in range(N+1):
print((ans[i]))
| p02604 |
import sys
input = sys.stdin.readline
INF = float('inf')
N = int(input().strip())
data = [list(map(int, input().split())) for _ in range(N)]
cost_b = []
cost_D = []
for b in range(1<<N):
towns = []
cost = INF
for i in range(N):
if (b>>i)&1:
towns.append(data[i])
for i in range(len(towns)):
X = towns[i][0]
cost = min(cost,sum(abs(towns[j][0]-X)*towns[j][2] for j in range(len(towns))))
for i in range(len(towns)):
Y = towns[i][1]
cost = min(cost,sum(abs(towns[j][1]-Y)*towns[j][2] for j in range(len(towns))))
if len(towns) == 0:
cost = 0
cost_b.append(cost)
cost_D.append(sum(min(abs(towns[j][0]),abs(towns[j][1]))*towns[j][2] for j in range(len(towns))))
dp = [[INF]*(N+1) for i in range(1<<N)]
for i in range(1<<N):
dp[i][0] = cost_D[i]
count = 0
for k in range(1,N+1):
for i in range(1<<N):
x = i
while x>=0:
x &= i
new = dp[i-x][k-1]+cost_b[x]
if dp[i][k] > new:
dp[i][k] = new
x -= 1
for i in range(N+1):
print((dp[-1][i])) | import sys
input = sys.stdin.readline
INF = float('inf')
N = int(input().strip())
data = [list(map(int, input().split())) for _ in range(N)]
cost_b = []
cost_D = []
for b in range(1<<N):
towns = []
cost = INF
for i in range(N):
if (b>>i)&1:
towns.append(data[i])
for i in range(len(towns)):
X = towns[i][0]
cost = min(cost,sum(abs(towns[j][0]-X)*towns[j][2] for j in range(len(towns))))
for i in range(len(towns)):
Y = towns[i][1]
cost = min(cost,sum(abs(towns[j][1]-Y)*towns[j][2] for j in range(len(towns))))
if len(towns) == 0:
cost = 0
cost_b.append(cost)
cost_D.append(sum(min(abs(towns[j][0]),abs(towns[j][1]))*towns[j][2] for j in range(len(towns))))
dp = [[INF]*(N+1) for i in range(1<<N)]
for i in range(1<<N):
dp[i][0] = cost_D[i]
count = 0
for k in range(1,N+1):
for i in reversed(list(range(1<<N))):
x = i
while x>=0:
x &= i
new = dp[i-x][k-1]+cost_b[x]
if dp[i][k] > new:
dp[i][k] = new
if new == 0:
break
x -= 1
for i in range(N+1):
print((dp[-1][i])) | p02604 |
import sys
input = sys.stdin.readline
INF = float('inf')
N = int(input().strip())
data = [list(map(int, input().split())) for _ in range(N)]
cost_b = []
cost_D = []
for b in range(1<<N):
towns = []
cost = INF
for i in range(N):
if (b>>i)&1:
towns.append(data[i])
for i in range(len(towns)):
X = towns[i][0]
cost = min(cost,sum(abs(towns[j][0]-X)*towns[j][2] for j in range(len(towns))))
for i in range(len(towns)):
Y = towns[i][1]
cost = min(cost,sum(abs(towns[j][1]-Y)*towns[j][2] for j in range(len(towns))))
if len(towns) == 0:
cost = 0
cost_b.append(cost)
cost_D.append(sum(min(abs(towns[j][0]),abs(towns[j][1]))*towns[j][2] for j in range(len(towns))))
dp = [[INF]*(N+1) for i in range(1<<N)]
for i in range(1<<N):
dp[i][0] = cost_D[i]
count = 0
for k in range(1,N+1):
for i in range(1<<N):
x = i
while x>=0:
x &= i
new = dp[i-x][k-1]+cost_b[x]
if dp[i][k] > new:
dp[i][k] = new
if new == 0:
break
x -= 1
for i in range(N+1):
print((dp[-1][i]))
| import sys
input = sys.stdin.readline
INF = float('inf')
N = int(input().strip())
data = [list(map(int, input().split())) for _ in range(N)]
cost_b = []
cost_D = []
for b in range(1<<N):
towns = []
cost = INF
for i in range(N):
if (b>>i)&1:
towns.append(data[i])
for i in range(len(towns)):
X = towns[i][0]
cost = min(cost,sum(abs(towns[j][0]-X)*towns[j][2] for j in range(len(towns))))
for i in range(len(towns)):
Y = towns[i][1]
cost = min(cost,sum(abs(towns[j][1]-Y)*towns[j][2] for j in range(len(towns))))
if len(towns) == 0:
cost = 0
cost_b.append(cost)
cost_D.append(sum(min(abs(towns[j][0]),abs(towns[j][1]))*towns[j][2] for j in range(len(towns))))
dp = [[INF]*(N+1) for i in range(1<<N)]
for i in range(1<<N):
dp[i][0] = cost_D[i]
count = 0
for k in range(1,N+1):
for i in range(1<<N)[::-1]:
x = i
while x>=0:
x &= i
new = dp[i-x][k-1]+cost_b[x]
if dp[i][k] > new:
dp[i][k] = new
if new == 0:
break
x -= 1
for i in range(N+1):
print((dp[-1][i])) | p02604 |
def main():
n = int(eval(input()))
xyp = [list(map(int, input().split())) for _ in [0]*n]
d = []
def calc(seq):
m = len(seq)
dp = [[0]]
for i in range(m):
dp2 = [[10**15]*(i+2) for _ in [0]*(i+2)]
for j in range(i+1):
dp2[j][0] = min(dp2[j][0], dp[j][0])
temp = dp[j][0]
for a, b in seq[:i+1]:
temp += min(abs(a), seq[i][0]-a)*b
dp2[j+1][i+1] = min(dp2[j+1][i+1], temp)
for k in range(1, i+1):
dp2[j][k] = min(dp2[j][k], dp[j][k])
temp = dp[j][k]
for a, b in seq[k:i+1]:
temp += min(abs(a), a-seq[k-1][0], seq[i][0]-a)*b
dp2[j+1][i+1] = min(dp2[j+1][i+1], temp)
dp = dp2
for i in range(m+1):
for a, b in seq[:m]:
dp[i][0] += abs(a)*b
for k in range(1, m+1):
for a, b in seq[k:m]:
dp[i][k] += min(abs(a), a-seq[k-1][0])*b
for i in range(m+1):
dp[i] = min(dp[i])
dp += [0]*(n-m)
return dp
xyp.sort()
for i in range(2**n):
x_list, y_list = [], []
for j in range(n):
x, y, p = xyp[j]
if i & 1:
x_list.append([x, p])
else:
y_list.append([y, p])
i >>= 1
y_list.sort()
d.append([calc(x_list), calc(y_list)])
ans = [10**15]*(n+1)
for x, y in d:
for i in range(n+1):
for j in range(n-i+1):
ans[i+j] = min(ans[i+j], x[i]+y[j])
for i in ans:
print(i)
main()
| def main():
n = int(eval(input()))
xyp = [list(map(int, input().split())) for _ in [0]*n]
d = []
def calc(seq):
m = len(seq)
dp = [[10**15]*(m+1) for _ in [0]*(m+1)]
dp[0][0] = 0
for i in range(m):
for j in range(i+1):
temp = dp[j][0]
for a, b in seq[:i+1]:
temp += min(abs(a), seq[i][0]-a)*b
dp[j+1][i+1] = min(dp[j+1][i+1], temp)
for k in range(1, i+1):
temp = dp[j][k]
for a, b in seq[k:i+1]:
temp += min(abs(a), a-seq[k-1][0], seq[i][0]-a)*b
dp[j+1][i+1] = min(dp[j+1][i+1], temp)
for i in range(m+1):
for a, b in seq[:m]:
dp[i][0] += abs(a)*b
for k in range(1, m+1):
for a, b in seq[k:m]:
dp[i][k] += min(abs(a), a-seq[k-1][0])*b
for i in range(m+1):
dp[i] = min(dp[i])
dp += [0]*(n-m)
return dp
xyp.sort()
for i in range(2**n):
x_list, y_list = [], []
for j in range(n):
x, y, p = xyp[j]
if i & 1:
x_list.append([x, p])
else:
y_list.append([y, p])
i >>= 1
y_list.sort()
d.append([calc(x_list), calc(y_list)])
ans = [10**15]*(n+1)
for x, y in d:
for i in range(n+1):
for j in range(n-i+1):
ans[i+j] = min(ans[i+j], x[i]+y[j])
for i in ans:
print(i)
main()
| p02604 |
import sys, queue, math, copy, itertools, bisect, collections, heapq
def main():
INF = 10 ** 15
LI = lambda: [int(x) for x in sys.stdin.readline().split()]
NI = lambda: int(sys.stdin.readline())
N = NI()
X = []
Y = []
P = []
for _ in range(N):
a, b, c = LI()
X.append(a)
Y.append(b)
P.append(c)
r = []
for a, b, c in zip(X, Y, P):
r.append(min(abs(a), abs(b)) * c)
hor = [copy.copy(r) for _ in range(2 ** N)]
ver = [copy.copy(r) for _ in range(2 ** N)]
for i in range(2 ** N):
k = i
for b in range(N):
if k % 2 == 1:
for j in range(N):
hor[i][j] = min(hor[i][j], abs(X[j] - X[b]) * P[j])
ver[i][j] = min(ver[i][j], abs(Y[j] - Y[b]) * P[j])
k //= 2
ans = [INF] * (N + 1)
for i in range(3 ** N):
cnt:int = 0
bx:int = 0
by:int = 0
for b in range(N):
bx <<= 1
by <<= 1
if i % 3 == 1:
bx += 1
cnt += 1
elif i % 3 == 2:
by += 1
cnt += 1
i //= 3
if ans[cnt] == 0: continue
s:int = 0
for b in range(N):
s += min(hor[bx][b], ver[by][b])
ans[cnt] = min(ans[cnt], s)
if ans[cnt] == 0:
for j in (cnt,N+1):
ans[cnt] = 0
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| import sys, queue, math, copy, itertools, bisect, collections, heapq
def main():
INF = 10 ** 15
LI = lambda: [int(x) for x in sys.stdin.readline().split()]
NI = lambda: int(sys.stdin.readline())
N = NI()
X = []
Y = []
P = []
for _ in range(N):
a, b, c = LI()
X.append(a)
Y.append(b)
P.append(c)
r = []
st = 0
for a, b, c in zip(X, Y, P):
r.append(min(abs(a), abs(b)) * c)
st += r[-1]
hor = [copy.copy(r) for _ in range(2 ** N)]
ver = [copy.copy(r) for _ in range(2 ** N)]
for i in range(2 ** N):
k = i
for b in range(N):
if k % 2 == 1:
for j in range(N):
hor[i][j] = min(hor[i][j], abs(X[j] - X[b]) * P[j])
ver[i][j] = min(ver[i][j], abs(Y[j] - Y[b]) * P[j])
k //= 2
ans = [st] * (N + 1)
for i in range(2 ** N):
cnt = 0
j = i
for _ in range(N):
cnt += j & 1
j >>= 1
j = i
while True:
s = 0
for b in range(N):
s += min(hor[j][b], ver[i-j][b])
ans[cnt] = min(ans[cnt], s)
if j == 0: break
j -= 1
j &= i
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| p02604 |
N = int(eval(input()))
city = []
for i in range(N):
x,y,p = list(map(int,input().split()))
city.append((x,y,p))
xx = [ [ abs(city[j][0]) for j in range(N) ] for i in range(2<<N) ]
yy = [ [ abs(city[j][1]) for j in range(N) ] for i in range(2<<N) ]
for i in range(2<<N):
X = [0]
rest = []
for j in range(N):
if i>>j&1:
X.append(city[j][0])
xx[i][j] = 0
else:
rest.append(j)
for j in rest:
res = 10**15
for k in X:
res = min(res, abs(city[j][0]-k))
xx[i][j] = res
for i in range(2<<N):
Y = [0]
rest = []
for j in range(N):
if i>>j&1:
Y.append(city[j][1])
yy[i][j] = 0
else:
rest.append(j)
for j in rest:
res = 10**15
for k in Y:
res = min(res, abs(city[j][1]-k))
yy[i][j] = res
ans = [10**15 for _ in range(N+1)]
for i in range(2<<N):
cond = i
rest = [j for j in range(N) if i>>j&1==0]
count = N-len(rest)
while True:
X = cond
Y = i-cond
temp = 0
for j in rest:
temp += min(xx[X][j], yy[Y][j])*city[j][2]
ans[count] = min(ans[count], temp)
if cond == 0:
break
else:
cond = (cond-1)&i
for i in range(N+1):
print((ans[i]))
| N=int(eval(input()))
city=[]
for i in range(N):
x,y,p=list(map(int,input().split()))
city.append((x,y,p))
xx=[[abs(city[j][0]) for j in range(N)] for i in range(2**N)]
yy=[[abs(city[j][1]) for j in range(N)] for i in range(2**N)]
for i in range(2**N):
X=[0]
rest=[]
for j in range(N):
if i>>j&1==1:
X.append(city[j][0])
xx[i][j]=0
else:
rest.append(j)
for j in rest:
res=10**15
for k in X:
res=min(res,abs(city[j][0]-k))
xx[i][j]=res
for i in range(2**N):
Y=[0]
rest=[]
for j in range(N):
if i>>j&1==1:
Y.append(city[j][1])
yy[i][j]=0
else:
rest.append(j)
for j in rest:
res=10**15
for k in Y:
res=min(res,abs(city[j][1]-k))
yy[i][j]=res
ans=[10**15 for i in range(N+1)]
for i in range(2**N):
cond=i
rest=[j for j in range(N) if i>>j &1==0]
count=N-len(rest)
while True:
X=cond
Y=i-cond
temp=0
for j in rest:
temp+=min(xx[X][j],yy[Y][j])*city[j][2]
ans[count]=min(ans[count],temp)
if cond==0:
break
else:
cond=(cond-1)&i
for i in range(N+1):
print((ans[i])) | p02604 |
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n = int(eval(input()))
li = []
for _ in range(n):
xi, yi, pi = list(map(int, input().split()))
li.append([xi, yi, pi])
li.sort(key=lambda x: x[2],reverse=True)
xx=[[abs(li[j][0]) for j in range(n)] for i in range(2**n)]
yy=[[abs(li[j][1]) for j in range(n)] for i in range(2**n)]
for i in range(2**n):
X=[0]
rest=[]
for j in range(n):
if i>>j&1==1:
X.append(li[j][0])
xx[i][j]=0
else:
rest.append(j)
for j in rest:
res=10**15
for k in X:
res=min(res,abs(li[j][0]-k))
xx[i][j]=res
for i in range(2**n):
Y=[0]
rest=[]
for j in range(n):
if i>>j&1==1:
Y.append(li[j][1])
yy[i][j]=0
else:
rest.append(j)
for j in rest:
res=10**15
for k in Y:
res=min(res,abs(li[j][1]-k))
yy[i][j]=res
index_list=[2**q for q in range(n)]
klist = [10**15]*(n+1)
klist[n]=0
for xyr2 in range(3**n):
xyr = xyr2
k,xopen,yopen=0,0,0
for index in range(n):
num = xyr%3
k+= (num+1)//2
xopen += (num%2)*index_list[index]
yopen += (num//2)*index_list[index]
xyr//=3
cost = 0
for w in range(n):
cost += min(xx[xopen][w], yy[yopen][w])*li[w][2]
klist[k] = min(klist[k], cost)
for g in range(n+1):
print((klist[g]))
if __name__ == '__main__':
main() | import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n = int(eval(input()))
li = []
for _ in range(n):
xi, yi, pi = list(map(int, input().split()))
li.append([xi, yi, pi])
li.sort(key=lambda x: x[2], reverse=True)
xx = [[abs(li[j][0]) for j in range(n)] for i in range(2**n)]
yy = [[abs(li[j][1]) for j in range(n)] for i in range(2**n)]
for i in range(2**n):
X = [0]
rest = []
for j in range(n):
if i >> j & 1 == 1:
X.append(li[j][0])
xx[i][j] = 0
else:
rest.append(j)
for j in rest:
res = 10**15
for k in X:
res = min(res, abs(li[j][0]-k))
xx[i][j] = res
for i in range(2**n):
Y = [0]
rest = []
for j in range(n):
if i >> j & 1 == 1:
Y.append(li[j][1])
yy[i][j] = 0
else:
rest.append(j)
for j in rest:
res = 10**15
for k in Y:
res = min(res, abs(li[j][1]-k))
yy[i][j] = res
index_list = [2**q for q in range(n)]
klist = [10**15]*(n+1)
klist[n] = 0
xx=tuple(xx)
yy=tuple(yy)
for xyr2 in range(3**(n-1)):
xyr = xyr2
k, xopen, yopen = 0, 0, 0
for index in range(n-1):
xyr, num = divmod(xyr, 3)
k += (num+1)//2
xopen += (num % 2)*index_list[index]
yopen += (num//2)*index_list[index]
for app in range(3):
k2, xopen2, yopen2 = k, xopen, yopen
k2 += (app+1)//2
xopen2 += (app % 2)*index_list[n-1]
yopen2 += (app//2)*index_list[n-1]
cost = 0
for w in range(n):
cost += min(xx[xopen2][w], yy[yopen2][w])*li[w][2]
klist[k2] = min(klist[k2], cost)
for g in range(n+1):
print((klist[g]))
if __name__ == '__main__':
main() | p02604 |
def popcnt(n):
c = (n & 0x5555) + ((n>>1) & 0x5555)
c = (c & 0x3333) + ((c>>2) & 0x3333)
c = (c & 0x0f0f) + ((c>>4) & 0x0f0f)
c = (c & 0x00ff) + ((c>>8) & 0x00ff)
return c
N = int(input())
X = []
Y = []
P = []
for _ in range(N):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * (1 << N) for _ in range(N)]
DY = [[0] * (1 << N) for _ in range(N)]
for i, x in enumerate(X):
for k in range(1 << N):
d = abs(x)
for j, xx in enumerate(X):
if k & (1 << j):
d = min(d, abs(xx - x))
DX[i][k] = d * P[i]
for i, y in enumerate(Y):
for k in range(1 << N):
d = abs(y)
for j, yy in enumerate(Y):
if k & (1 << j):
d = min(d, abs(yy - y))
DY[i][k] = d * P[i]
ANS = [1 << 100] * (N + 1)
for i in range(1 << N):
m = i ^ ((1 << N) - 1)
j = m
while 1:
ans = 0
for k in range(N):
ans += min(DX[k][i], DY[k][j])
pc = popcnt(i) + popcnt(j)
ANS[pc] = min(ANS[pc], ans)
if not j:
break
j = m & (j - 1)
print(*ANS, sep = "\n")
| def popcnt(n):
c = (n & 0x5555) + ((n>>1) & 0x5555)
c = (c & 0x3333) + ((c>>2) & 0x3333)
c = (c & 0x0f0f) + ((c>>4) & 0x0f0f)
c = (c & 0x00ff) + ((c>>8) & 0x00ff)
return c
N = int(input())
X = []
Y = []
P = []
for _ in range(N):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * (1 << N) for _ in range(N)]
DY = [[0] * (1 << N) for _ in range(N)]
for i, x in enumerate(X):
for k in range(1 << N):
d = abs(x)
for j, xx in enumerate(X):
if k & (1 << j):
d = min(d, abs(xx - x))
DX[i][k] = d * P[i]
for i, y in enumerate(Y):
for k in range(1 << N):
d = abs(y)
for j, yy in enumerate(Y):
if k & (1 << j):
d = min(d, abs(yy - y))
DY[i][k] = d * P[i]
ANS = [1 << 100] * (N + 1)
for i in range(1 << N):
m = i ^ ((1 << N) - 1)
j = m
pci = popcnt(i)
while 1:
ans = 0
for k in range(N):
ans += min(DX[k][i], DY[k][j])
pc = pci + popcnt(j)
ANS[pc] = min(ANS[pc], ans)
if not j:
break
j = m & (j - 1)
print(*ANS, sep = "\n")
| p02604 |
N = int(input())
X = []
Y = []
P = []
for _ in range(N):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * (1 << N) for _ in range(N)]
DY = [[0] * (1 << N) for _ in range(N)]
for i, x in enumerate(X):
for k in range(1 << N):
d = abs(x)
for j, xx in enumerate(X):
if k & (1 << j):
d = min(d, abs(xx - x))
DX[i][k] = d * P[i]
for i, y in enumerate(Y):
for k in range(1 << N):
d = abs(y)
for j, yy in enumerate(Y):
if k & (1 << j):
d = min(d, abs(yy - y))
DY[i][k] = d * P[i]
ANS = [1 << 100] * (N + 1)
PC = [0] * (1 << N)
for i in range(1, 1 << N):
j = i ^ (i & (-i))
PC[i] = PC[j] + 1
for i in range(1 << N):
m = i ^ ((1 << N) - 1)
j = m
while 1:
ans = 0
for k in range(N):
ans += min(DX[k][i], DY[k][j])
pc = PC[i] + PC[j]
ANS[pc] = min(ANS[pc], ans)
if not j:
break
j = m & (j - 1)
print(*ANS, sep = "\n")
| N = int(input())
X = []
Y = []
P = []
for _ in range(N):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * (1 << N) for _ in range(N)]
DY = [[0] * (1 << N) for _ in range(N)]
for i, x in enumerate(X):
for k in range(1 << N):
d = abs(x)
for j, xx in enumerate(X):
if k & (1 << j):
d = min(d, abs(xx - x))
DX[i][k] = d * P[i]
for i, y in enumerate(Y):
for k in range(1 << N):
d = abs(y)
for j, yy in enumerate(Y):
if k & (1 << j):
d = min(d, abs(yy - y))
DY[i][k] = d * P[i]
ANS = [1 << 100] * (N + 1)
PC = [0] * (1 << N)
for i in range(1, 1 << N):
j = i ^ (i & (-i))
PC[i] = PC[j] + 1
RA = []
for i in range(1 << N):
t = []
for j in range(N):
if i & (1 << j):
t.append(j)
RA.append(tuple(t))
mm = (1 << N) - 1
for i in range(1 << N):
m = i ^ mm
j = m
while 1:
ans = 0
for k in RA[i^j^mm]:
ans += min(DX[k][i], DY[k][j])
pc = PC[i] + PC[j]
ANS[pc] = min(ANS[pc], ans)
if not j:
break
j = m & (j - 1)
print(*ANS, sep = "\n")
| p02604 |
N = int(input())
X = []
Y = []
P = []
for _ in range(N):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * (1 << N) for _ in range(N)]
DY = [[0] * (1 << N) for _ in range(N)]
for i, x in enumerate(X):
for k in range(1 << N):
d = abs(x)
for j, xx in enumerate(X):
if k & (1 << j):
d = min(d, abs(xx - x))
DX[i][k] = d * P[i]
for i, y in enumerate(Y):
for k in range(1 << N):
d = abs(y)
for j, yy in enumerate(Y):
if k & (1 << j):
d = min(d, abs(yy - y))
DY[i][k] = d * P[i]
ANS = [1 << 100] * (N + 1)
PC = [0] * (1 << N)
for i in range(1, 1 << N):
PC[i] = PC[i^1] + 1 if i % 2 else PC[i//2]
RA = []
for i in range(1 << N):
t = []
for j in range(N):
if i & (1 << j):
t.append(j)
RA.append(t)
mm = (1 << N) - 1
for i in range(1 << N):
m = i ^ mm
j = m
while 1:
ans = 0
for k in RA[i^j^mm]:
ans += min(DX[k][i], DY[k][j])
pc = PC[i] + PC[j]
ANS[pc] = min(ANS[pc], ans)
if not j:
break
j = m & (j - 1)
for i in range(1 << N):
m = i ^ mm
j = m
while 1:
ans = 0
for k in RA[i^j^mm]:
ans += min(DX[k][i], DY[k][j])
pc = PC[i] + PC[j]
ANS[pc] = min(ANS[pc], ans)
if not j:
break
j = m & (j - 1)
print(*ANS, sep = "\n")
| N = int(input())
X = []
Y = []
P = []
for _ in range(N):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * N for _ in range(1 << N)]
DY = [[0] * N for _ in range(1 << N)]
for i, x in enumerate(X):
for k in range(1 << N):
d = abs(x)
for j, xx in enumerate(X):
if k & (1 << j):
d = min(d, abs(xx - x))
DX[k][i] = d * P[i]
for i, y in enumerate(Y):
for k in range(1 << N):
d = abs(y)
for j, yy in enumerate(Y):
if k & (1 << j):
d = min(d, abs(yy - y))
DY[k][i] = d * P[i]
ANS = [1 << 100] * (N + 1)
PC = [0] * (1 << N)
for i in range(1, 1 << N):
PC[i] = PC[i^1] + 1 if i % 2 else PC[i//2]
RA = []
for i in range(1 << N):
t = []
for j in range(N):
if i & (1 << j):
t.append(j)
RA.append(t)
mm = (1 << N) - 1
for i in range(1 << N):
m = i ^ mm
j = m
while 1:
ans = 0
for k in RA[i^j^mm]:
ans += min(DX[i][k], DY[j][k])
pc = PC[i] + PC[j]
ANS[pc] = min(ANS[pc], ans)
if not j:
break
j = m & (j - 1)
print(*ANS, sep = "\n")
| p02604 |
N = int(input())
X = []
Y = []
P = []
for _ in range(N):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * N for _ in range(1 << N)]
DY = [[0] * N for _ in range(1 << N)]
for i, x in enumerate(X):
for k in range(1 << N):
d = abs(x)
for j, xx in enumerate(X):
if k & (1 << j):
d = min(d, abs(xx - x))
DX[k][i] = d * P[i]
for i, y in enumerate(Y):
for k in range(1 << N):
d = abs(y)
for j, yy in enumerate(Y):
if k & (1 << j):
d = min(d, abs(yy - y))
DY[k][i] = d * P[i]
ANS = [1 << 100] * (N + 1)
PC = [0] * (1 << N)
for i in range(1, 1 << N):
PC[i] = PC[i^1] + 1 if i % 2 else PC[i//2]
RA = []
for i in range(1 << N):
t = []
for j in range(N):
if i & (1 << j):
t.append(j)
RA.append(t)
mm = (1 << N) - 1
for i in range(1 << N):
m = i ^ mm
j = m
while 1:
ans = 0
for k in RA[i^j^mm]:
ans += min(DX[i][k], DY[j][k])
pc = PC[i] + PC[j]
ANS[pc] = min(ANS[pc], ans)
if not j:
break
j = m & (j - 1)
print(*ANS, sep = "\n")
| N = int(input())
X = []
Y = []
P = []
for _ in range(N):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * N for _ in range(1 << N)]
DY = [[0] * N for _ in range(1 << N)]
for i, x in enumerate(X):
for k in range(1 << N):
d = abs(x)
for j, xx in enumerate(X):
if k & (1 << j):
d = min(d, abs(xx - x))
DX[k][i] = d * P[i]
for i, y in enumerate(Y):
for k in range(1 << N):
d = abs(y)
for j, yy in enumerate(Y):
if k & (1 << j):
d = min(d, abs(yy - y))
DY[k][i] = d * P[i]
ANS = [1 << 100] * (N + 1)
PC = [0] * (1 << N)
for i in range(1, 1 << N):
PC[i] = PC[i^1] + 1 if i % 2 else PC[i//2]
RA = []
for i in range(1 << N):
t = []
for j in range(N):
if i & (1 << j):
t.append(j)
RA.append(t)
mm = (1 << N) - 1
for i in range(1 << N):
m = i ^ mm
j = m
dxi = DX[i]
while 1:
dyj = DY[j]
ans = 0
for k in RA[i^j^mm]:
ans += min(dxi[k], dyj[k])
pc = PC[i] + PC[j]
ANS[pc] = min(ANS[pc], ans)
if not j:
break
j = m & (j - 1)
print(*ANS, sep = "\n")
| p02604 |
N = int(input())
X = []
Y = []
P = []
for _ in range(N):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * N for _ in range(1 << N)]
DY = [[0] * N for _ in range(1 << N)]
for i, x in enumerate(X):
for k in range(1 << N):
d = abs(x)
for j, xx in enumerate(X):
if k & (1 << j):
d = min(d, abs(xx - x))
DX[k][i] = d * P[i]
for i, y in enumerate(Y):
for k in range(1 << N):
d = abs(y)
for j, yy in enumerate(Y):
if k & (1 << j):
d = min(d, abs(yy - y))
DY[k][i] = d * P[i]
ANS = [1 << 100] * (N + 1)
PC = [0] * (1 << N)
for i in range(1, 1 << N):
PC[i] = PC[i^1] + 1 if i % 2 else PC[i//2]
mm = (1 << N) - 1
for i in range(1 << N):
m = i ^ mm
j = m
dxi = DX[i]
while 1:
dyj = DY[j]
ans = 0
for dxik, dyjk in zip(dxi, dyj):
ans += min(dxik, dyjk)
pc = PC[i] + PC[j]
ANS[pc] = min(ANS[pc], ans)
if not j:
break
j = m & (j - 1)
print(*ANS, sep = "\n")
| N = int(input())
X = []
Y = []
P = []
for _ in range(N):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * N for _ in range(1 << N)]
DY = [[0] * N for _ in range(1 << N)]
for i, x in enumerate(X):
for k in range(1 << N):
d = abs(x)
for j, xx in enumerate(X):
if k & (1 << j):
d = min(d, abs(xx - x))
DX[k][i] = d * P[i]
for i, y in enumerate(Y):
for k in range(1 << N):
d = abs(y)
for j, yy in enumerate(Y):
if k & (1 << j):
d = min(d, abs(yy - y))
DY[k][i] = d * P[i]
ANS = [1 << 100] * (N + 1)
PC = [0] * (1 << N)
for i in range(1, 1 << N):
PC[i] = PC[i^1] + 1 if i % 2 else PC[i//2]
RA = []
for i in range(1 << N):
t = []
for j in range(N):
if i & (1 << j):
t.append(j)
RA.append(t)
mm = (1 << N) - 1
for i in range(1 << N):
m = i ^ mm
j = m
dxi = DX[i]
pci = PC[i]
while 1:
dyj = DY[j]
ans = 0
for k in RA[i^j^mm]:
ans += min(dxi[k], dyj[k])
pc = pci + PC[j]
ANS[pc] = min(ANS[pc], ans)
if not j:
break
j = m & (j - 1)
print(*ANS, sep = "\n")
| p02604 |
# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, = list(map(int, readline().split()))
xyp = [tuple(map(int, readline().split())) for _ in range(n)]
N = 1<<n
INF = 1<<60
resx = []
resy = []
for i in range(n):
x,y,p = xyp[i]
rx = [min(abs(x),abs(y))]*N
ry = [min(abs(x),abs(y))]*N
for j in range(n):
for k in range(1<<j):
rx[k+(1<<j)] = min(rx[k],abs(x-xyp[j][0]))
ry[k+(1<<j)] = min(ry[k],abs(y-xyp[j][1]))
for j in range(N):
rx[j] *= p
ry[j] *= p
resx.append(rx)
resy.append(ry)
from itertools import product
ans = [INF]*(n+1)
for lst in product(list(range(3)),repeat=n):
"""
0: なし、1: 縦、2: 横
"""
v = lst.count(0)
x = y = 0
for i in range(n):
if lst[i]==1: x |= 1<<i
if lst[i]==2: y |= 1<<i
r = 0
for i in range(n):
r += min(resx[i][x],resy[i][y])
if r < ans[v]:
ans[v] = r
for i in ans[::-1]:
print(i)
| # coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, = list(map(int, readline().split()))
xyp = tuple(tuple(map(int, readline().split())) for _ in range(n))
N = 1<<n
INF = 1<<60
resx = []
resy = []
for i in range(n):
x,y,p = xyp[i]
rx = [min(abs(x),abs(y))]*N
ry = [min(abs(x),abs(y))]*N
for j in range(n):
for k in range(1<<j):
rx[k+(1<<j)] = min(rx[k],abs(x-xyp[j][0]))
ry[k+(1<<j)] = min(ry[k],abs(y-xyp[j][1]))
for j in range(N):
rx[j] *= p
ry[j] *= p
resx.append(rx)
resy.append(ry)
ans = [INF]*(n+1)
N = 3**n
p = tuple(3**i for i in range(n+1))
rv = [0]*N
rx = [0]*N
ry = [0]*N
for j in range(n):
for k in range(p[j]):
rv[k+ p[j]] = rv[k+2*p[j]] = rv[k]
rv[k] += 1
rx[k+ p[j]] = rx[k]|(1<<j)
ry[k+ p[j]] = ry[k]
rx[k+2*p[j]] = rx[k]
ry[k+2*p[j]] = ry[k]|(1<<j)
for mask in range(N):
v = rv[mask]
x = rx[mask]
y = ry[mask]
r = 0
for i in range(n):
r += min(resx[i][x],resy[i][y])
if r < ans[v]:
ans[v] = r
for i in ans[::-1]:
print(i)
| p02604 |
# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, = list(map(int, readline().split()))
xyp = tuple(tuple(map(int, readline().split())) for _ in range(n))
N = 1<<n
INF = 1<<60
resx = []
resy = []
for i in range(n):
x,y,p = xyp[i]
rx = [abs(x)]*N
ry = [abs(y)]*N
for j in range(n):
for k in range(1<<j):
rx[k+(1<<j)] = min(rx[k],abs(x-xyp[j][0]))
ry[k+(1<<j)] = min(ry[k],abs(y-xyp[j][1]))
for j in range(N):
rx[j] *= p
ry[j] *= p
resx.append(rx)
resy.append(ry)
ans = [INF]*(n+1)
for m0 in range(N):
v = n
for i in range(n):
if m0>>i&1: v-=1
mx = (N-1)&~m0
while mx>=0:
my = (N-1)^m0^mx
r = 0
for i in range(n):
r += min(resx[i][mx],resy[i][my])
if r < ans[v]:
ans[v] = r
mx = (mx-1)&~m0
for i in ans:
print(i)
| # coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n, = list(map(int, readline().split()))
xyp = tuple(tuple(map(int, readline().split())) for _ in range(n))
N = 1<<n
INF = 1<<60
resx = []
resy = []
for i in range(n):
x,y,p = xyp[i]
rx = [abs(x)]*N
ry = [abs(y)]*N
for j in range(n):
for k in range(1<<j):
rx[k+(1<<j)] = min(rx[k],abs(x-xyp[j][0]))
ry[k+(1<<j)] = min(ry[k],abs(y-xyp[j][1]))
for j in range(N):
rx[j] *= p
ry[j] *= p
resx.append(rx)
resy.append(ry)
cnt = [n]*N
for j in range(n):
for k in range(1<<j):
cnt[k+(1<<j)] = cnt[k]-1
ans = [INF]*(n+1)
for m0 in range(N):
v = cnt[m0]
mx = (N-1)&~m0
while mx>=0:
my = (N-1)^m0^mx
r = 0
for i in range(n):
if m0>>i&1:
r += min(resx[i][mx],resy[i][my])
if r < ans[v]:
ans[v] = r
mx = (mx-1)&~m0
for i in ans:
print(i)
| p02604 |
inf = 10**15
def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
X = []
Y = []
P = []
for _ in range(N):
x, y, p = list(map(int, input().split()))
X.append(x)
Y.append(y)
P.append(p)
dx = [[inf] * N for _ in range(1<<N)]
dy = [[inf] * N for _ in range(1<<N)]
for i in range(1 << N):
Xline = [0]
Yline = [0]
for j in range(N):
if i>>j&1:
Xline.append(X[j])
Yline.append(Y[j])
for j in range(N):
for x, y in zip(Xline, Yline):
dx[i][j] = min(dx[i][j], abs(x - X[j]))
dy[i][j] = min(dy[i][j], abs(y - Y[j]))
ans = [inf] * (N+1)
beki2 = [1<<j for j in range(N)]
for i in range(3**N):
M = i
k = 0
ix = iy = 0
J = []
for j in range(N):
M, m = divmod(M, 3)
if m == 0:
J.append(j)
elif m == 1:
k += 1
ix += beki2[j]
else:
k += 1
iy += beki2[j]
cost = 0
for j in J:
p = P[j]
cost += min(dx[ix][j], dy[iy][j]) * p
ans[k] = min(ans[k], cost)
for c in ans:
print(c)
if __name__ == '__main__':
main()
| inf = 10**15
def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
X = []
Y = []
P = []
for _ in range(N):
x, y, p = list(map(int, input().split()))
X.append(x)
Y.append(y)
P.append(p)
dx = [[inf] * N for _ in range(1<<N)]
dy = [[inf] * N for _ in range(1<<N)]
for i in range(1 << N):
Xline = [0]
Yline = [0]
for j in range(N):
if i>>j&1:
Xline.append(X[j])
Yline.append(Y[j])
for j in range(N):
for x, y in zip(Xline, Yline):
dx[i][j] = min(dx[i][j], abs(x - X[j]))
dy[i][j] = min(dy[i][j], abs(y - Y[j]))
ans = [inf] * (N+1)
beki = [1<<j for j in range(N)]
for i in range(3**(N-1)):
M = i
k = 0
ix = iy = 0
J = []
for j in range(N-1):
M, m = divmod(M, 3)
if m == 0:
J.append(j)
elif m == 1:
k += 1
ix += beki[j]
else:
k += 1
iy += beki[j]
for x in range(3):
kk = k
ix_ = ix
iy_ = iy
if x == 0:
J.append(N-1)
elif x == 1:
kk += 1
ix_ += beki[N-1]
else:
kk += 1
iy_ += beki[N-1]
cost = 0
for j in J:
p = P[j]
cost += min(dx[ix_][j], dy[iy_][j]) * p
ans[kk] = min(ans[kk], cost)
for c in ans:
print(c)
if __name__ == '__main__':
main()
| p02604 |
N = int(eval(input()))
A = [tuple(map(int,input().split())) for _ in range(N)]
#準備：S_の外延表記sを求める
def settify(S):
s = []
i = 0
while S > 0:
if (S & 1):
s.append(i)
S = S >> 1
i += 1
return s
Sets = []
for S_ in range(2**N):#MLEの可能性あり
Sets.append(settify(S_))
#前処理：集合に対して最適な路線を一つ選ぶO(N^2*2^N)
B = [0 for _ in range(2**N)]
for S_ in range(2**N):
if S_ == 0:
ans = 0
continue
ans = 10 ** 20
s = Sets[S_]
for k in s:
#南北方向の路線の場合
sm1 = 0
#東西方向の路線の場合
sm2 = 0
for l in s:
sm1 += abs(A[k][0] - A[l][0]) * A[l][2]
sm2 += abs(A[k][1] - A[l][1]) * A[l][2]
ans = min(ans, sm1, sm2)
#print(S_, s, ans, sm1, sm2)
B[S_] = ans
#Bit_DP... DP[S][i] = min{DP[S-T][i-1]+B[T]| T<S}
DP = [[0 for _ in range(N+2)] for _ in range(2**N)] #0番目を南北、1番目を東西大通りとする
#南北大通りO(N*2^N)
for S_ in range(2**N):
#S = S_
#i = 0
for i in Sets[S_]:
#while S > 0:
#if (S & 1):
#print(i,S_,S,DP)
DP[S_][0] += abs(A[i][0])*A[i][2]
#S = S >> 1
#i += 1
#print(S_, DP[S_][0])
#東西大通りの下準備O(N*2^N)
C = [0 for _ in range(2**N)]
for S_ in range(2**N):
"""
S = S_
i = 0
while S > 0:
if (S & 1):
"""
for i in Sets[S_]:
C[S_] += abs(A[i][1])*A[i][2]
#S = S >> 1
#i += 1
#東西大通り
for S_ in range(2**N):
if S_ == 0:
continue
s = Sets[S_]
DP[S_][1] = 10**20
#Sの部分集合を列挙して、DP[*][1]を実行
for T_ in range(2**len(s)):
#T = T_
#i = 0
L = 0
"""
while T > 0:
if (T & 1):
"""
for i in Sets[T_]:
L += 2**s[i]
#T = T >> 1
#i += 1
DP[S_][1] = min(DP[S_][1], DP[S_-L][0] + C[L])
#DP[*][2~]を実行
for k in range(N): #DP[*][k+2]
for S_ in range(2**N):
if S_ == 0: continue
#S = S_
s = Sets[S_]
#S = S_
DP[S_][k+2] = 10**20
#Sの部分集合を列挙して、DP[*][k+2]を実行
for T_ in range(2**len(s)):
#T = T_
#i = 0
L = 0
"""
while T > 0:
if (T & 1):
"""
for i in Sets[T_]:
L += 2**s[i]
#T = T >> 1
#i += 1
DP[S_][k+2] = min(DP[S_][k+2], DP[S_-L][k+1] + B[L])
#print(B,C)
#print(DP)
for k in range(-1,N):
print((DP[2**N-1][k+2]))
| N = int(eval(input()))
A = [tuple(map(int,input().split())) for _ in range(N)]
#準備：S_の外延表記sを求める
def settify(S):
s = []
i = 0
while S > 0:
if (S & 1):
s.append(i)
S = S >> 1
i += 1
return s
Sets = [settify(S_) for S_ in range(2**N)]
b = [2 ** i for i in range(N)] #2べき
def DP_solve(S, A, l, L): #l=0:x, l=1:y, L:最大本数
if S == 0:
return [0 for _ in range(L+1)]
s = Sets[S]
n = len(s)
B = [(A[i][l],A[i][2]) for i in s]#位置,コスト(人口)
B.sort()
Q = [[0 for _ in range(n)] for _ in range(n)]#準備用
for j in range(n):
for k in range(j):#k < j
Q[k][j] = sum([min(abs(B[l][0]),abs(B[l][0]-B[k][0]),abs(B[l][0]-B[j][0]))*B[l][1] for l in range(k+1,j)])
DP = [[-1 for _ in range(n)] for _ in range(L+1)]
#print(DP)
for j in range(n):
DP[1][j] = sum([min(abs(B[l][0]),abs(B[l][0]-B[j][0]))*B[l][1] for l in range(j)]) #i本目を置いて、最後がj番目の集落
for i in range(2,L+1):
DP[i][0] = DP[i-1][0]
for j in range(1,n):
DP[i][j] = min([DP[i-1][k]+Q[k][j] for k in range(j)])
#i本目を置いて、最後がj番目の集落
return [min([DP[i][j]+sum([min(abs(B[l][0]),abs(B[l][0]-B[j][0]))*B[l][1] for l in range(j+1,n)]) for j in range(n)]) if i >= 1 else sum([abs(B[l][0])*B[l][1] for l in range(n)]) for i in range(L+1)]
#1次元へ帰着
X = [DP_solve(S_,A,0, N) for S_ in range(2**N)]
Y = [DP_solve(S_,A,1, N) for S_ in range(2**N)]
#print(X)
for k in range(N+1):#合計k本(大通り以外)
ans = 10**20
for S_ in range(2**N):#X側に集合S_が割り当てられる
for i in range(k+1):#x軸平行にi本
#print(ans, X[S_][i] + Y[2**N-1-S_][k-i])
ans = min(ans, X[S_][i] + Y[2**N-1-S_][k-i])
print(ans)
| p02604 |
# 解説と 提出 #15122924 を参考に作成.
# 遅い. PyPyで出すと通る. はず.
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(N, X, Y, P):
inf = 10 ** 18
cnb_N = 2 ** N
# 前計算
# # 集落の部分集合毎の、Y軸X軸へのそれぞれの最短経路
to_x = [[0] * N for _ in range(cnb_N)]
to_y = [[0] * N for _ in range(cnb_N)]
for cn in range(cnb_N):
for n in range(N):
to_x[cn][n] = abs(X[n]) * P[n]
to_y[cn][n] = abs(Y[n]) * P[n]
for n2 in range(N):
if cn >> n2 & 1:
to_x[cn][n] = min(to_x[cn][n], abs(X[n] - X[n2]) * P[n])
to_y[cn][n] = min(to_y[cn][n], abs(Y[n] - Y[n2]) * P[n])
# 実計算
# # 各集落の集合に対して、Y軸を取った場合とX軸を取った場合で最短となる経路を算出
ans = [inf] * (N + 1)
for cn in range(cnb_N):
count = 0
for i in range(N):
count += 1 if cn >> i & 1 else 0
cn2 = cn
while cn2 >= 0:
cn2 = cn2 & cn
subsum = 0
for n in range(N):
# if not (cn >> n & 1):
subsum += min(to_x[cn - cn2][n], to_y[cn2][n])
ans[count] = min(ans[count], subsum)
cn2 -= 1
for n in range(N + 1):
print((ans[n]))
if __name__ == '__main__':
# S = input()
N = int(eval(input()))
# N, M = map(int, input().split())
X, Y, P = [], [], []
for _ in range(N):
tmp = [int(i) for i in input().split()]
X.append(tmp[0])
Y.append(tmp[1])
P.append(tmp[2])
solve(N, X, Y, P)
| # 解説と 提出 #15122924 を参考に作成.
# 遅い. PyPyで出すと通る. はず.
# import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
# from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(N, X, Y, P):
inf = 10 ** 18
cnb_N = 2 ** N
# 前計算
# # 集落の部分集合毎の、Y軸X軸へのそれぞれの最短経路
to_x = [[0] * N for _ in range(cnb_N)]
to_y = [[0] * N for _ in range(cnb_N)]
for cn in range(cnb_N):
for n in range(N):
to_x[cn][n] = abs(X[n]) * P[n]
to_y[cn][n] = abs(Y[n]) * P[n]
for n2 in range(N):
if cn >> n2 & 1:
to_x[cn][n] = min(to_x[cn][n], abs(X[n] - X[n2]) * P[n])
to_y[cn][n] = min(to_y[cn][n], abs(Y[n] - Y[n2]) * P[n])
# 実計算
# # 各集落の集合に対して、Y軸を取った場合とX軸を取った場合で最短となる経路を算出
ans = [inf] * (N + 1)
for cn in range(cnb_N):
count = 0
for i in range(N):
count += 1 if cn >> i & 1 else 0
cn2 = cn
while cn2 >= 0:
cn2 = cn2 & cn
subsum = 0
for n in range(N):
if not (cn >> n & 1):
subsum += min(to_x[cn - cn2][n], to_y[cn2][n])
ans[count] = min(ans[count], subsum)
cn2 -= 1
for n in range(N + 1):
print((ans[n]))
if __name__ == '__main__':
# S = input()
N = int(eval(input()))
# N, M = map(int, input().split())
X, Y, P = [], [], []
for _ in range(N):
tmp = [int(i) for i in input().split()]
X.append(tmp[0])
Y.append(tmp[1])
P.append(tmp[2])
solve(N, X, Y, P)
| p02604 |
#! /usr/bin/env python3
import sys
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
N = int(readline())
XYP = [list(map(int, readline().split())) for _ in range(N)]
x_cost = [0] * ((1 << N) * N)
y_cost = [0] * ((1 << N) * N)
for bit in range(1 << N):
for i, (xi, yi, _) in enumerate(XYP):
x_cost[bit * N + i] = abs(xi)
y_cost[bit * N + i] = abs(yi)
for k, (xk, yk, _) in enumerate(XYP):
if bit & (1 << k):
x_cost[bit * N + i] = min(x_cost[bit * N + i], abs(xi - xk))
y_cost[bit * N + i] = min(y_cost[bit * N + i], abs(yi - yk))
ans = [sys.maxsize for _ in range(N + 1)]
for bit in range(1 << N):
cnt = bin(bit).count('1')
bit_ = bit
while bit_ >= 0:
bit_ &= bit
cost = 0
for k in range(N):
cost += 1 * XYP[k][2] * min(x_cost[bit_ * N + k],
y_cost[(bit - bit_) * N + k])
ans[cnt] = min(ans[cnt], cost)
bit_ -= 1
for i in range(N + 1):
print((ans[i])) | #! /usr/bin/env python3
import sys
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)
N = int(readline())
XYP = [list(map(int, readline().split())) for _ in range(N)]
costs = [sys.maxsize] * N
for i, (x, y, c) in enumerate(XYP):
costs[i] = c * min(abs(x), abs(y))
x_cost = [sys.maxsize] * ((1 << N) * N)
y_cost = [sys.maxsize] * ((1 << N) * N)
for bit in range(1 << N):
for i, (xi, yi, _) in enumerate(XYP):
x_cost[bit * N + i] = min(costs[i], x_cost[bit * N + i])
y_cost[bit * N + i] = min(costs[i], y_cost[bit * N + i])
if not (bit & (1 << i)):
continue
for k, (xk, yk, c) in enumerate(XYP):
x_cost[bit * N + k] = min(x_cost[bit * N + k], abs(xi - xk) * c)
y_cost[bit * N + k] = min(y_cost[bit * N + k], abs(yi - yk) * c)
ans = [sys.maxsize] * (N + 1)
for bit in range(1 << N):
cnt = bin(bit).count('1')
bit_ = bit
while bit_ >= 0:
bit_ &= bit
cost = 0
y_bit = bit - bit_
for k in range(N):
cost += min(x_cost[bit_ * N + k], y_cost[(y_bit) * N + k])
ans[cnt] = min(ans[cnt], cost)
bit_ -= 1
for i in range(N + 1):
print((ans[i])) | p02604 |
n = int(input())
X, Y, P = [], [], []
for i in range(n):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * n for s in range(2**n)]
DY = [[0] * n for s in range(2**n)]
for s in range(2**n):
for i in range(n):
DX[s][i] = abs(X[i]) * P[i]
DY[s][i] = abs(Y[i]) * P[i]
for j in range(n):
if s & (1 << j):
DX[s][i] = min(DX[s][i], abs(X[i] - X[j]) * P[i])
DY[s][i] = min(DY[s][i], abs(Y[i] - Y[j]) * P[i])
A = [10**20] * (n + 1)
for s in range(3**n):
tmp = s
c, sx, sy = 0, 0, 0
for i in range(n):
if tmp % 3 != 0:
c += 1
if tmp % 3 == 1:
sx += 2**i
if tmp % 3 == 2:
sy += 2**i
tmp //= 3
d = 0
for i in range(n):
d += min(DX[sx][i], DY[sy][i])
A[c] = min(A[c], d)
print(*A, sep="\n")
| n = int(input())
XYP = [tuple(map(int, input().split())) for i in range(n)]
X = [x for x, y, p in XYP]
Y = [y for x, y, p in XYP]
P = [p for x, y, p in XYP]
pow2 = [2**i for i in range(n + 1)]
DX = [[0] * n for s in range(pow2[n])]
DY = [[0] * n for s in range(pow2[n])]
for s in range(1 << n):
for i in range(n):
DX[s][i] = abs(X[i]) * P[i]
DY[s][i] = abs(Y[i]) * P[i]
for j in range(n):
if s & (1 << j):
DX[s][i] = min(DX[s][i], abs(X[i] - X[j]) * P[i])
DY[s][i] = min(DY[s][i], abs(Y[i] - Y[j]) * P[i])
BC = [bin(s).count("1") for s in range(pow2[n])]
A = [10**20] * (n + 1)
for sx in range(pow2[n]):
rx = (pow2[n] - 1) ^ sx
sy = rx
for _ in range(pow2[n - BC[sx]]):
sy = (sy - 1) & rx
d = 0
for i in range(n):
d += min(DX[sx][i], DY[sy][i])
c = BC[sx] + BC[sy]
A[c] = min(A[c], d)
print(*A, sep="\n")
| p02604 |
n = int(input())
XYP = [tuple(map(int, input().split())) for i in range(n)]
X = [x for x, y, p in XYP]
Y = [y for x, y, p in XYP]
P = [p for x, y, p in XYP]
pow2 = [2**i for i in range(n + 1)]
DX = [[0] * n for s in range(pow2[n])]
DY = [[0] * n for s in range(pow2[n])]
for s in range(1 << n):
for i in range(n):
DX[s][i] = abs(X[i]) * P[i]
DY[s][i] = abs(Y[i]) * P[i]
for j in range(n):
if s & (1 << j):
DX[s][i] = min(DX[s][i], abs(X[i] - X[j]) * P[i])
DY[s][i] = min(DY[s][i], abs(Y[i] - Y[j]) * P[i])
BC = [bin(s).count("1") for s in range(pow2[n])]
A = [10**20] * (n + 1)
for sx in range(pow2[n]):
rx = (pow2[n] - 1) ^ sx
sy = rx
for _ in range(pow2[n - BC[sx]]):
sy = (sy - 1) & rx
d = 0
for i in range(n):
d += min(DX[sx][i], DY[sy][i])
c = BC[sx] + BC[sy]
A[c] = min(A[c], d)
print(*A, sep="\n")
| n = int(input())
X, Y, P = [], [], []
for i in range(n):
x, y, p = map(int, input().split())
X.append(x)
Y.append(y)
P.append(p)
DX = [[0] * n for s in range(1 << n)]
DY = [[0] * n for s in range(1 << n)]
for s in range(1 << n):
for i in range(n):
DX[s][i] = abs(X[i]) * P[i]
DY[s][i] = abs(Y[i]) * P[i]
for j in range(n):
if s & (1 << j):
DX[s][i] = min(DX[s][i], abs(X[i] - X[j]) * P[i])
DY[s][i] = min(DY[s][i], abs(Y[i] - Y[j]) * P[i])
BC = [bin(s).count("1") for s in range(1 << n)]
A = [10**20] * (n + 1)
for sx in range(1 << n):
rx = ((1 << n) - 1) ^ sx
sy = rx
for _ in range(1 << (n - BC[sx])):
sy = (sy - 1) & rx
d = 0
for i in range(n):
d += min(DX[sx][i], DY[sy][i])
c = BC[sx] + BC[sy]
A[c] = min(A[c], d)
print(*A, sep="\n")
| p02604 |
from heapq import heappush,heappop
from sys import setrecursionlimit
setrecursionlimit(10**6)
N,M,s,t=list(map(int,input().split()))
table=[[] for i in range(N)]
rtable=[[] for i in range(N)]
for i in range(M):
u,v,a,b=list(map(int,input().split()))
u,v=u-1,v-1
table[u].append([a,v])
table[v].append([a,u])
rtable[u].append([b,v])
rtable[v].append([b,u])
mod=pow(10,15)
def dijk(s,table):
dij=[]
heappush(dij,[0,s])
val=[mod]*N
val[s]=0
while len(dij)>0:
q,x=heappop(dij)
if val[x]<q:
continue
for d,y in table[x]:
if val[y]>val[x]+d:
val[y]=val[x]+d
heappush(dij,[val[y],y])
return val
val=dijk(s-1,table)
rval=dijk(t-1,rtable)
score=[0]*N
for i in range(N):
score[i]=mod-(val[i]+rval[i])
amax=[mod]*N
amax[-1]=score[-1]
for i in range(N-2,-1,-1):
amax[i]=max(amax[i+1],score[i])
for i in range(N):
print((amax[i])) | from heapq import heappush,heappop
from sys import setrecursionlimit
setrecursionlimit(10**6)
N,M,s,t=list(map(int,input().split()))
table=[[] for i in range(N)]
rtable=[[] for i in range(N)]
for i in range(M):
u,v,a,b=list(map(int,input().split()))
u,v=u-1,v-1
table[u].append((a,v))
table[v].append((a,u))
rtable[u].append((b,v))
rtable[v].append((b,u))
mod=pow(10,15)
def dijk(s,table):
dij=[]
heappush(dij,(0,s))
val=[mod]*N
val[s]=0
while len(dij)>0:
q,x=heappop(dij)
if val[x]<q:
continue
for d,y in table[x]:
if val[y]>val[x]+d:
val[y]=val[x]+d
heappush(dij,(val[y],y))
return val
val=dijk(s-1,table)
rval=dijk(t-1,rtable)
score=[0]*N
for i in range(N):
score[i]=mod-(val[i]+rval[i])
amax=[mod]*N
amax[-1]=score[-1]
for i in range(N-2,-1,-1):
amax[i]=max(amax[i+1],score[i])
for i in range(N):
print((amax[i])) | p03305 |
import heapq
dif = 10 ** 6
initial = 10 ** 15
def di(links, s):
costs = [initial] * n
costs[s] = 0
node_list = []
serched_node = set()
heapq.heappush(node_list, s)
while(len(node_list) != 0 and len(serched_node) != n):
index = heapq.heappop(node_list) % dif
if index in serched_node:
continue
serched_node.add(index)
link = links[index]
for j in range(n):
if j in serched_node or link[j] == -1:
continue
cost = link[j]
newcost = costs[index] + cost
if newcost < costs[j]:
costs[j] = newcost
heapq.heappush(node_list, newcost * dif + j)
return costs
n, m, s, t = list(map(int, input().split()))
s -= 1
t -= 1
links_en = [[-1 for j in range(n)] for i in range(n)]
links_sn = [[-1 for j in range(n)] for i in range(n)]
for i in range(m):
u, v, a, b = list(map(int, input().split()))
links_en[u - 1][v - 1] = a
links_en[v - 1][u - 1] = a
links_sn[v - 1][u - 1] = b
links_sn[u - 1][v - 1] = b
cost_en_from_s = di(links_en, s)
cost_sn_to_t = di(links_sn, t)
trans = n - 1
costs = [0] * n
for i in range(n - 1, -1, -1):
if i == n - 1:
costs[n-1] = cost_en_from_s[n-1] + cost_sn_to_t[n-1]
continue
newcost = cost_en_from_s[i] + cost_sn_to_t[i]
if newcost < costs[trans]:
trans = i
costs[i] = newcost
continue
costs[i] = costs[trans]
for cost in costs:
print((initial - cost)) | import heapq
initial_cost = 10 ** 9
initial = 10 ** 15
def di(link_costs, s):
costs = [initial] * n
costs[s] = 0
q = []
heapq.heappush(q, (0, s))
while(len(q) != 0):
index_cost, index = heapq.heappop(q)
if costs[index] < index_cost:
continue
for j in link_costs[index]:
newcost = costs[index] + link_costs[index][j]
if newcost < costs[j]:
costs[j] = newcost
heapq.heappush(q, (newcost, j))
return costs
n, m, s, t = list(map(int, input().split()))
s -= 1
t -= 1
links_cost_en = [{} for _ in range(n)]
links_cost_sn = [{} for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
u -= 1
v -= 1
links_cost_en[u][v] = a
links_cost_en[v][u] = a
links_cost_sn[u][v] = b
links_cost_sn[v][u] = b
cost_en_from_s = di(links_cost_en, s)
cost_sn_to_t = di(links_cost_sn, t)
cost_list = [cost_en_from_s[i] + cost_sn_to_t[i] for i in range(n)]
ans = [initial] * n
ans[-1] = cost_list[-1]
for i in list(range(n - 1))[::-1]:
ans[i] = min(ans[i + 1], cost_list[i])
for i in range(n):
print((initial - ans[i])) | p03305 |
import heapq
def dijkstra(G, s):
dist = [float("inf")]*len(G)
q = []
dist[s] = 0
heapq.heapify(q)
heapq.heappush(q, [0, s])
while 0 < len(q):
pre_cost, p = heapq.heappop(q)
if dist[p] < pre_cost:
continue
for v, d in G[p]:
if dist[v] > dist[p] + d:
dist[v] = dist[p] + d
heapq.heappush(q, [dist[v], v])
return dist
def main():
n, m, s, t = list(map(int, input().split()))
s, t = s-1, t-1
G_y = [[] for _ in range(n)]
G_s = [[] for _ in range(n)]
f = [True]*n
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
u, v = u-1, v-1
G_y[u].append([v, a])
G_y[v].append([u, a])
G_s[u].append([v, b])
G_s[v].append([u, b])
cost_y = dijkstra(G_y, s)
cost_s = dijkstra(G_s, t)
cost = [[cost_y[i] + cost_s[i], i] for i in range(n)]
cost.sort()
x = 0
for i in range(n):
while not f[cost[x][1]]:
x += 1
print((10**15 - cost[x][0]))
f[i] = False
if __name__ == "__main__":
main()
| import heapq
def dijkstra(G, s):
dist = [float("inf")]*len(G)
q = []
dist[s] = 0
heapq.heapify(q)
heapq.heappush(q, [0, s])
while 0 < len(q):
pre_cost, p = heapq.heappop(q)
if dist[p] < pre_cost:
continue
for v, d in G[p]:
if dist[v] > dist[p] + d:
dist[v] = dist[p] + d
heapq.heappush(q, [dist[v], v])
return dist
import sys
input = sys.stdin.readline
def main():
n, m, s, t = list(map(int, input().split()))
s, t = s-1, t-1
G_y = [[] for _ in range(n)]
G_s = [[] for _ in range(n)]
f = [True]*n
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
u, v = u-1, v-1
G_y[u].append([v, a])
G_y[v].append([u, a])
G_s[u].append([v, b])
G_s[v].append([u, b])
cost_y = dijkstra(G_y, s)
cost_s = dijkstra(G_s, t)
cost = [[cost_y[i] + cost_s[i], i] for i in range(n)]
cost.sort()
x = 0
for i in range(n):
while not f[cost[x][1]]:
x += 1
print((10**15 - cost[x][0]))
f[i] = False
if __name__ == "__main__":
main()
| p03305 |
import heapq
import sys
input = sys.stdin.readline
INF = 10**18
n,m,s,t = list(map(int,input().split()))
edge = [list(map(int,input().split())) for _ in range(m)]
graph_s = [[] for _ in range(n)]
graph_t = [[] for _ in range(n)]
for e in edge:
graph_s[e[0]-1].append([e[1]-1,e[2]])
graph_s[e[1]-1].append([e[0]-1,e[2]])
graph_t[e[0]-1].append([e[1]-1,e[3]])
graph_t[e[1]-1].append([e[0]-1,e[3]])
dist_s = [INF]*n
dist_t = [INF]*n
dist_s[s-1] = 0
dist_t[t-1] = 0
heap_s = [[0,s-1]]
heapq.heapify(heap_s)
heap_t = [[0,t-1]]
heapq.heapify(heap_t)
while heap_s:
cost,node = heapq.heappop(heap_s)
if dist_s[node] < cost:
continue
for adj,adjcost in graph_s[node]:
if dist_s[node] + adjcost < dist_s[adj]:
dist_s[adj] = dist_s[node] + adjcost
heapq.heappush(heap_s,[dist_s[adj],adj])
while heap_t:
cost,node = heapq.heappop(heap_t)
if dist_t[node] < cost:
continue
for adj,adjcost in graph_t[node]:
if dist_t[node] + adjcost < dist_t[adj]:
dist_t[adj] = dist_t[node] + adjcost
heapq.heappush(heap_t,[dist_t[adj],adj])
dist = INF
ans = []
for i in range(n):
dist = min(dist,dist_t[-1-i]+dist_s[-1-i])
ans.append(10**15-dist)
for i in range(n):
print((ans[-1-i])) | from heapq import heappop, heappush, heapify
class Graph(): #non-directed
def __init__(self, n, edge, indexed=1):
self.n = n
self.edge = edge
self.indexed = indexed
self.graph = [[] for _ in range(n)]
for e in edge:
self.graph[e[0] - indexed].append((e[1] - indexed, e[2]))
self.graph[e[1] - indexed].append((e[0] - indexed, e[2]))
def dijkstra(self, s, INF=10**18, restore_to=None):
dist = [INF for _ in range(self.n)]
dist[s] = 0
heap = [(0, s)]
prev = [None for _ in range(self.n)]
while heap:
cost, node = heappop(heap)
if dist[node] < cost:
continue
for adj, adjcost in self.graph[node]:
if dist[node] + adjcost < dist[adj]:
dist[adj] = dist[node] + adjcost
prev[adj] = node
heappush(heap, (dist[adj], adj))
if restore_to is not None:
g = restore_to
if dist[g] == INF:
return dist, False
path = [g]
node = g
while node != s:
node = prev[node]
path.append(node)
return dist, path[::-1]
return dist
import sys
input = sys.stdin.readline
N, M, S, T = list(map(int, input().split()))
E1 = []
E2 = []
for _ in range(M):
u, v, a, b = list(map(int, input().split()))
E1.append((u, v, a))
E2.append((u, v, b))
g1 = Graph(N, E1)
g2 = Graph(N, E2)
dist_from_s = g1.dijkstra(S - 1)
dist_from_t = g2.dijkstra(T - 1)
res = list()
tmp = 0
for i in range(N)[::-1]:
tmp = max(tmp, 10**15 - dist_from_t[i] - dist_from_s[i])
res.append(tmp)
print(('\n'.join(map(str, res[::-1])))) | p03305 |
N, M, S, T = map(int, input().split())
S, T = S - 1, T - 1
G_yen = [[] for i in range(N)]
G_snuuk = [[] for i in range(N)]
for i in range(M):
u, v, a, b = map(int, input().split())
u, v = u - 1, v - 1
G_yen[u].append([v, a])
G_yen[v].append([u, a])
G_snuuk[u].append([v, b])
G_snuuk[v].append([u, b])
def dijkstra(graph, start, inf=float('inf')):
import heapq
n = len(graph)
distances = [inf] * n
fixed = [False] * n
distances[start] = 0
# 距離・頂点
hq = [(0, start)]
while hq:
dist, fr = heapq.heappop(hq)
fixed[fr] = True
for to, cost in graph[fr]:
new_dist = distances[fr] + cost
if (fixed[to] is False) and (distances[to] > new_dist):
distances[to] = new_dist
heapq.heappush(hq, (new_dist, to))
return distances
from_start_yen = dijkstra(G_yen, S)
from_goal_snuuk = dijkstra(G_snuuk, T)
ans = [0] * (N + 1)
for i, yen, snuuk in zip(reversed(range(N)), from_start_yen[::-1], from_goal_snuuk[::-1]):
ans[i] = max(ans[i + 1], 10 ** 15 - (yen + snuuk))
print(*ans[:-1], sep='\n')
| N, M, S, T = map(int, input().split())
S, T = S - 1, T - 1
G_yen = [[] for i in range(N)]
G_snuuk = [[] for i in range(N)]
for i in range(M):
u, v, a, b = map(int, input().split())
u, v = u - 1, v - 1
G_yen[u].append([v, a])
G_yen[v].append([u, a])
G_snuuk[u].append([v, b])
G_snuuk[v].append([u, b])
def dijkstra(graph, start, inf=float('inf')):
import heapq
n = len(graph)
distances = [inf] * n
distances[start] = 0
# 距離・頂点
hq = [(0, start)]
while hq:
dist, fr = heapq.heappop(hq)
if distances[fr] != dist:
continue
for to, cost in graph[fr]:
new_dist = distances[fr] + cost
if distances[to] > new_dist:
distances[to] = new_dist
heapq.heappush(hq, (new_dist, to))
return distances
from_start_yen = dijkstra(G_yen, S)
from_goal_snuuk = dijkstra(G_snuuk, T)
ans = [0] * (N + 1)
for i, yen, snuuk in zip(reversed(range(N)), from_start_yen[::-1], from_goal_snuuk[::-1]):
ans[i] = max(ans[i + 1], 10 ** 15 - (yen + snuuk))
print(*ans[:-1], sep='\n')
| p03305 |
import heapq
from collections import defaultdict
WHITE = 0
GRAY = 1
BLACK = 2
INFTY = 10**16
def dijkstra(s, VC):
color = [WHITE for i in range(N)]
d = [INFTY for i in range(N)]
d[s] = 0
pq = []
heapq.heappush(pq, (0, s))
while len(pq) != 0:
u = heapq.heappop(pq)[1]
color[u] = BLACK
for v, c in VC[u]:
if color[v] != BLACK:
if d[u] + c < d[v]:
d[v] = d[u] + c
color[v] = GRAY
heapq.heappush(pq, (d[v], v))
return d
N, M, S, T = list(map(int, input().split()))
# VA = [[] for i in range(N)]
# VB = [[] for i in range(N)]
VA = defaultdict(list)
VB = defaultdict(list)
for i in range(M):
u, v, a, b = list(map(int, input().split()))
VA[u-1].append([v-1, a,])
VA[v-1].append([u-1, a])
VB[u-1].append([v-1, b])
VB[v-1].append([u-1, b])
da = dijkstra(S-1, VA)
db = dijkstra(T-1, VB)
tmp = 10**16
base = 10 ** 15
ans = [0 for i in range(N)]
for i in range(N-1, -1, -1):
tmp = min(da[i] + db[i], tmp)
ans[i] = tmp
for i in range(N):
print((base - ans[i]))
| import heapq
WHITE = 0
GRAY = 1
BLACK = 2
INFTY = 10**16
def dijkstra(s, VC):
color = [WHITE for i in range(N)]
d = [INFTY for i in range(N)]
d[s] = 0
pq = []
heapq.heappush(pq, (0, s))
while len(pq) != 0:
u = heapq.heappop(pq)[1]
color[u] = BLACK
for v, c in VC[u]:
if color[v] != BLACK:
if d[u] + c < d[v]:
d[v] = d[u] + c
color[v] = GRAY
heapq.heappush(pq, (d[v], v))
return d
N, M, S, T = list(map(int, input().split()))
VA = [[] for i in range(N)]
VB = [[] for i in range(N)]
for i in range(M):
u, v, a, b = list(map(int, input().split()))
VA[u-1].append([v-1, a,])
VA[v-1].append([u-1, a])
VB[u-1].append([v-1, b])
VB[v-1].append([u-1, b])
da = dijkstra(S-1, VA)
db = dijkstra(T-1, VB)
tmp = 10**16
base = 10 ** 15
ans = [0 for i in range(N)]
for i in range(N-1, -1, -1):
tmp = min(da[i] + db[i], tmp)
ans[i] = tmp
for i in range(N):
print((base - ans[i]))
| p03305 |
import heapq
from itertools import accumulate
n,m,s,t = map(int,input().split())
inf = 1000000000000000
gyen = [[] for _ in range(n)]
gsnuk = [[] for _ in range(n)]
for _ in range(m):
u,v,a,b = map(int,input().split())
gyen[u-1].append([v-1,a])
gyen[v-1].append([u-1,a])
gsnuk[u-1].append([v-1,b])
gsnuk[v-1].append([u-1,b])
def dijkstra(graph, start):
dist = [inf for _ in range(n)]
dist[start] = 0
q = [(0,start)]
rem = n-1
while q and rem>0:
du, u = heapq.heappop(q)
if dist[u] < du:
continue
rem -= 1
for i in graph[u]:
if dist[i[0]] > du+i[1]:
dist[i[0]] = du+i[1]
heapq.heappush(q, (dist[i[0]], i[0]))
return dist
yen = dijkstra(gyen,s-1)
snuke = dijkstra(gsnuk,t-1)
ans = list(accumulate([y+s for y,s in zip(yen,snuke)][::-1],min))
[print(inf-ans[i]) for i in range(n-1,-1,-1)]
| import heapq
import sys
from itertools import accumulate
n,m,s,t = map(int,next(sys.stdin).split(" "))
inf = 1000000000000000
gyen = [dict() for _ in range(n)]
gsnuk = [dict() for _ in range(n)]
for _ in range(m):
u,v,a,b = map(int,next(sys.stdin).split(" "))
gyen[u-1][v-1] = gyen[v-1][u-1] = a
gsnuk[u-1][v-1] = gsnuk[v-1][u-1] = b
def dijkstra(graph, start):
dist = [inf for _ in range(n)]
dist[start] = 0
q = [(0,start)]
while q:
du, u = heapq.heappop(q)
if dist[u] < du:
continue
for v,d in graph[u].items():
if dist[v] > du+d:
dist[v] = du+d
heapq.heappush(q, (dist[v], v))
return dist
yen = dijkstra(gyen,s-1)
snuke = dijkstra(gsnuk,t-1)
ans = list(accumulate([y+s for y,s in zip(yen,snuke)][::-1],min))
[print(inf-ans[i]) for i in range(n-1,-1,-1)]
| p03305 |
def main():
import collections
import heapq
class Dijkstra:
def __init__(self):
self.e = collections.defaultdict(list)
def add(self, u, v, d): # 無向グラフの場合
self.e[u].append([v, d])
self.e[v].append([u, d])
def delete(self, u, v):
self.e[u] = [_ for _ in self.e[u] if _[0] != v]
self.e[v] = [_ for _ in self.e[v] if _[0] != u]
def search(self, s): # d[i]はsからiまでの最短距離
d = collections.defaultdict(lambda: float('inf'))
d[s] = 0
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
for uv, ud in self.e[u]:
if v[uv]:
continue
vd = k + ud
if d[uv] > vd:
d[uv] = vd
heapq.heappush(q, (vd, uv))
return d
n, m, s, t = list(map(int, input().split()))
data = [list(map(int, input().split())) for i in range(m)]
G1 = Dijkstra()
G2 = Dijkstra()
for i in range(m):
G1.add(data[i][0], data[i][1], data[i][2])
G2.add(data[i][0], data[i][1], data[i][3])
D1 = G1.search(s)
D2 = G2.search(t)
A = []
for i in range(1, n + 1):
A.append((D1[i] + D2[i], i))
A.sort()
b = 0
for i in range(n):
if i == 0:
print((10 ** 15 - A[i][0]))
elif i < A[b][1]:
print((10 ** 15 - A[b][0]))
else:
while i >= A[b][1]:
b += 1
print((10 ** 15 - A[b][0]))
if __name__ == '__main__':
main() | import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def main():
import collections
import heapq
class Dijkstra:
def __init__(self):
self.e = collections.defaultdict(list)
def add(self, u, v, d): # 無向グラフの場合
self.e[u].append([v, d])
self.e[v].append([u, d])
def delete(self, u, v):
self.e[u] = [_ for _ in self.e[u] if _[0] != v]
self.e[v] = [_ for _ in self.e[v] if _[0] != u]
def search(self, s): # d[i]はsからiまでの最短距離
d = collections.defaultdict(lambda: float('inf'))
d[s] = 0
q = []
heapq.heappush(q, (0, s))
v = collections.defaultdict(bool)
while len(q):
k, u = heapq.heappop(q)
if v[u]:
continue
v[u] = True
for uv, ud in self.e[u]:
if v[uv]:
continue
vd = k + ud
if d[uv] > vd:
d[uv] = vd
heapq.heappush(q, (vd, uv))
return d
n, m, s, t = MI()
G1 = Dijkstra() #円だけ
G2 = Dijkstra() #スヌースだけ
for i in range(m):
u,v,a,b = MI()
G1.add(u,v,a)
G2.add(u,v,b)
D1 = G1.search(s)
D2 = G2.search(t)
A = []
for i in range(1, n + 1):
A.append((D1[i] + D2[i], i))
A.sort()
b = 0
for i in range(n):
if i == 0:
print((10 ** 15 - A[i][0]))
elif i < A[b][1]:
print((10 ** 15 - A[b][0]))
else:
while i >= A[b][1]:
b += 1
print((10 ** 15 - A[b][0]))
if __name__ == '__main__':
main()
| p03305 |
import sys
from collections import defaultdict as dd
import heapq
input = sys.stdin.readline
n, m, s, t = list(map(int, input().split()))
e = dd(list)
money = 10 ** 15
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
e[u].append((v, a))
e[v].append((u, a))
e[u + n].append((v + n, b))
e[v + n].append((u + n, b))
"""
for i in range(1, n + 1):
e[i].append((i + n, 0))
"""
class dijkstra:
def __init__(self, n, e):
self.e = e
self.n = n
def path(self, s, t):
d = [float("inf")] * (self.n + 1)
vis = set()
d[s] = 0
h = [s]
while not t in vis and len(h):
v = heapq.heappop(h)
v1 = v % (10 ** 15)
v0 = v // (10 ** 15)
if v1 in vis: continue
vis.add(v1)
for p in self.e[v1]:
d[p[0]] = min(d[p[0]], d[v1] + p[1])
if p[0] in vis: continue
heapq.heappush(h, d[p[0]] * (10 ** 15) + p[0])
return d
d = dijkstra(2 * n + 1, e)
x = d.path(s, 2 * n + 1)
y = d.path(t + n, 2 * n + 1)
#print(x)
#print(y)
paths = [float("inf")] * (n + 1)
minpaths = [float("inf")] * (n + 1)
for i in range(1, n + 1):
paths[i] = x[i] + y[n + i]
#print(paths)
minpaths[-1] = paths[-1]
for i in range(n - 1, -1, -1):
minpaths[i] = min(minpaths[i + 1], paths[i])
#print(minpaths)
for i in range(1, n + 1):
print((money - minpaths[i])) | import sys
from collections import defaultdict as dd
input = sys.stdin.readline
N, M, s, t = list(map(int, input().split()))
e = dd(list)
ee = dd(list)
for i in range(M):
u, v, a, b = list(map(int, input().split()))
e[u].append((v, a))
e[v].append((u, a))
ee[u].append((v, b))
ee[v].append((u, b))
import heapq
class dijkstra:
def __init__(self, n, e):
self.e = e
self.n = n
def path(self, s, t):
d = [float("inf")] * (self.n + 1)
vis = set()
d[s] = 0
h = [s]
while not t in vis and len(h):
v = heapq.heappop(h)
v1 = v % (10 ** 10)
v0 = v // (10 ** 10)
if v1 in vis: continue
vis.add(v1)
for p in self.e[v1]:
d[p[0]] = min(d[p[0]], d[v1] + p[1])
if p[0] in vis: continue
heapq.heappush(h, d[p[0]] * (10 ** 10) + p[0])
return d
dij = dijkstra(N, e)
edij = dijkstra(N, ee)
p = dij.path(s, 0)
revp = edij.path(t, 0)
mny = pow(10, 15)
table = [0] * (N + 1)
for x in range(1, N + 1):
table[x] = mny - p[x] - revp[x]
csmx = [0] * (N + 1)
for i in range(N, 0, -1): csmx[i - 1] = max(csmx[i - 1], table[i], csmx[i])
for i in range(N): print((csmx[i])) | p03305 |
import heapq
def dijkstra(adj, start):
ans = [float("inf")] * len(adj)
q = [(0, start)]
while len(q):
cost, node = heapq.heappop(q)
if cost > ans[node]:
continue
ans[node] = cost
for nxt in adj[node]:
heapq.heappush(q, (cost + adj[node][nxt], nxt))
return ans
def main():
n, m, s, t = list(map(int, input().split()))
adj1 = [{} for _ in range(n)]
adj2 = [{} for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
adj1[u-1][v-1] = a
adj1[v-1][u-1] = a
adj2[u-1][v-1] = b
adj2[v-1][u-1] = b
d1 = dijkstra(adj1, s-1)
d2 = dijkstra(adj2, t-1)
ans = [float("inf")] * n
ans[n-1] = d1[n-1] + d2[n-1]
for i in range(n-2, -1, -1):
ans[i] = min(d1[i] + d2[i], ans[i+1])
for i in range(n):
print((10**15 - ans[i]))
if __name__ == "__main__":
main()
| from heapq import heappush, heappop
def dijkstra(N, adj, start=0):
ans = [float("inf")] * N
q = [(0, start)]
while len(q):
cost, i = heappop(q)
if ans[i] <= cost:
continue
ans[i] = cost
for nxt in adj[i]:
if ans[nxt] == float("inf"):
heappush(q, (cost + adj[i][nxt], nxt))
return ans
def main():
n, m, s, t = list(map(int, input().split()))
adj1 = [{} for _ in range(n)]
adj2 = [{} for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
adj1[u-1][v-1] = a
adj1[v-1][u-1] = a
adj2[u-1][v-1] = b
adj2[v-1][u-1] = b
d1 = dijkstra(n, adj1, s-1)
d2 = dijkstra(n, adj2, t-1)
ans = [float("inf")] * n
ans[n-1] = d1[n-1] + d2[n-1]
for i in range(n-2, -1, -1):
ans[i] = min(d1[i] + d2[i], ans[i+1])
for i in range(n):
print((10**15 - ans[i]))
if __name__ == "__main__":
main()
| p03305 |
from collections import defaultdict
import heapq
n,m,s,t=list(map(int, input().strip().split()))
links_y=defaultdict(list)
links_s=defaultdict(list)
for i in range(m):
u,v,a,b=list(map(int, input().strip().split()))
links_y[u-1].append((v-1,a))
links_y[v-1].append((u-1,a))
links_s[u-1].append((v-1,b))
links_s[v-1].append((u-1,b))
def dijkstra(frm, links):
dist=[float('inf')]*n
dist[frm]=0
Q=[(0,frm)]
heapq.heapify(Q)
while Q:
d,u = heapq.heappop(Q)
for v,dd in links[u]:
if dist[v]> d+dd:
dist[v]=dd+d
heapq.heappush(Q,(dist[v],v))
return dist
yen_cost=dijkstra(s-1,links_y)
snk_cost=dijkstra(t-1,links_s)
sumyensnk=[i+j for i,j in zip(yen_cost,snk_cost)]
min_snk=[float('inf')]*n
tmp=float('inf')
for i in range(n)[::-1]:
min_snk[i] = min(sumyensnk[i],tmp)
tmp = min_snk[i]
money=10**15
for sumsnk in min_snk:
print((money-sumsnk)) | import heapq
n,m,s,t=list(map(int, input().strip().split()))
links_y=[[]for i in range(n) ]
links_s=[[]for i in range(n) ]
INF=float('inf')
for i in range(m):
u,v,a,b=list(map(int, input().strip().split()))
links_y[u-1].append((v-1,a))
links_y[v-1].append((u-1,a))
links_s[u-1].append((v-1,b))
links_s[v-1].append((u-1,b))
def dijkstra(frm, links):
dist=[INF]*n
dist[frm]=0
Q=[(0,frm)]
heapq.heapify(Q)
while Q:
d,u = heapq.heappop(Q)
for v,dd in links[u]:
if dist[v]> d+dd:
dist[v]=dd+d
heapq.heappush(Q,(dist[v],v))
return dist
yen_cost=dijkstra(s-1,links_y)
snk_cost=dijkstra(t-1,links_s)
sumyensnk=[i+j for i,j in zip(yen_cost,snk_cost)]
min_snk=[INF]*n
tmp=INF
for i in range(n)[::-1]:
min_snk[i] = min(sumyensnk[i],tmp)
tmp = min_snk[i]
money=10**15
for sumsnk in min_snk:
print((money-sumsnk)) | p03305 |
from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# graph[node] = [(cost, to)]
inf = float('inf')
dist = [inf]*node
dist[start] = 0
heap = [(0,start)]
while heap:
cost,thisNode = heappop(heap)
for NextCost,NextNode in graph[thisNode]:
dist_cand = dist[thisNode]+NextCost
if dist_cand < dist[NextNode]:
dist[NextNode] = dist_cand
heappush(heap,(dist[NextNode],NextNode))
return dist
n,m,s,t = list(map(int,input().split()))
g_a = [[] for i in range(n)]
g_b = [[] for i in range(n)]
for i in range(m):
u,v,a,b = list(map(int,input().split()))
g_a[u-1].append((a,v-1))
g_a[v-1].append((a,u-1))
g_b[u-1].append((b,v-1))
g_b[v-1].append((b,u-1))
d_a = dijkstra(g_a,n,s-1)
d_b = dijkstra(g_b,n,t-1)
d = []
for i in range(n):
d.append(d_a[i]+d_b[i])
d.reverse()
for i in range(n):
print((10**15-min(d)))
d.pop() | from heapq import heappush, heappop
def dijkstra(graph:list, node:int, start:int) -> list:
# graph[node] = [(cost, to)]
inf = float('inf')
dist = [inf]*node
dist[start] = 0
heap = [(0,start)]
while heap:
cost,thisNode = heappop(heap)
for NextCost,NextNode in graph[thisNode]:
dist_cand = dist[thisNode]+NextCost
if dist_cand < dist[NextNode]:
dist[NextNode] = dist_cand
heappush(heap,(dist[NextNode],NextNode))
return dist
n,m,s,t = list(map(int,input().split()))
g_a = [[] for i in range(n)]
g_b = [[] for i in range(n)]
for i in range(m):
u,v,a,b = list(map(int,input().split()))
g_a[u-1].append((a,v-1))
g_a[v-1].append((a,u-1))
g_b[u-1].append((b,v-1))
g_b[v-1].append((b,u-1))
d_a = dijkstra(g_a,n,s-1)
d_b = dijkstra(g_b,n,t-1)
d = []
for i in range(n):
d.append(d_a[i]+d_b[i])
d.reverse()
ans = []
m = float('inf')
for i in range(n):
m = min(m,d[i])
ans.append(10**15-m)
ans.reverse()
for i in range(n):
print((ans[i])) | p03305 |
import sys
input = sys.stdin.readline
from collections import defaultdict, deque
from itertools import accumulate
n,m,s,t= list(map(int,input().split()))
uvab = [list(map(int,input().split())) for i in range(m)]
g = defaultdict(list)
c = {}
for i in range(1,n+1):
g[i].append(n+i)
c[(i,n+i)] = 0
for u,v,a,b in uvab:
g[u].append(v)
g[v].append(u)
g[n+u].append(n+v)
g[n+v].append(n+u)
c[(u,v)] = a
c[(v,u)] = a
c[(n+u,n+v)] = b
c[(n+v,n+u)] = b
inf = 10**15
ds2t = [inf for i in range(2*n+1)]
ds2t[s] = 0
dq = deque([s])
while dq:
v = dq.popleft()
for nv in g[v]:
if ds2t[nv] > ds2t[v] + c[(v,nv)]:
ds2t[nv] = ds2t[v] + c[(v,nv)]
dq.append(nv)
dt2s = [inf for i in range(2*n+1)]
dt2s[n+t] = 0
dq = deque([n+t])
while dq:
v = dq.popleft()
for nv in g[v]:
if dt2s[nv] > dt2s[v] + c[(v,nv)]:
dt2s[nv] = dt2s[v] + c[(v,nv)]
dq.append(nv)
ds = []
for i in range(1,n+1):
ds.append(ds2t[i] + dt2s[n+i])
ds = accumulate(ds[::-1], min)
for d in reversed(list(ds)):
print((10**15-d))
| import sys
input = sys.stdin.readline
from collections import defaultdict, deque
from itertools import accumulate
n,m,s,t= list(map(int,input().split()))
uvab = [list(map(int,input().split())) for i in range(m)]
g = defaultdict(list)
c = {}
'''
for i in range(1,n+1):
g[i].append(n+i)
c[(i,n+i)] = 0
'''
for u,v,a,b in uvab:
g[u].append(v)
g[v].append(u)
g[n+u].append(n+v)
g[n+v].append(n+u)
c[(u,v)] = a
c[(v,u)] = a
c[(n+u,n+v)] = b
c[(n+v,n+u)] = b
inf = 10**15
ds2t = [inf for i in range(2*n+1)]
ds2t[s] = 0
dq = deque([s])
while dq:
v = dq.popleft()
for nv in g[v]:
if ds2t[nv] > ds2t[v] + c[(v,nv)]:
ds2t[nv] = ds2t[v] + c[(v,nv)]
dq.append(nv)
dt2s = [inf for i in range(2*n+1)]
dt2s[n+t] = 0
dq = deque([n+t])
while dq:
v = dq.popleft()
for nv in g[v]:
if dt2s[nv] > dt2s[v] + c[(v,nv)]:
dt2s[nv] = dt2s[v] + c[(v,nv)]
dq.append(nv)
ds = []
for i in range(1,n+1):
ds.append(ds2t[i] + dt2s[n+i])
ds = accumulate(ds[::-1], min)
for d in reversed(list(ds)):
print((10**15-d))
| p03305 |
import heapq
import sys
n, m, s, t = [int(i) for i in input().split()]
s -= 1
t -= 1
snuuk_dict = dict()
yen_dict = dict()
snuuk_que = []
yen_que = []
for i in range(m):
u, v, a, b = [int(i) for i in sys.stdin.readline().split()]
u -= 1
v -= 1
if snuuk_dict.get(u) is None:
snuuk_dict[u] = []
yen_dict[u] = []
if snuuk_dict.get(v) is None:
snuuk_dict[v] = []
yen_dict[v] = []
snuuk_dict[u].append([b, u, v])
snuuk_dict[v].append([b, v, u])
yen_dict[u].append([a, u, v])
yen_dict[v].append([a, v, u])
for i in snuuk_dict[t]:
heapq.heappush(snuuk_que, i)
for i in yen_dict[s]:
heapq.heappush(yen_que, i)
snuuk_ls = [-1 for i in range(n)]
yen_ls = [-1 for i in range(n)]
yen_ls[s] = 0
snuuk_ls[t] = 0
while len(yen_que) > 0:
a, u, v = heapq.heappop(yen_que)
if yen_ls[v] != -1:
continue
yen_ls[v] = a
for i in yen_dict[v]:
heapq.heappush(yen_que, [i[0] + yen_ls[v], i[1], i[2]])
while len(snuuk_que) > 0:
b, v, u = heapq.heappop(snuuk_que)
if snuuk_ls[u] != -1:
continue
snuuk_ls[u] = b
for i in snuuk_dict[u]:
heapq.heappush(snuuk_que, [i[0] + snuuk_ls[u], i[1], i[2]])
sum_ls = [10** 15 - (i + j) for i, j in zip(snuuk_ls, yen_ls)]
for i in range(n):
print((max(sum_ls[i:]))) | import heapq
import sys
n, m, s, t = [int(i) for i in input().split()]
s -= 1
t -= 1
snuuk_dict = dict()
yen_dict = dict()
snuuk_que = []
yen_que = []
for i in range(m):
u, v, a, b = [int(i) for i in sys.stdin.readline().split()]
u -= 1
v -= 1
if snuuk_dict.get(u) is None:
snuuk_dict[u] = []
yen_dict[u] = []
if snuuk_dict.get(v) is None:
snuuk_dict[v] = []
yen_dict[v] = []
snuuk_dict[u].append([b, u, v])
snuuk_dict[v].append([b, v, u])
yen_dict[u].append([a, u, v])
yen_dict[v].append([a, v, u])
for i in snuuk_dict[t]:
heapq.heappush(snuuk_que, i)
for i in yen_dict[s]:
heapq.heappush(yen_que, i)
snuuk_ls = [-1 for i in range(n)]
yen_ls = [-1 for i in range(n)]
yen_ls[s] = 0
snuuk_ls[t] = 0
while len(yen_que) > 0:
a, u, v = heapq.heappop(yen_que)
if yen_ls[v] != -1:
continue
yen_ls[v] = a
for i in yen_dict[v]:
if yen_ls[i[2]] == -1:
heapq.heappush(yen_que, [i[0] + yen_ls[v], i[1], i[2]])
while len(snuuk_que) > 0:
b, v, u = heapq.heappop(snuuk_que)
if snuuk_ls[u] != -1:
continue
snuuk_ls[u] = b
for i in snuuk_dict[u]:
if snuuk_ls[i[2]] == -1:
heapq.heappush(snuuk_que, [i[0] + snuuk_ls[u], i[1], i[2]])
sum_ls = [10** 15 - (i + j) for i, j in zip(snuuk_ls, yen_ls)]
_max = 0
for i in range(n):
_max = sum_ls[-1-i] if sum_ls[-1-i] > _max else _max
sum_ls[-i-1] = _max
for i in range(n):
print((sum_ls[i])) | p03305 |
import sys
from collections import namedtuple
from heapq import heappush, heappop
INF = sys.maxsize
P = namedtuple('P', 'cost v')
Edage = namedtuple('Edge', 'to cost')
n, m, s, t = list(map(int, input().split()))
s, t = s - 1, t - 1
# 円とスヌークそれぞれグラフを構成する
Yen = [[] for _ in range(n)]
Snuuk = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
u, v = u - 1, v - 1
Yen[u].append(Edage(v, a))
Yen[v].append(Edage(u, a))
Snuuk[u].append(Edage(v, b))
Snuuk[v].append(Edage(u, b))
def min_costs(graph, start):
costs = [INF] * n
costs[start] = 0
q = [P(0, start)]
while q:
cost, v = heappop(q)
if cost > costs[v]:
continue
for to, cost in graph[v]:
if costs[to] > costs[v] + cost:
costs[to] = costs[v] + cost
heappush(q, P(costs[to], to))
return costs
total_costs = [
min_costs(Yen, s)[i] + min_costs(Snuuk, t)[i]
for i in range(n)
]
# 両替所が閉鎖されていく
for i in range(n - 1, 0, -1):
total_costs[i - 1] = min(total_costs[i - 1], total_costs[i])
for i in range(n):
print((10 ** 15 - total_costs[i]))
| import sys
from collections import namedtuple
from heapq import heappush, heappop
INF = sys.maxsize
P = namedtuple('P', 'cost v')
Edage = namedtuple('Edge', 'to cost')
n, m, s, t = list(map(int, input().split()))
s, t = s - 1, t - 1
# 円とスヌークそれぞれグラフを構成する
Yen = [[] for _ in range(n)]
Snuuk = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
u, v = u - 1, v - 1
Yen[u].append(Edage(v, a))
Yen[v].append(Edage(u, a))
Snuuk[u].append(Edage(v, b))
Snuuk[v].append(Edage(u, b))
def min_costs(graph, start):
costs = [INF] * n
costs[start] = 0
q = [P(0, start)]
while q:
cost, v = heappop(q)
if cost > costs[v]:
continue
for to, cost in graph[v]:
if costs[to] > costs[v] + cost:
costs[to] = costs[v] + cost
heappush(q, P(costs[to], to))
return costs
min_costs_in_yen = min_costs(Yen, s)
min_costs_in_snuuk = min_costs(Snuuk, t)
total_costs = [
min_costs_in_yen[i] + min_costs_in_snuuk[i]
for i in range(n)
]
# 両替所が閉鎖されていく
for i in range(n - 1, 0, -1):
total_costs[i - 1] = min(total_costs[i - 1], total_costs[i])
for i in range(n):
print((10 ** 15 - total_costs[i]))
| p03305 |
#!/usr/bin/env python3
#SoundHound D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n,m,s,t = LI()
cost1 = [[inf]*n for _ in range(n)]
cost2 = [[inf]*n for _ in range(n)]
for _ in range(m):
u,v,a,b = LI()
cost1[u-1][v-1] = a
cost1[v-1][u-1] = a
cost2[u-1][v-1] = b
cost2[v-1][u-1] = b
def dijkstra(s,cost):
d = [inf]*n
used = [False]*n
d[s] = 0
while 1:
v = -1
for i in range(n):
if not used[i] and v == -1:
v = i
elif not used[i] and d[i] < d[v]:
v = i
if v == -1:
break
used[v] = True
for j in range(n):
d[j] = min(d[j],d[v] + cost[v][j])
return d
c1 = dijkstra(s-1,cost1)
c2 = dijkstra(t-1,cost2)
c = [c1[i] + c2[i] for i in range(n)]
money = 10**15
for i in range(n):
ans = money - min(c[i:])
print(ans)
| #!/usr/bin/env python3
#SoundHound D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n,m,s,t = LI()
graph1 = [[] for _ in range(n)]
graph2 = [[] for _ in range(n)]
for _ in range(m):
u,v,a,b = LI()
graph1[u-1].append((v-1,a))
graph1[v-1].append((u-1,a))
graph2[u-1].append((v-1,b))
graph2[v-1].append((u-1,b))
def dijkstra(s,graph):
d = [inf]*n
d[s] = 0
h = [(0,s)]
while h:
c,v = heappop(h)
if d[v] < c:
continue
for t,cost in graph[v]:
if d[v] + cost < d[t]:
d[t] = d[v] + cost
heappush(h,(d[t],t))
return d
c1 = dijkstra(s-1,graph1)
c2 = dijkstra(t-1,graph2)
c = [c1[i] + c2[i] for i in range(n)]
money = 10**15
for i in range(n):
ans = money - min(c[i:])
print(ans)
| p03305 |
#!/usr/bin/env python3
#SoundHound D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n,m,s,t = LI()
graph1 = [[] for _ in range(n)]
graph2 = [[] for _ in range(n)]
for _ in range(m):
u,v,a,b = LI()
graph1[u-1].append((v-1,a))
graph1[v-1].append((u-1,a))
graph2[u-1].append((v-1,b))
graph2[v-1].append((u-1,b))
def dijkstra(s,graph):
d = [inf]*n
d[s] = 0
h = [(0,s)]
while h:
c,v = heappop(h)
if d[v] < c:
continue
for t,cost in graph[v]:
if d[v] + cost < d[t]:
d[t] = d[v] + cost
heappush(h,(d[t],t))
return d
c1 = dijkstra(s-1,graph1)
c2 = dijkstra(t-1,graph2)
c = [c1[i] + c2[i] for i in range(n)]
money = 10**15
for i in range(n):
ans = money - min(c[i:])
print(ans)
| #!/usr/bin/env python3
#SoundHound D
import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n,m,s,t = LI()
graph1 = [[] for _ in range(n)]
graph2 = [[] for _ in range(n)]
for _ in range(m):
u,v,a,b = LI()
graph1[u-1].append((v-1,a))
graph1[v-1].append((u-1,a))
graph2[u-1].append((v-1,b))
graph2[v-1].append((u-1,b))
def dijkstra(s,graph):
d = [inf]*n
d[s] = 0
h = [(0,s)]
while h:
c,v = heappop(h)
if d[v] < c:
continue
for t,cost in graph[v]:
if d[v] + cost < d[t]:
d[t] = d[v] + cost
heappush(h,(d[t],t))
return d
c1 = dijkstra(s-1,graph1)
c2 = dijkstra(t-1,graph2)
c = [c1[i] + c2[i] for i in range(n)]
money = 10**15
mi = c[-1]
for i in range(n-1)[::-1]:
mi = min(mi,c[i])
c[i] = mi
for i in range(n):
print((money - c[i]))
| p03305 |
import heapq
class SegmentTree(object):
def __init__(self, A, dot, unit):
n = 1 << (len(A) - 1).bit_length()
tree = [unit] * (2 * n)
for i, v in enumerate(A):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n = n
self._tree = tree
self._dot = dot
self._unit = unit
def __getitem__(self, i):
return self._tree[i + self._n]
def update(self, i, v):
i += self._n
self._tree[i] = v
while i != 1:
i >>= 1
self._tree[i] = self._dot(self._tree[i << 1], self._tree[i << 1 | 1])
def add(self, i, v):
self.update(i, self[i] + v)
def sum(self, l, r):
l += self._n
r += self._n
l_val = r_val = self._unit
while l < r:
if l & 1:
l_val = self._dot(l_val, self._tree[l])
l += 1
if r & 1:
r -= 1
r_val = self._dot(self._tree[r], r_val)
l >>= 1
r >>= 1
return self._dot(l_val, r_val)
INF = float("inf")
YEN = pow(10,15)
n,m,s,t = list(map(int,input().split()))
s-=1;t-=1 #s,tを0index
yedge = [[] for _ in range(n)]
sedge = [[] for _ in range(n)]
for i in range(m):
u,v,a,b = list(map(int,input().split()))
u-=1;v-=1
yedge[u].append([a,v]);yedge[v].append([a,u])
sedge[u].append([b,v]);sedge[v].append([b,u])
def dijkstra_heap(s,edge):
#始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n #True:未確定。始点として探索されたか。というかdが更新されたか。
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist,e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中からスタートから最小の距離のものを探す
if not used[minedge[1]]: #すでに探索済みの場合にはスキップして次のプライオリティーキューへ。
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False #ここで始点として探索済みにする。
for e in edge[v]:
if used[e[1]]: #行き先がすでに始点として探索済みでない場合には値を更新。
heapq.heappush(edgelist,[e[0]+d[v],e[1]]) #重みをスタートからの最短重みにするため+d[v]
return d ##始点sから各頂点への最短距離がアウトプットとなる。
yto = dijkstra_heap(s,yedge)
sto = dijkstra_heap(s,sedge)
yot = dijkstra_heap(t,yedge)
sot = dijkstra_heap(t,sedge)
#print(yto)
#print(sto)
#print(yot)
#print(sot)
A = []
for i in range(n):
if i == s:
temp = sot[i]
elif i == t:
temp = yto[i]
else:
temp = yto[i]+sot[i]
A.append(temp)
#print(A)
Tree = SegmentTree(A,min, INF)
for i in range(n):
temp = Tree.sum(i,n)
ans = YEN - temp
print(ans) | import heapq
class SegmentTree(object):
def __init__(self, A, dot, unit):
n = 1 << (len(A) - 1).bit_length()
tree = [unit] * (2 * n)
for i, v in enumerate(A):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n = n
self._tree = tree
self._dot = dot
self._unit = unit
def __getitem__(self, i):
return self._tree[i + self._n]
def update(self, i, v):
i += self._n
self._tree[i] = v
while i != 1:
i >>= 1
self._tree[i] = self._dot(self._tree[i << 1], self._tree[i << 1 | 1])
def add(self, i, v):
self.update(i, self[i] + v)
def sum(self, l, r):
l += self._n
r += self._n
l_val = r_val = self._unit
while l < r:
if l & 1:
l_val = self._dot(l_val, self._tree[l])
l += 1
if r & 1:
r -= 1
r_val = self._dot(self._tree[r], r_val)
l >>= 1
r >>= 1
return self._dot(l_val, r_val)
INF = float("inf")
YEN = pow(10,15)
n,m,s,t = list(map(int,input().split()))
s-=1;t-=1 #s,tを0index
yedge = [[] for _ in range(n)]
sedge = [[] for _ in range(n)]
for i in range(m):
u,v,a,b = list(map(int,input().split()))
u-=1;v-=1
yedge[u].append([a,v]);yedge[v].append([a,u])
sedge[u].append([b,v]);sedge[v].append([b,u])
def dijkstra_heap(s,edge):
#始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n #True:未確定。始点として探索されたか。というかdが更新されたか。
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist,e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中からスタートから最小の距離のものを探す
if not used[minedge[1]]: #すでに探索済みの場合にはスキップして次のプライオリティーキューへ。
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False #ここで始点として探索済みにする。
for e in edge[v]:
if used[e[1]]: #行き先がすでに始点として探索済みでない場合には値を更新。
heapq.heappush(edgelist,[e[0]+d[v],e[1]]) #重みをスタートからの最短重みにするため+d[v]
return d ##始点sから各頂点への最短距離がアウトプットとなる。
yto = dijkstra_heap(s,yedge)
#sto = dijkstra_heap(s,sedge)
#yot = dijkstra_heap(t,yedge)
sot = dijkstra_heap(t,sedge)
#print(yto)
#print(sto)
#print(yot)
#print(sot)
A = []
for i in range(n):
if i == s:
temp = sot[i]
elif i == t:
temp = yto[i]
else:
temp = yto[i]+sot[i]
A.append(temp)
#print(A)
Tree = SegmentTree(A,min, INF)
for i in range(n):
temp = Tree.sum(i,n)
ans = YEN - temp
print(ans) | p03305 |
n, m, s, t = list(map(int, input().split()))
root1 = []
for i in range(n):
root1_ = [0] * n
root1.append(root1_)
root2 = []
for i in range(n):
root2_ = [0] * n
root2.append(root2_)
for i in range(m):
root = list(map(int, input().split()))
root1[root[0] - 1][root[1] - 1] = root[2]
root1[root[1] - 1][root[0] - 1] = root[2]
root2[root[0] - 1][root[1] - 1] = root[3]
root2[root[1] - 1][root[0] - 1] = root[3]
def min_cost(start, end, root):
confirmed = [[start, 0]]
edge = [start]
while len(confirmed) < n:
candidate = []
for i in range(len(edge)):
for j in range(n):
if root[edge[i] - 1][j] != 0:
for k in range(len(confirmed)):
if confirmed[k][0] == edge[i]:
candidate.append([j + 1, confirmed[k][1] + root[edge[i] - 1][j]])
break
candidate.sort(key = lambda x: x[1])
for i in range(len(candidate)):
if candidate[i][0] in [confirmed[i][0] for i in range(len(confirmed))]:
continue
else:
confirmed.append(candidate[i])
break
for i in range(len(confirmed)):
edge.append(confirmed[i][0])
exclude = []
for i in range(len(edge)):
flag = True
for j in range(n):
if root[edge[i] - 1][j] != 0 and (j + 1) not in edge:
flag = False
break
if flag == True:
exclude.append(edge[i])
edge = list(set(edge) - set(exclude))
for i in range(len(confirmed)):
if confirmed[i][0] == end:
return confirmed[i][1]
cost = []
for i in range(n):
cost1 = min_cost(s, i + 1, root1)
cost2 = min_cost(i + 1, t, root2)
cost.append(cost1 + cost2)
for i in range(n):
new_cost = cost[i:]
print((10 ** 15 - min(new_cost))) | n, m, s, t = list(map(int, input().split()))
root1 = {}
root2 = {}
for i in range(m):
u, v, a, b = list(map(int, input().split()))
root1[(u, v)] = a
root2[(u, v)] = b
def edge(G, x):
return([(b, G[(a, b)]) for (a, b) in G if a == x] + [(a, G[(a, b)]) for (a, b) in G if b == x])
def min_cost(G, start, end):
S = {start: 0}
D = {}
while len(S) > 0:
x = select_min(S)
m = S[x]
del S[x]
D[x] = m
for (y, w) in edge(G, x):
if y in S:
if S[y] > m + w:
S[y] = m + w
elif y not in D:
S[y] = m + w
return D[end]
def select_min(S):
m = -1
for a in S:
if m == -1 or m > S[a]:
x = a
m = S[a]
return x
cost = []
for i in range(n):
cost.append(min_cost(root1, s, i + 1) + min_cost(root2, i + 1, t))
for i in range(n):
print((10 ** 15 - min(cost[i:]))) | p03305 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.