input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import heapq
INF = 10 ** 17
def dijkstra(s):
#始点sから各頂点への最短距離
d = [INF] * (n+1)
used = [True] * (n+1) #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in graph_a[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 graph_a[v]:
if used[e[1]]:
heapq.heappush(edgelist,[e[0]+d[v],e[1]])
return d
def dijkstra1(s):
#始点sから各頂点への最短距離
d = [INF] * (n+1)
used = [True] * (n+1) #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in graph_b[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 graph_b[v]:
if used[e[1]]:
heapq.heappush(edgelist,[e[0]+d[v],e[1]])
return d
n, m, s, t = list(map(int, input().split()))
# graph作成
graph_a = {i: [] for i in range(1, n + 1)}
graph_b = {i: [] for i in range(1, n + 1)}
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
graph_a[u].append([a, v])
graph_a[v].append([a, u])
graph_b[u].append([b, v])
graph_b[v].append([b, u])
yen = dijkstra(s)
snu = dijkstra1(t)
cost = [0] * n
for i in range(n):
cost[i] = (yen[i + 1] + snu[i + 1],i)
heapq.heapify(cost)
c = -1
aaa = 10 ** 15
for i in range(n):
if c < i:
while cost:
nn, t = heapq.heappop(cost)
if t >= i:
c = t
break
print((aaa - nn))
| import heapq
INF = 10**18
def dijkstra(s, edge, n):
d = [INF] * n
used = [True] * n #True: not used
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]))
return d
n, m, s, t = list(map(int, input().split()))
s -= 1
t -= 1
graph_a = [[] for _ in range(n)]
graph_b = [[] for _ in range(n)]
for i in range(m):
u, v, a, b = list(map(int, input().split()))
u, v = u-1, v-1
graph_a[u].append((a, v))
graph_a[v].append((a, u))
graph_b[u].append((b, v))
graph_b[v].append((b, u))
yen = dijkstra(s, graph_a, n)
snu = dijkstra(t, graph_b, n)
cost = [0] * n
for i in range(n):
cost[i] = (yen[i] + snu[i],i)
heapq.heapify(cost)
c = -1
aaa = 10 ** 15
for i in range(n):
if c < i:
while cost:
nn, t = heapq.heappop(cost)
if t >= i:
c = t
break
print((aaa - nn))
| p03305 |
n, m, s, t = list(map(int, input().split()))
yen_edge = [[] for _ in range(n)]
snuke_edge = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
yen_edge[u - 1].append([v - 1, a])
yen_edge[v - 1].append([u - 1, a])
snuke_edge[u - 1].append([v - 1, b])
snuke_edge[v - 1].append([u - 1, b])
import heapq
class Dijkstra(object):
def dijkstra(self, lst, start, goal=None):
'''
ダイクストラアルゴリズムによる最短経路を求めるメソッド
入力
adj: adj[i][j]の値が頂点iから頂点jまでの距離(頂点iから頂点jに枝がない場合，値はfloat('inf'))となるような2次元リスト(正方行列)
start: 始点のID
lst: 隣接リスト
goal: オプション引数．終点のID
出力
goalを引数に持つ場合，startからgoalまでの最短経路を格納したリストを返す
持たない場合は，startから各頂点までの最短距離を格納したリストを返す
>>> d = Dijkstra()
>>> d.dijkstra([[float('inf'), 2, 4, float('inf'), float('inf')], [2, float('inf'), 3, 5, float('inf')], [4, 3, float('inf'), 1, 4], [float('inf'), 5, 1, float('inf'), 3], [float('inf'), float('inf'), 4, 3, float('inf')]], 0)
[0, 2, 4, 5, 8] # 例えば，始点0から頂点3までの最短距離は5となる
>>> d.dijkstra([[float('inf'), 2, 4, float('inf'), float('inf')], [2, float('inf'), 3, 5, float('inf')], [4, 3, float('inf'), 1, 4], [float('inf'), 5, 1, float('inf'), 3], [float('inf'), float('inf'), 4, 3, float('inf')]], 0, goal=4)
[0, 2, 4] # 頂点0から頂点4までの最短経路は0 -> 2 -> 4となる
'''
num = len(lst) # グラフのノード数
dist = [float('inf') for i in range(num)] # 始点から各頂点までの最短距離を格納する
prev = [float('inf') for i in range(num)] # 最短経路における，その頂点の前の頂点のIDを格納する
dist[start] = 0
q = [] # プライオリティキュー．各要素は，(startからある頂点vまでの仮の距離, 頂点vのID)からなるタプル
heapq.heappush(q, (0, start)) # 始点をpush
while len(q) != 0:
prov_cost, src = heapq.heappop(q) # pop
# プライオリティキューに格納されている最短距離が，現在計算できている最短距離より大きければ，distの更新をする必要はない
if dist[src] < prov_cost:
continue
# 他の頂点の探索
# for dest in range(num):
for dest in lst[src]:
# cost = adj[src][dest]
cost = dest[1]
# if dist[dest] > dist[src] + cost:
if dist[dest[0]] > dist[src] + cost:
# dist[dest] = dist[src] + cost # distの更新
dist[dest[0]] = dist[src] + cost
# heapq.heappush(q, (dist[dest], dest)) # キューに新たな仮の距離の情報をpush
heapq.heappush(q, (dist[dest[0]], dest[0]))
# prev[dest] = src # 前の頂点を記録
prev[dest[0]] = src
# 以下は経路を返すプログラム
# if goal is not None:
# return self.get_path(goal, prev)
if goal is not None:
return dist[goal]
else:
return dist
def get_path(self, goal, prev):
'''
始点startから終点goalまでの最短経路を求める
'''
path = [goal] # 最短経路
dest = goal
# 終点から最短経路を逆順に辿る
while prev[dest] != float('inf'):
path.append(prev[dest])
dest = prev[dest]
# 経路をreverseして出力
return list(reversed(path))
d = Dijkstra()
yen = d.dijkstra(yen_edge, s - 1)
snuke = d.dijkstra(snuke_edge, t - 1)
ans_list = []
for i in range(n):
ans_list.append(yen[i] + snuke[i])
ans = []
ans.append(10 ** 15 - ans_list[n - 1])
for i in range(1, n):
if ans_list[n - i - 1] > ans_list[n - i]:
ans_list[n - i - 1] = ans_list[n - i]
ans.append(10 ** 15 - ans_list[n - i - 1])
for i in range(n - 1, -1, -1):
print((ans[i])) | import heapq, sys
def input():
return sys.stdin.readline()[:-1]
n, m, s, t = list(map(int, input().split()))
yen_edge = [[] for _ in range(n)]
snuke_edge = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
yen_edge[u - 1].append([v - 1, a])
yen_edge[v - 1].append([u - 1, a])
snuke_edge[u - 1].append([v - 1, b])
snuke_edge[v - 1].append([u - 1, b])
class DijkstraList():
#隣接リスト版
#同一頂点の複数回探索を防ぐため訪問した頂点数を変数cntで持つ
def __init__(self, adj, start):
self.list = adj
self.start = start
self.size = len(adj)
def solve(self):
self.dist = [float("inf") for _ in range(self.size)]
self.dist[self.start] = 0
self.prev = [-1 for _ in range(self.size)]
self.q = []
self.cnt = 0
heapq.heappush(self.q, (0, self.start))
while self.q and self.cnt < self.size:
u_dist, u = heapq.heappop(self.q)
if self.dist[u] < u_dist:
continue
for v, w in self.list[u]:
if self.dist[v] > u_dist + w:
self.dist[v] = u_dist + w
self.prev[v] = u
heapq.heappush(self.q, (self.dist[v], v))
self.cnt += 1
return
def distance(self, goal):
return self.dist[goal]
def path(self, goal):
self.path = [goal]
while self.path[-1] != self.start:
self.path.append(self.prev[self.path[-1]])
return self.path[::-1]
yen = DijkstraList(yen_edge, s - 1)
snuke = DijkstraList(snuke_edge, t - 1)
yen.solve()
snuke.solve()
ans_list = []
for i in range(n):
ans_list.append(yen.distance(i) + snuke.distance(i))
ans = []
ans.append(10 ** 15 - ans_list[n - 1])
for i in range(1, n):
if ans_list[n - i - 1] > ans_list[n - i]:
ans_list[n - i - 1] = ans_list[n - i]
ans.append(10 ** 15 - ans_list[n - i - 1])
for i in range(n - 1, -1, -1):
print((ans[i])) | p03305 |
import heapq, sys
def input():
return sys.stdin.readline()[:-1]
n, m, s, t = list(map(int, input().split()))
yen_edge = [[] for _ in range(n)]
snuke_edge = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
yen_edge[u - 1].append([v - 1, a])
yen_edge[v - 1].append([u - 1, a])
snuke_edge[u - 1].append([v - 1, b])
snuke_edge[v - 1].append([u - 1, b])
class DijkstraList():
#隣接リスト版
#同一頂点の複数回探索を防ぐため訪問した頂点数を変数cntで持つ
def __init__(self, adj, start):
self.list = adj
self.start = start
self.size = len(adj)
def solve(self):
self.dist = [float("inf") for _ in range(self.size)]
self.dist[self.start] = 0
self.prev = [-1 for _ in range(self.size)]
self.q = []
self.cnt = 0
heapq.heappush(self.q, (0, self.start))
while self.q and self.cnt < self.size:
u_dist, u = heapq.heappop(self.q)
if self.dist[u] < u_dist:
continue
for v, w in self.list[u]:
if self.dist[v] > u_dist + w:
self.dist[v] = u_dist + w
self.prev[v] = u
heapq.heappush(self.q, (self.dist[v], v))
self.cnt += 1
return
def distance(self, goal):
return self.dist[goal]
def path(self, goal):
self.path = [goal]
while self.path[-1] != self.start:
self.path.append(self.prev[self.path[-1]])
return self.path[::-1]
yen = DijkstraList(yen_edge, s - 1)
snuke = DijkstraList(snuke_edge, t - 1)
yen.solve()
snuke.solve()
ans_list = []
for i in range(n):
ans_list.append(yen.distance(i) + snuke.distance(i))
ans = []
ans.append(10 ** 15 - ans_list[n - 1])
for i in range(1, n):
if ans_list[n - i - 1] > ans_list[n - i]:
ans_list[n - i - 1] = ans_list[n - i]
ans.append(10 ** 15 - ans_list[n - i - 1])
for i in range(n - 1, -1, -1):
print((ans[i])) | import heapq, sys
n, m, s, t = list(map(int, input().split()))
yen_edge = [[] for _ in range(n)]
snuke_edge = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
yen_edge[u - 1].append([v - 1, a])
yen_edge[v - 1].append([u - 1, a])
snuke_edge[u - 1].append([v - 1, b])
snuke_edge[v - 1].append([u - 1, b])
class DijkstraList():
#隣接リスト版
#同一頂点の複数回探索を防ぐため訪問した頂点数を変数cntで持つ
def __init__(self, adj, start):
self.list = adj
self.start = start
self.size = len(adj)
def solve(self):
self.dist = [float("inf") for _ in range(self.size)]
self.dist[self.start] = 0
self.prev = [-1 for _ in range(self.size)]
self.q = []
self.cnt = 0
heapq.heappush(self.q, (0, self.start))
while self.q and self.cnt < self.size:
u_dist, u = heapq.heappop(self.q)
if self.dist[u] < u_dist:
continue
for v, w in self.list[u]:
if self.dist[v] > u_dist + w:
self.dist[v] = u_dist + w
self.prev[v] = u
heapq.heappush(self.q, (self.dist[v], v))
self.cnt += 1
return
def distance(self, goal):
return self.dist[goal]
def path(self, goal):
self.path = [goal]
while self.path[-1] != self.start:
self.path.append(self.prev[self.path[-1]])
return self.path[::-1]
yen = DijkstraList(yen_edge, s - 1)
snuke = DijkstraList(snuke_edge, t - 1)
yen.solve()
snuke.solve()
ans_list = []
for i in range(n):
ans_list.append(yen.distance(i) + snuke.distance(i))
ans = []
ans.append(10 ** 15 - ans_list[n - 1])
for i in range(1, n):
if ans_list[n - i - 1] > ans_list[n - i]:
ans_list[n - i - 1] = ans_list[n - i]
ans.append(10 ** 15 - ans_list[n - i - 1])
for i in range(n - 1, -1, -1):
print((ans[i])) | p03305 |
import heapq, sys
n, m, s, t = list(map(int, input().split()))
yen_edge = [[] for _ in range(n)]
snuke_edge = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
yen_edge[u - 1].append([v - 1, a])
yen_edge[v - 1].append([u - 1, a])
snuke_edge[u - 1].append([v - 1, b])
snuke_edge[v - 1].append([u - 1, b])
class DijkstraList():
#隣接リスト版
#同一頂点の複数回探索を防ぐため訪問した頂点数を変数cntで持つ
def __init__(self, adj, start):
self.list = adj
self.start = start
self.size = len(adj)
def solve(self):
self.dist = [float("inf") for _ in range(self.size)]
self.dist[self.start] = 0
self.prev = [-1 for _ in range(self.size)]
self.q = []
self.cnt = 0
heapq.heappush(self.q, (0, self.start))
while self.q and self.cnt < self.size:
u_dist, u = heapq.heappop(self.q)
if self.dist[u] < u_dist:
continue
for v, w in self.list[u]:
if self.dist[v] > u_dist + w:
self.dist[v] = u_dist + w
self.prev[v] = u
heapq.heappush(self.q, (self.dist[v], v))
self.cnt += 1
return
def distance(self, goal):
return self.dist[goal]
def path(self, goal):
self.path = [goal]
while self.path[-1] != self.start:
self.path.append(self.prev[self.path[-1]])
return self.path[::-1]
yen = DijkstraList(yen_edge, s - 1)
snuke = DijkstraList(snuke_edge, t - 1)
yen.solve()
snuke.solve()
ans_list = []
for i in range(n):
ans_list.append(yen.distance(i) + snuke.distance(i))
ans = []
ans.append(10 ** 15 - ans_list[n - 1])
for i in range(1, n):
if ans_list[n - i - 1] > ans_list[n - i]:
ans_list[n - i - 1] = ans_list[n - i]
ans.append(10 ** 15 - ans_list[n - i - 1])
for i in range(n - 1, -1, -1):
print((ans[i])) | import heapq, sys
def input():
return sys.stdin.readline()[:-1]
n, m, s, t = list(map(int, input().split()))
yen_edge = [[] for _ in range(n)]
snuke_edge = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
yen_edge[u - 1].append([v - 1, a])
yen_edge[v - 1].append([u - 1, a])
snuke_edge[u - 1].append([v - 1, b])
snuke_edge[v - 1].append([u - 1, b])
class DijkstraList():
#隣接リスト版
#同一頂点の複数回探索を防ぐため訪問した頂点数を変数cntで持つ
def __init__(self, adj, start):
self.list = adj
self.start = start
self.size = len(adj)
def solve(self):
self.dist = [10**30 for _ in range(self.size)]
self.dist[self.start] = 0
#self.prev = [-1 for _ in range(self.size)]
self.q = []
self.cnt = 0
heapq.heappush(self.q, (0, self.start))
while self.q and self.cnt < self.size:
u_dist, u = heapq.heappop(self.q)
if self.dist[u] < u_dist:
continue
for v, w in self.list[u]:
if self.dist[v] > u_dist + w:
self.dist[v] = u_dist + w
#self.prev[v] = u
heapq.heappush(self.q, (self.dist[v], v))
self.cnt += 1
return
def distance(self, goal):
return self.dist[goal]
yen = DijkstraList(yen_edge, s - 1)
snuke = DijkstraList(snuke_edge, t - 1)
yen.solve()
snuke.solve()
ans_list = []
for i in range(n):
ans_list.append(yen.distance(i) + snuke.distance(i))
ans = []
ans.append(10 ** 15 - ans_list[n - 1])
for i in range(1, n):
if ans_list[n - i - 1] > ans_list[n - i]:
ans_list[n - i - 1] = ans_list[n - i]
ans.append(10 ** 15 - ans_list[n - i - 1])
for i in range(n - 1, -1, -1):
print((ans[i])) | p03305 |
import sys
input = sys.stdin.readline
import heapq
def dijkstra(n, graph, s, yen=True):
dist = [10**18] * n
queue = [(s, 0)]
dist[s] = 0
while queue:
v, d = heapq.heappop(queue)
if dist[v] < d:
continue
for child, costa, costb in graph[v]:
if yen:
cost = costa
else:
cost = costb
if dist[v] + cost < dist[child]:
dist[child] = dist[v] + cost
heapq.heappush(queue, (child, dist[child]))
return dist
def main():
n, m, s, t = map(int, input().split())
s -= 1
t -= 1
graph = [[] for _ in range(n)]
for i in range(m):
u, v, a, b = map(int, input().split())
u -= 1
v -= 1
graph[u].append((v, a, b))
graph[v].append((u, a, b))
s_dist = dijkstra(n, graph, s, True)
t_dist = dijkstra(n, graph, t, False)
cost = 10 ** 18
ans = [0] * n
for i in range(n-1, -1, -1):
cost = min(cost, s_dist[i] + t_dist[i])
ans[i] = 10 ** 15 - cost
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
from heapq import heappop, heappush
INF = 10 ** 18
def dijkstra(n, s, g, mode):
dist = [INF] * n
dist[s] = 0
hq = [(0, s)]
while hq:
d, v = heappop(hq)
if dist[v] < d:
continue
for w, *a in g[v]:
nd = d + a[mode]
if dist[w] > nd:
dist[w] = nd
heappush(hq, (nd, w))
return dist
def main():
n, m, s, t = map(int, input().split())
s -= 1
t -= 1
graph = [[] for _ in range(n)]
for i in range(m):
u, v, a, b = map(int, input().split())
u -= 1
v -= 1
graph[u].append((v, a, b))
graph[v].append((u, a, b))
s_dist = dijkstra(n, s, graph, 0)
t_dist = dijkstra(n, t, graph, 1)
cost = float("inf")
ans = [0] * n
for i in range(n-1, -1, -1):
cost = min(cost, s_dist[i] + t_dist[i])
ans[i] = 10 ** 15 - cost
print(*ans, sep="\n")
if __name__ == '__main__':
main()
| p03305 |
from queue import PriorityQueue as PQ
INF = float('inf')
yen = 10**15
def pcc(src, adj):
global n
pq = PQ()
dist = [INF]*(n+1)
dist[src] = 0
pq.put([0,src])
while not pq.empty():
d,u = pq.get()
for w, v in adj[u]:
if dist[v] > dist[u] + w:
dist[v] = dist[u] + w
pq.put([dist[v], v])
return dist
n,m,s,t = (int(i) for i in input().split())
adjs = []
adjt = []
for i in range(n+1):
adjs += [[]]
adjt += [[]]
for i in range(m):
u,v,a,b = (int(i) for i in input().split())
adjs[u].append([a,v])
adjs[v].append([a,u])
adjt[u].append([b,v])
adjt[v].append([b,u])
dist_s = pcc(s,adjs)
dist_t = pcc(t,adjt)
ans = [0]*(n+1)
ans[n] = dist_s[n] + dist_t[n]
for i in range(n-1,0,-1):
ans[i] = min(ans[i+1], dist_s[i] + dist_t[i])
for i in range(1,n+1):
print((yen-ans[i]))
| import heapq
INF = float('inf')
yen = 10**15
def pcc(src, adj):
global n
pq = [(0,src)]
heapq.heapify(pq)
dist = [INF]*(n+1)
dist[src] = 0
while pq:
d,u = heapq.heappop(pq)
for w, v in adj[u]:
if dist[v] > dist[u] + w:
dist[v] = dist[u] + w
heapq.heappush(pq, (dist[v], v))
return dist
n,m,s,t = (int(i) for i in input().split())
adjs = []
adjt = []
for i in range(n+1):
adjs += [[]]
adjt += [[]]
for i in range(m):
u,v,a,b = (int(i) for i in input().split())
adjs[u].append([a,v])
adjs[v].append([a,u])
adjt[u].append([b,v])
adjt[v].append([b,u])
dist_s = pcc(s,adjs)
dist_t = pcc(t,adjt)
ans = [0]*(n+1)
ans[n] = dist_s[n] + dist_t[n]
for i in range(n-1,0,-1):
ans[i] = min(ans[i+1], dist_s[i] + dist_t[i])
for i in range(1,n+1):
print((yen-ans[i]))
| p03305 |
import heapq
INF = float('inf')
yen = 10**15
def pcc(src, adj):
pq = [(0,src)]
heapq.heapify(pq)
dist = [INF]*(n+1)
dist[src] = 0
while pq:
d,u = heapq.heappop(pq)
if d>dist[u]:continue
for w, v in adj[u]:
if dist[v] > dist[u] + w:
dist[v] = dist[u] + w
heapq.heappush(pq, (dist[v], v))
return dist
n,m,s,t = (int(i) for i in input().split())
adjs = [[] for _ in range(n+1)]
adjt = [[] for _ in range(n+1)]
for _ in range(m):
u,v,a,b = (int(i) for i in input().split())
adjs[u].append([a,v])
adjs[v].append([a,u])
adjt[u].append([b,v])
adjt[v].append([b,u])
dist_s = pcc(s,adjs)
dist_t = pcc(t,adjt)
ans = [0]*(n)
ans[n-1] = yen -dist_s[n] - dist_t[n]
for i in range(n-2,-1,-1):
ans[i] = max(ans[i+1], yen - dist_s[i+1] - dist_t[i+1])
print(*ans, sep = '\n')
| import heapq
def dijkstra(s, neighbor):
dist = [float('inf')] * N
dist[s] = 0
que = [(0, s)]
heapq.heapify(que)
while que:
d, v = heapq.heappop(que)
if d > dist[v]:
continue
for u, l in neighbor[v]:
tmp_d = d + l
if tmp_d < dist[u]:
dist[u] = tmp_d
heapq.heappush(que, (tmp_d, u))
return dist
N, M, s, t = map(int, input().split())
yen = [[] for _ in range(N)]
snuuk = [[] for _ in range(N)]
for _ in range(M):
u, v, a, b = map(int, input().split())
yen[u-1].append((v-1, a))
yen[v-1].append((u-1, a))
snuuk[u-1].append((v-1, b))
snuuk[v-1].append((u-1, b))
dist_s = dijkstra(s-1, yen)
dist_t = dijkstra(t-1, snuuk)
ans = [-1] * N
tmp = float('inf')
for i in range(N-1, -1, -1):
if dist_s[i] + dist_t[i] < tmp:
tmp = dist_s[i] + dist_t[i]
ans[i] = 10 ** 15 - tmp
print(*ans, sep='\n')
| p03305 |
import heapq
INF = float('inf')
yen = 10**15
def pcc(src, adj):
pq = [(0,src)]
heapq.heapify(pq)
dist = [INF]*(n+1)
dist[src] = 0
while pq:
d,u = heapq.heappop(pq)
if d>dist[u]:continue
for w, v in adj[u]:
if dist[v] > dist[u] + w:
dist[v] = dist[u] + w
heapq.heappush(pq, (dist[v], v))
return dist
n,m,s,t = (int(i) for i in input().split())
adjs = [[] for _ in range(n+1)]
adjt = [[] for _ in range(n+1)]
for _ in range(m):
u,v,a,b = map(int, input().split())
adjs[u].append([a,v])
adjs[v].append([a,u])
adjt[u].append([b,v])
adjt[v].append([b,u])
dist_s = pcc(s,adjs)
dist_t = pcc(t,adjt)
ans = [0]*(n)
ans[n-1] = yen -dist_s[n] - dist_t[n]
for i in range(n-2,-1,-1):
ans[i] = max(ans[i+1], yen - dist_s[i+1] - dist_t[i+1])
print(*ans, sep = '\n')
| import heapq
INF = float('inf')
yen = 10**15
def pcc(src, adj):
pq = [(0,src)]
heapq.heapify(pq)
dist = [INF]*n
dist[src] = 0
while pq:
d,u = heapq.heappop(pq)
if d>dist[u]:continue
for w, v in adj[u]:
if dist[v] > dist[u] + w:
dist[v] = dist[u] + w
heapq.heappush(pq, (dist[v], v))
return dist
n,m,s,t = map(int, input().split())
s,t = s-1,t-1
adjs = [[] for _ in range(n)]
adjt = [[] for _ in range(n)]
for _ in range(m):
u,v,a,b = map(int, input().split())
u,v = u-1, v-1
adjs[u].append((a,v))
adjs[v].append((a,u))
adjt[u].append((b,v))
adjt[v].append((b,u))
dist_s = pcc(s,adjs)
dist_t = pcc(t,adjt)
ans = [0]*(n)
ans[n-1] = yen -dist_s[n-1] - dist_t[n-1]
for i in range(n-2,-1,-1):
ans[i] = max(ans[i+1], yen - dist_s[i] - dist_t[i])
print(*ans, sep = '\n')
| p03305 |
import heapq
INF = float('inf')
yen = 10**15
def pcc(src, adj):
pq = [(0,src)]
heapq.heapify(pq)
dist = [INF]*n
dist[src] = 0
while pq:
d,u = heapq.heappop(pq)
if d>dist[u]:continue
for w, v in adj[u]:
if dist[v] > dist[u] + w:
dist[v] = dist[u] + w
heapq.heappush(pq, (dist[v], v))
return dist
n,m,s,t = map(int, input().split())
s,t = s-1,t-1
adjs = [[] for _ in range(n)]
adjt = [[] for _ in range(n)]
for _ in range(m):
u,v,a,b = map(int, input().split())
u,v = u-1, v-1
adjs[u].append((a,v))
adjs[v].append((a,u))
adjt[u].append((b,v))
adjt[v].append((b,u))
dist_s = pcc(s,adjs)
dist_t = pcc(t,adjt)
ans = [0]*(n)
ans[n-1] = yen -dist_s[n-1] - dist_t[n-1]
for i in range(n-2,-1,-1):
ans[i] = max(ans[i+1], yen - dist_s[i] - dist_t[i])
print(*ans, sep = '\n')
| import heapq
def pcc(src, adj):
pq = [(0,src)]
dist = [float('inf')]*n
dist[src] = 0
heapq.heapify(pq)
while pq:
d, u = heapq.heappop(pq)
for w, v in adj[u]:
if dist[v] > dist[u] + w:
dist[v] = dist[u] + w
heapq.heappush(pq, (dist[v], v))
return dist
n,m,s,t = map(int,input().split())
s,t = s-1,t-1
adjs = [[] for _ in range(n)]
adjt = [[] for _ in range(n)]
for _ in range(m):
u,v,a,b = map(int, input().split())
u,v = u-1,v-1
adjs[u].append((a,v))
adjs[v].append((a,u))
adjt[u].append((b,v))
adjt[v].append((b,u))
dist_s = pcc(s, adjs)
dist_t = pcc(t, adjt)
ans = [0]*n
ans[n-1] = 10**15 - dist_s[n-1]-dist_t[n-1]
for i in range(n-2,-1,-1):
ans[i] = max(ans[i+1], 10**15 - dist_s[i] - dist_t[i])
print(*ans, sep = "\n")
| p03305 |
def dijkstra(s,n,w,cost):
#始点sから各頂点への最短距離
#n:頂点数, w:辺の数, cost[u][v] : 辺uvのコスト(存在しないときはinf)
d = [float("inf")] * n
used = [False] * n
d[s] = 0
while True:
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
n, m, s, t = list(map(int, input().split()))
trains = [list(map(int, input().split())) for i in range(m)]
INF = float('inf')
cost_yen = [[INF for i in range(n)] for j in range(n)]
cost_snuuk = [[INF for i in range(n)] for j in range(n)]
for train in trains:
u, v, a, b = train
cost_yen[u-1][v-1] = a
cost_yen[v-1][u-1] = a
cost_snuuk[u-1][v-1] = b
cost_snuuk[v-1][u-1] = b
d_yen = dijkstra(s-1, n, m, cost_yen)
d_snuuk = dijkstra(t-1, n, m, cost_snuuk)
for i in range(n):
cost_sum = [x+y for x, y in zip(d_yen[i:], d_snuuk[i:])]
print((10**15 - min(cost_sum)))
| import sys
def dijkstra(s,n,w,cost):
#始点sから各頂点への最短距離
#n:頂点数, w:辺の数, cost[u][v] : 辺uvのコスト(存在しないときはinf)
d = [float("inf")] * n
used = [False] * n
d[s] = 0
while True:
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
input = sys.stdin.readline
n, m, s, t = list(map(int, input().split()))
trains = [list(map(int, input().split())) for i in range(m)]
INF = float('inf')
cost_yen = [[INF for i in range(n)] for j in range(n)]
cost_snuuk = [[INF for i in range(n)] for j in range(n)]
for train in trains:
u, v, a, b = train
cost_yen[u-1][v-1] = a
cost_yen[v-1][u-1] = a
cost_snuuk[u-1][v-1] = b
cost_snuuk[v-1][u-1] = b
d_yen = dijkstra(s-1, n, m, cost_yen)
d_snuuk = dijkstra(t-1, n, m, cost_snuuk)
for i in range(n):
cost_sum = [x+y for x, y in zip(d_yen[i:], d_snuuk[i:])]
print((10**15 - min(cost_sum)))
| p03305 |
from heapq import heapify,heappop,heappush
N,M,s,t=list(map(int,input().split()))
Graph1=[set() for i in range(N)]
Graph2=[set() for i in range(N)]
inf=float("inf")
for i in range(M):
u,v,a,b=list(map(int,input().split()))
Graph1[u-1].add((a,v-1))
Graph1[v-1].add((a,u-1))
Graph2[u-1].add((b,v-1))
Graph2[v-1].add((b,u-1))
def dijkstra(s,n,links):
cost=[inf]*n
visited=[False]*n
visited[s]=True
cost[s]=0
heap=[(0,s)]
heapify(heap)
while heap:
hc,hp=heappop(heap)
visited[hp]=True
for c,p in links[hp]:
if not visited[p]:
if c+hc<=cost[p]:
cost[p]=c+hc
heappush(heap,(cost[p],p))
return cost
cost1=dijkstra(s-1,N,Graph1)
cost2=dijkstra(t-1,N,Graph2)
ans=[0]*N
a=inf
for i in range(N)[::-1]:
a=min(a,cost1[i]+cost2[i])
ans[i]=10**15-a
for i in ans:
print(i) | from heapq import heapify,heappop,heappush
N,M,s,t=list(map(int,input().split()))
Graph1=[set() for i in range(N)]
Graph2=[set() for i in range(N)]
inf=float("inf")
for i in range(M):
u,v,a,b=list(map(int,input().split()))
Graph1[u-1].add((a,v-1))
Graph1[v-1].add((a,u-1))
Graph2[u-1].add((b,v-1))
Graph2[v-1].add((b,u-1))
def dijkstra(s,n,links):
cost=[inf]*n
visited=[False]*n
cost[s]=0
heap=[(0,s)]
heapify(heap)
while heap:
hc,hp=heappop(heap)
if not visited[hp]:
visited[hp]=True
for c,p in links[hp]:
if not visited[p]:
if c+hc<=cost[p]:
cost[p]=c+hc
heappush(heap,(cost[p],p))
return cost
cost1=dijkstra(s-1,N,Graph1)
cost2=dijkstra(t-1,N,Graph2)
ans=[0]*N
a=inf
for i in range(N)[::-1]:
a=min(a,cost1[i]+cost2[i])
ans[i]=10**15-a
for i in ans:
print(i) | p03305 |
from collections import defaultdict
from heapq import heapify, heappop
import heapq
n,m,s,t =list(map(int,input().split()))
MAX_VAL = 10**20
uvab = [list(map(int,input().split())) for _ in range(m)]
jpy_cost = defaultdict(lambda :defaultdict(lambda :MAX_VAL))
snuke_cost = defaultdict(lambda :defaultdict(lambda :MAX_VAL))
for u,v,a,b in uvab:
u=u-1
v=v-1
jpy_cost[u][v] = a
jpy_cost[v][u] =a
snuke_cost[u][v]=b
snuke_cost[v][u]=b
# Dijktra's shortest path algorithm. Prints the path from source to target.
def dijkstra(adj, source):
INF = MAX_VAL
dist = [INF for x in range(n)]
dist[source] = 0
PQ = []
heapq.heappush(PQ, [dist[source], source])
while (PQ):
u_dist,u_id = heapq.heappop(PQ) # u is a tuple [u_dist, u_id]
if u_dist == dist[u_id]:
for v in adj[u_id]:
w_uv = adj[u_id][v]
if dist[u_id] + w_uv < dist[v]:
dist[v] = dist[u_id] + w_uv
heapq.heappush(PQ, [dist[v], v])
return dist
jpy_dijk = dijkstra(jpy_cost,s-1)
snuke_dijk = dijkstra(snuke_cost,t-1)
#
# print(s,t)
# print(jpy_dijk)
# print(snuke_dijk)
# print([jpy_dijk[i]+snuke_dijk[i] for i in range(n)])
#ord n
res = []
min_val = MAX_VAL
for i in reversed(list(range(n))):
#都市 i で両替
val = jpy_dijk[i]+ snuke_dijk[i]
assert val < MAX_VAL
min_val=min(min_val,val)
res.append(min_val)
#ord n
for x in reversed(res):
print((10**15- x))
| from collections import defaultdict
from heapq import heapify, heappop
import heapq
n,m,s,t =list(map(int,input().split()))
MAX_VAL = 10**20
uvab = [list(map(int,input().split())) for _ in range(m)]
jpy_cost = defaultdict(dict)
snuke_cost = defaultdict(dict)
for u,v,a,b in uvab:
u=u-1
v=v-1
jpy_cost[u][v] = a
jpy_cost[v][u] =a
snuke_cost[u][v]=b
snuke_cost[v][u]=b
# Dijktra's shortest path algorithm. Prints the path from source to target.
def dijkstra(adj, source):
INF = MAX_VAL
dist = [INF for x in range(n)]
dist[source] = 0
PQ = []
heapq.heappush(PQ, [dist[source], source])
while (PQ):
u_dist,u_id = heapq.heappop(PQ) # u is a tuple [u_dist, u_id]
if u_dist == dist[u_id]:
for v in adj[u_id]:
w_uv = adj[u_id][v]
if dist[u_id] + w_uv < dist[v]:
dist[v] = dist[u_id] + w_uv
heapq.heappush(PQ, [dist[v], v])
return dist
jpy_dijk = dijkstra(jpy_cost,s-1)
snuke_dijk = dijkstra(snuke_cost,t-1)
#
# print(s,t)
# print(jpy_dijk)
# print(snuke_dijk)
# print([jpy_dijk[i]+snuke_dijk[i] for i in range(n)])
#ord n
res = []
min_val = MAX_VAL
for i in reversed(list(range(n))):
#都市 i で両替
val = jpy_dijk[i]+ snuke_dijk[i]
assert val < MAX_VAL
min_val=min(min_val,val)
res.append(min_val)
#ord n
for x in reversed(res):
print((10**15- x))
| p03305 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
import heapq
class PriorityQueue:
class Reverse:
def __init__(self, val):
self.val = val
def __lt__(self, other):
return self.val > other.val
def __repr__(self):
return repr(self.val)
def __init__(self, x=None, desc=False):
if not x:
x = []
if desc:
for i in range(len(x)):
x[i] = self.Reverse(x[i])
self._desc = desc
self._container = x
heapq.heapify(self._container)
@property
def is_empty(self):
return not self._container
def pop(self):
if self._desc:
return heapq.heappop(self._container).val
else:
return heapq.heappop(self._container)
def push(self, item):
if self._desc:
heapq.heappush(self._container, self.Reverse(item))
else:
heapq.heappush(self._container, item)
def top(self):
if self._desc:
return self._container[0].val
else:
return self._container[0]
def sum(self):
return sum(self._container)
def __len__(self):
return len(self._container)
def main():
from collections import defaultdict
n, m, s, t = list(map(int, readline().split()))
edge = defaultdict(list)
for _ in range(m):
u, v, a, b = list(map(int, readline().split()))
edge[u].append((v, a, b))
edge[v].append((u, a, b))
dist_s = defaultdict(lambda: float("INF"))
dist_t = defaultdict(lambda: float("INF"))
dist_s[s] = 0
dist_t[t] = 0
pq = PriorityQueue()
pq.push((s, 0))
while pq:
cur, cost = pq.pop()
for nx, a, _ in edge[cur]:
nc = cost + a
if nc < dist_s[nx]:
dist_s[nx] = nc
pq.push((nx, nc))
pq.push((t, 0))
while pq:
cur, cost = pq.pop()
for nx, _, b in edge[cur]:
nc = cost + b
if nc < dist_t[nx]:
dist_t[nx] = nc
pq.push((nx, nc))
res = [0] * (n + 1)
for i in range(n - 1, -1, -1):
res[i] = max(res[i + 1], 10 ** 15 - (dist_s[i+1] + dist_t[i+1]))
for i in range(n):
print((res[i]))
if __name__ == '__main__':
main()
| import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
sys.setrecursionlimit(10 ** 5)
def main():
import heapq
from collections import defaultdict
INF = float('INF')
n, m, s, t = list(map(int, readline().split()))
edge = defaultdict(list)
for _ in range(m):
u, v, a, b = list(map(int, readline().split()))
edge[u].append((v, a, b))
edge[v].append((u, a, b))
dist_s = defaultdict(lambda: float("INF"))
dist_t = defaultdict(lambda: float("INF"))
dist_s[s] = 0
dist_t[t] = 0
hq = []
heapq.heappush(hq, (0, s))
while hq:
cost, cur = heapq.heappop(hq)
for nx, a, _ in edge[cur]:
nc = cost + a
if nc < dist_s[nx]:
dist_s[nx] = nc
heapq.heappush(hq, (nc, nx))
heapq.heappush(hq, (0, t))
while hq:
cost, cur = heapq.heappop(hq)
for nx, _, b in edge[cur]:
nc = cost + b
if nc < dist_t[nx]:
dist_t[nx] = nc
heapq.heappush(hq, (nc, nx))
res = [0] * (n + 1)
for i in range(n - 1, -1, -1):
res[i] = max(res[i + 1], 10 ** 15 - (dist_s[i + 1] + dist_t[i + 1]))
for i in range(n):
print((res[i]))
if __name__ == '__main__':
main()
| p03305 |
import heapq
class Dijkstra(object):
def dijkstra(self, adj, start, goal=None):
'''
ダイクストラアルゴリズムによる最短経路を求めるメソッド
入力
adj: adj[i][j]の値が頂点iから頂点jまでの距離(頂点iから頂点jに枝がない場合，値はfloat('inf'))となるような2次元リスト(正方行列)
start: 始点のID
goal: オプション引数．終点のID
出力
goalを引数に持つ場合，startからgoalまでの最短経路を格納したリストを返す
持たない場合は，startから各頂点までの最短距離を格納したリストを返す
>>> d = Dijkstra()
>>> d.dijkstra([[float('inf'), 2, 4, float('inf'), float('inf')], [2, float('inf'), 3, 5, float('inf')], [4, 3, float('inf'), 1, 4], [float('inf'), 5, 1, float('inf'), 3], [float('inf'), float('inf'), 4, 3, float('inf')]], 0)
[0, 2, 4, 5, 8] # 例えば，始点0から頂点3までの最短距離は5となる
>>> d.dijkstra([[float('inf'), 2, 4, float('inf'), float('inf')], [2, float('inf'), 3, 5, float('inf')], [4, 3, float('inf'), 1, 4], [float('inf'), 5, 1, float('inf'), 3], [float('inf'), float('inf'), 4, 3, float('inf')]], 0, goal=4)
[0, 2, 4] # 頂点0から頂点4までの最短経路は0 -> 2 -> 4となる
'''
num = len(adj) # グラフのノード数
dist = [float('inf') for i in range(num)] # 始点から各頂点までの最短距離を格納する
prev = [float('inf') for i in range(num)] # 最短経路における，その頂点の前の頂点のIDを格納する
dist[start] = 0
q = [] # プライオリティキュー．各要素は，(startからある頂点vまでの仮の距離, 頂点vのID)からなるタプル
heapq.heappush(q, (0, start)) # 始点をpush
while len(q) != 0:
prov_cost, src = heapq.heappop(q) # pop
# プライオリティキューに格納されている最短距離が，現在計算できている最短距離より大きければ，distの更新をする必要はない
if dist[src] < prov_cost:
continue
# 他の頂点の探索
for dest in range(num):
cost = adj[src][dest]
if cost != float('inf') and dist[dest] > dist[src] + cost:
dist[dest] = dist[src] + cost # distの更新
heapq.heappush(q, (dist[dest], dest)) # キューに新たな仮の距離の情報をpush
prev[dest] = src # 前の頂点を記録
if goal is not None:
return self.get_path(goal, prev)
else:
return dist
def get_path(self, goal, prev):
'''
始点startから終点goalまでの最短経路を求める
'''
path = [goal] # 最短経路
dest = goal
# 終点から最短経路を逆順に辿る
while prev[dest] != float('inf'):
path.append(prev[dest])
dest = prev[dest]
# 経路をreverseして出力
return list(reversed(path))
n, m, s, t = list(map(int, input().split()))
s, t = s-1, t-1
route_yen = [[10**15 for i in range(n)] for j in range(n)]
route_snook = [[10**15 for i in range(n)] for j in range(n)]
for i in range(m):
ui, vi, ai, bi = list(map(int, input().split()))
ui, vi = vi-1, ui-1
route_yen[ui][vi], route_yen[vi][ui] = ai, ai
route_snook[ui][vi], route_snook[vi][ui] = bi, bi
yen = Dijkstra()
distance_yen = yen.dijkstra(route_yen, s)
snook = Dijkstra()
distance_snook = snook.dijkstra(route_snook, t)
ans_lst = [0 for i in range(n)]
temp_min = 10**15
for i in range(n)[::-1]:
now = distance_yen[i] + distance_snook[i]
temp_min = min(temp_min, now)
ans_lst[i] = 10**15 - temp_min
for i in range(n):
print((ans_lst[i])) | '''
1つの始点から全頂点への最短距離を求めるアルゴリズム
辺の数E,頂点の数Vに対し、O((E+V)log(V))
edge[u]=[(d1, v1), (d2, v2), ...]が頂点uと頂点viに距離diの辺があることを表す隣接リストが入力
無向グラフにて検証済み。有効グラフのたぶんいけるので確認したらここを書き換えて欲しい。
'''
from heapq import heappush, heappop
INF = 10**15
def dijkstra(s, edges):
que = []
d = [INF] * n
d[s] = 0
heappush(que, (0, s))
while len(que) > 0:
(c, v) = heappop(que)
if d[v] < c:
continue
for (cc, w) in edges[v]:
if d[w] > d[v] + cc:
d[w] = d[v] + cc
heappush(que, (d[w], w))
return d
n, m, s, t = list(map(int, input().split()))
s, t = s-1, t-1
yen_edge = [[] for i in range(n)]
snook_edge = [[] for i in range(n)]
for i in range(m):
ui, vi, ai, bi = list(map(int, input().split()))
ui, vi = vi-1, ui-1
yen_edge[ui].append((ai, vi))
yen_edge[vi].append((ai, ui))
snook_edge[ui].append((bi, vi))
snook_edge[vi].append((bi, ui))
distance_yen = dijkstra(s, yen_edge)
distance_snook = dijkstra(t, snook_edge)
ans_lst = [0 for i in range(n)]
temp_min = 10**15
for i in range(n)[::-1]:
now = distance_yen[i] + distance_snook[i]
temp_min = min(temp_min, now)
ans_lst[i] = 10**15 - temp_min
for i in range(n):
print((ans_lst[i])) | p03305 |
'''
1つの始点から全頂点への最短距離を求めるアルゴリズム
辺の数E,頂点の数Vに対し、O((E+V)log(V))
edge[u]=[(d1, v1), (d2, v2), ...]が頂点uと頂点viに距離diの辺があることを表す隣接リストが入力
無向グラフにて検証済み。有効グラフのたぶんいけるので確認したらここを書き換えて欲しい。
'''
from heapq import heappush, heappop
INF = 10**15
def dijkstra(s, edges):
que = []
d = [INF] * n
d[s] = 0
heappush(que, (0, s))
while len(que) > 0:
(c, v) = heappop(que)
if d[v] < c:
continue
for (cc, w) in edges[v]:
if d[w] > d[v] + cc:
d[w] = d[v] + cc
heappush(que, (d[w], w))
return d
n, m, s, t = list(map(int, input().split()))
s, t = s-1, t-1
yen_edge = [[] for i in range(n)]
snook_edge = [[] for i in range(n)]
for i in range(m):
ui, vi, ai, bi = list(map(int, input().split()))
ui, vi = vi-1, ui-1
yen_edge[ui].append((ai, vi))
yen_edge[vi].append((ai, ui))
snook_edge[ui].append((bi, vi))
snook_edge[vi].append((bi, ui))
distance_yen = dijkstra(s, yen_edge)
distance_snook = dijkstra(t, snook_edge)
ans_lst = [0 for i in range(n)]
temp_min = 10**15
for i in range(n)[::-1]:
now = distance_yen[i] + distance_snook[i]
temp_min = min(temp_min, now)
ans_lst[i] = 10**15 - temp_min
for i in range(n):
print((ans_lst[i])) | '''
1つの始点から全頂点への最短距離を求めるアルゴリズム
辺の数E,頂点の数Vに対し、O((E+V)log(V))
edge[u]=[(d1, v1), (d2, v2), ...]が頂点uと頂点viに距離diの辺があることを表す隣接リストが入力
無向グラフにて検証済み。有効グラフのたぶんいけるので確認したらここを書き換えて欲しい。
'''
from heapq import heappush, heappop
INF = 10**15
def dijkstra(s, edges):
n = len(edges)
que = []
d = [INF] * n
d[s] = 0
heappush(que, (0, s))
while len(que) > 0:
(c, v) = heappop(que)
if d[v] < c:
continue
for (cc, w) in edges[v]:
if d[w] > d[v] + cc:
d[w] = d[v] + cc
heappush(que, (d[w], w))
return d
n, m, s, t = list(map(int, input().split()))
s, t = s-1, t-1
yen_edge = [[] for i in range(n)]
snook_edge = [[] for i in range(n)]
for i in range(m):
ui, vi, ai, bi = list(map(int, input().split()))
ui, vi = vi-1, ui-1
yen_edge[ui].append((ai, vi))
yen_edge[vi].append((ai, ui))
snook_edge[ui].append((bi, vi))
snook_edge[vi].append((bi, ui))
distance_yen = dijkstra(s, yen_edge)
distance_snook = dijkstra(t, snook_edge)
ans_lst = [0 for i in range(n)]
temp_min = 10**15
for i in range(n)[::-1]:
now = distance_yen[i] + distance_snook[i]
temp_min = min(temp_min, now)
ans_lst[i] = 10**15 - temp_min
for i in range(n):
print((ans_lst[i])) | p03305 |
import heapq
from itertools import accumulate
inf = float('inf')
def dijkstra(ad_lst, n, s):
costs = [inf for i in range(n+1)]
costs[s], Q = 0, []
heapq.heappush(Q, [costs[s], s])
while(Q != []):
c, u = heapq.heappop(Q)
for v, c in ad_lst[u]:
if costs[u] + c < costs[v]:
heapq.heappush(Q, [costs[u] + c, v])
costs[v] = costs[u] + c
return costs
n,m,s,t, = map(int, input().split())
route_y = {i: [] for i in range(n+1)}
route_s = {i: [] for i in range(n+1)}
for i in range(m):
u, v, a, b = map(int, input().split())
route_y[u].append([v,a])
route_y[v].append([u,a])
route_s[u].append([v,b])
route_s[v].append([u,b])
cost_y = dijkstra(route_y, n, s)
cost_s = dijkstra(route_s, n, t)
result = list(accumulate([y+s for y,s in zip(cost_y, cost_s)][::-1], min))
yen = 10**15
[print(yen-result[i]) for i in range(n-1, -1, -1)]
| import heapq
from itertools import accumulate
inf = float('inf')
def dijkstra(ad_lst, n, s):
costs = [inf for i in range(n+1)]
costs[s], Q = 0, []
heapq.heappush(Q, [costs[s], s])
while(Q != []):
c, u = heapq.heappop(Q)
for v, c in ad_lst[u].items():
if costs[u] + c < costs[v]:
heapq.heappush(Q, [costs[u] + c, v])
costs[v] = costs[u] + c
return costs
n,m,s,t, = map(int, input().split())
route_y = {i: {} for i in range(n+1)}
route_s = {i: {} for i in range(n+1)}
for i in range(m):
u, v, a, b = map(int, input().split())
route_y[u][v] = a
route_y[v][u] = a
route_s[u][v] = b
route_s[v][u] = b
cost_y = dijkstra(route_y, n, s)
cost_s = dijkstra(route_s, n, t)
result = list(accumulate([y+s for y,s in zip(cost_y, cost_s)][::-1], min))
yen = 10**15
[print(yen-result[i]) for i in range(n-1, -1, -1)]
| p03305 |
import sys
input = sys.stdin.readline
n, m, s, t = list(map(int,input().split()))
C = [list(map(int,input().split())) for i in range(m)]
s -= 1
t -= 1
# O((V + E)log(V))
# Cは [[スタート頂点, ゴール頂点, 重み], ...] のリスト
for i in range(m):
for j in range(2):
C[i][j] -= 1
M = [[] for i in range(n)]
for i in range(len(C)):
M[C[i][0]].append([C[i][1], C[i][2]]) # 無向グラフなら両方追加
M[C[i][1]].append([C[i][0], C[i][2]]) # 無向グラフなら両方追加
N = [[] for i in range(n)]
for i in range(len(C)):
N[C[i][0]].append([C[i][1], C[i][3]]) # 無向グラフなら両方追加
N[C[i][1]].append([C[i][0], C[i][3]]) # 無向グラフなら両方追加
import heapq
def dijkstra(s, M):
D = [float("inf")] * n # 頂点0からの距離
P = [-1] * n # 頂点0からの最短距離において、そこの直前の頂点(経路復元に利用)
D[s] = 0
V = [0] * n # その頂点のD[i]が最短距離と確定したら1
Q = [] # 優先度付きキュー
for v in range(n):
heapq.heappush(Q, [D[v], v])
le = len(Q)
while le > 0:
q = heapq.heappop(Q)
u = q[1]
du = q[0]
if V[u] == 0:
V[u] = 1
le -= 1
for i in range(len(M[u])):
v = M[u][i][0]
luv = M[u][i][1]
if V[v] == 0:
alt = du + luv
if D[v] > alt:
D[v] = alt
P[v] = u
heapq.heappush(Q, [alt, v])
return D, P
Ds, _ = dijkstra(s, M)
Dt, _ = dijkstra(t, N)
ANS = [0] * n
# print(Ds,Dt)
ans = float("inf")
for i in range(n-1, -1, -1):
ans = min(ans, Ds[i] + Dt[i])
ANS[i] = ans
for i in range(n):
print((10**15 - ANS[i])) | import sys
input = sys.stdin.readline
n, m, s, t = list(map(int,input().split()))
C = [list(map(int,input().split())) for i in range(m)]
s -= 1
t -= 1
# O((V + E)log(V))
# Cは [[スタート頂点, ゴール頂点, 重み], ...] のリスト
M = [[] for i in range(n)]
for i in range(len(C)):
M[C[i][0]-1].append([C[i][1]-1, C[i][2]]) # 無向グラフなら両方追加
M[C[i][1]-1].append([C[i][0]-1, C[i][2]]) # 無向グラフなら両方追加
N = [[] for i in range(n)]
for i in range(len(C)):
N[C[i][0]-1].append([C[i][1]-1, C[i][3]]) # 無向グラフなら両方追加
N[C[i][1]-1].append([C[i][0]-1, C[i][3]]) # 無向グラフなら両方追加
import heapq
def dijkstra(s, M):
D = [10**16] * n # 頂点0からの距離
P = [-1] * n # 頂点0からの最短距離において、そこの直前の頂点(経路復元に利用)
D[s] = 0
V = [0] * n # その頂点のD[i]が最短距離と確定したら1
Q = [] # 優先度付きキュー
for v in range(n):
heapq.heappush(Q, [D[v], v])
le = len(Q)
while le > 0:
q = heapq.heappop(Q)
u = q[1]
du = q[0]
if V[u] == 0:
V[u] = 1
le -= 1
for i in range(len(M[u])):
v = M[u][i][0]
luv = M[u][i][1]
if V[v] == 0:
alt = du + luv
if D[v] > alt:
D[v] = alt
P[v] = u
heapq.heappush(Q, [alt, v])
return D, P
Ds, _ = dijkstra(s, M)
Dt, _ = dijkstra(t, N)
ANS = [0] * n
# print(Ds,Dt)
ans = 10**16
for i in range(n-1, -1, -1):
ans = min(ans, Ds[i] + Dt[i])
ANS[i] = ans
for i in range(n):
print((10**15 - ANS[i])) | p03305 |
import sys
input = sys.stdin.readline
n, m, s, t = list(map(int,input().split()))
C = [list(map(int,input().split())) for i in range(m)]
s -= 1
t -= 1
# O((V + E)log(V))
# Cは [[スタート頂点, ゴール頂点, 重み], ...] のリスト
# for i in range(m):
# for j in range(2):
# C[i][j] -= 1
M = [[] for i in range(n)]
for i in range(len(C)):
M[C[i][0]-1].append([C[i][1]-1, C[i][2]]) # 無向グラフなら両方追加
M[C[i][1]-1].append([C[i][0]-1, C[i][2]]) # 無向グラフなら両方追加
N = [[] for i in range(n)]
for i in range(len(C)):
N[C[i][0]-1].append([C[i][1]-1, C[i][3]]) # 無向グラフなら両方追加
N[C[i][1]-1].append([C[i][0]-1, C[i][3]]) # 無向グラフなら両方追加
import heapq
def dijkstra(s, M):
D = [float("inf")] * n # 頂点0からの距離
P = [-1] * n # 頂点0からの最短距離において、そこの直前の頂点(経路復元に利用)
D[s] = 0
V = [0] * n # その頂点のD[i]が最短距離と確定したら1
Q = [] # 優先度付きキュー
for v in range(n):
heapq.heappush(Q, [D[v], v])
le = len(Q)
while le > 0:
q = heapq.heappop(Q)
u = q[1]
du = q[0]
if V[u] == 0:
V[u] = 1
le -= 1
for i in range(len(M[u])):
v = M[u][i][0]
luv = M[u][i][1]
if V[v] == 0:
alt = du + luv
if D[v] > alt:
D[v] = alt
P[v] = u
heapq.heappush(Q, [alt, v])
return D, P
Ds, _ = dijkstra(s, M)
Dt, _ = dijkstra(t, N)
ANS = [0] * n
# print(Ds,Dt)
ans = float("inf")
for i in range(n-1, -1, -1):
ans = min(ans, Ds[i] + Dt[i])
ANS[i] = ans
for i in range(n):
print((10**15 - ANS[i])) | import sys
input = sys.stdin.readline
n, m, s, t = list(map(int,input().split()))
C = [list(map(int,input().split())) for i in range(m)]
s -= 1
t -= 1
# O((V + E)log(V))
# Cは [[スタート頂点, ゴール頂点, 重み], ...] のリスト
# for i in range(m):
# for j in range(2):
# C[i][j] -= 1
M = [[] for i in range(n)]
for i in range(len(C)):
M[C[i][0]-1].append([C[i][1]-1, C[i][2]]) # 無向グラフなら両方追加
M[C[i][1]-1].append([C[i][0]-1, C[i][2]]) # 無向グラフなら両方追加
N = [[] for i in range(n)]
for i in range(len(C)):
N[C[i][0]-1].append([C[i][1]-1, C[i][3]]) # 無向グラフなら両方追加
N[C[i][1]-1].append([C[i][0]-1, C[i][3]]) # 無向グラフなら両方追加
import heapq
def dijkstra(s, M):
D = [10**16] * n # 頂点0からの距離
P = [-1] * n # 頂点0からの最短距離において、そこの直前の頂点(経路復元に利用)
D[s] = 0
V = [0] * n # その頂点のD[i]が最短距離と確定したら1
Q = [] # 優先度付きキュー
for v in range(n):
heapq.heappush(Q, [D[v], v])
le = len(Q)
while le > 0:
q = heapq.heappop(Q)
u = q[1]
du = q[0]
if V[u] == 0:
V[u] = 1
le -= 1
for i in range(len(M[u])):
v = M[u][i][0]
luv = M[u][i][1]
if V[v] == 0:
alt = du + luv
if D[v] > alt:
D[v] = alt
P[v] = u
heapq.heappush(Q, [alt, v])
return D, P
Ds, _ = dijkstra(s, M)
Dt, _ = dijkstra(t, N)
ANS = [0] * n
# print(Ds,Dt)
ans = 10**16
for i in range(n-1, -1, -1):
ans = min(ans, Ds[i] + Dt[i])
ANS[i] = ans
for i in range(n):
print((10**15 - ANS[i])) | p03305 |
import sys
input = sys.stdin.readline
n, m, s, t = list(map(int,input().split()))
C = [list(map(int,input().split())) for i in range(m)]
s -= 1
t -= 1
# O((V + E)log(V))
# Cは [[スタート頂点, ゴール頂点, 重み], ...] のリスト
M = [[] for i in range(n)]
for i in range(len(C)):
M[C[i][0]-1].append([C[i][1]-1, C[i][2]]) # 無向グラフなら両方追加
M[C[i][1]-1].append([C[i][0]-1, C[i][2]]) # 無向グラフなら両方追加
N = [[] for i in range(n)]
for i in range(len(C)):
N[C[i][0]-1].append([C[i][1]-1, C[i][3]]) # 無向グラフなら両方追加
N[C[i][1]-1].append([C[i][0]-1, C[i][3]]) # 無向グラフなら両方追加
import heapq
def dijkstra(s, M):
D = [10**16] * n # 頂点0からの距離
P = [-1] * n # 頂点0からの最短距離において、そこの直前の頂点(経路復元に利用)
D[s] = 0
V = [0] * n # その頂点のD[i]が最短距離と確定したら1
Q = [] # 優先度付きキュー
for v in range(n):
heapq.heappush(Q, [D[v], v])
le = len(Q)
while le > 0:
q = heapq.heappop(Q)
u = q[1]
du = q[0]
if V[u] == 0:
V[u] = 1
le -= 1
for i in range(len(M[u])):
v = M[u][i][0]
luv = M[u][i][1]
if V[v] == 0:
alt = du + luv
if D[v] > alt:
D[v] = alt
P[v] = u
heapq.heappush(Q, [alt, v])
return D, P
Ds, _ = dijkstra(s, M)
Dt, _ = dijkstra(t, N)
ANS = [0] * n
# print(Ds,Dt)
ans = 10**16
for i in range(n-1, -1, -1):
ans = min(ans, Ds[i] + Dt[i])
ANS[i] = ans
for i in range(n):
print((10**15 - ANS[i])) | # 「C[i][0]から1を引くのを別のループでやらない」「大きい値にはinfでなく10**16を使う」
# この2つはTLEしないために必須。それでも数回に1回、TLEすることがある
import sys
input = sys.stdin.readline
n, m, s, t = list(map(int,input().split()))
C = [list(map(int,input().split())) for i in range(m)]
s -= 1
t -= 1
# O((V + E)log(V))
# Cは [[スタート頂点, ゴール頂点, 重み], ...] のリスト
# M = [[] for i in range(n)]
# for i in range(len(C)):
# M[C[i][0]-1].append([C[i][1]-1, C[i][2]]) # 無向グラフなら両方追加
# M[C[i][1]-1].append([C[i][0]-1, C[i][2]]) # 無向グラフなら両方追加
# N = [[] for i in range(n)]
# for i in range(len(C)):
# N[C[i][0]-1].append([C[i][1]-1, C[i][3]]) # 無向グラフなら両方追加
# N[C[i][1]-1].append([C[i][0]-1, C[i][3]]) # 無向グラフなら両方追加
M = [[] for i in range(n)]
for i in range(len(C)):
M[C[i][0]-1].append([C[i][1]-1, C[i][2], C[i][3]]) # 無向グラフなら両方追加
M[C[i][1]-1].append([C[i][0]-1, C[i][2], C[i][3]]) # 無向グラフなら両方追加
import heapq
# def dijkstra(s, M):
# D = [10**16] * n # 頂点0からの距離
# P = [-1] * n # 頂点0からの最短距離において、そこの直前の頂点(経路復元に利用)
# D[s] = 0
# V = [0] * n # その頂点のD[i]が最短距離と確定したら1
# Q = [] # 優先度付きキュー
# for v in range(n):
# heapq.heappush(Q, [D[v], v])
# le = len(Q)
# while le > 0:
# q = heapq.heappop(Q)
# u = q[1]
# du = q[0]
# if V[u] == 0:
# V[u] = 1
# le -= 1
# for i in range(len(M[u])):
# v = M[u][i][0]
# luv = M[u][i][1]
# if V[v] == 0:
# alt = du + luv
# if D[v] > alt:
# D[v] = alt
# P[v] = u
# heapq.heappush(Q, [alt, v])
# return D, P
def dijkstra(a,in_connect_list,v,money_kind):
out_shortest_list = [10**15 for i in range(v)]
out_shortest_list[a] = 0
searching_list = [a]
while searching_list != []:
new_search_list = []
for i in searching_list:
for j in in_connect_list[i]:
c = j[0]
p = j[money_kind]
if out_shortest_list[c] > p + out_shortest_list[i]:
out_shortest_list[c] = p + out_shortest_list[i]
new_search_list.append(j[0])
searching_list = new_search_list
return out_shortest_list
# Ds, _ = dijkstra(s, M)
# Dt, _ = dijkstra(t, N)
Ds = dijkstra(s, M, n, 1)
Dt = dijkstra(t, M, n, 2)
ANS = [0] * n
# print(Ds,Dt)
ans = 10**16
for i in range(n-1, -1, -1):
ans = min(ans, Ds[i] + Dt[i])
ANS[i] = ans
for i in range(n):
print((10**15 - ANS[i])) | p03305 |
from collections import defaultdict
import sys
import heapq
sys.setrecursionlimit(10**8)
#N:頂点数 M:辺数
N,M,s,t = list(map(int,input().split()))
#root[n] -> nからいけるlist
root_yen = defaultdict(set)
root_snu = defaultdict(set)
#cost[a][b] = a -> b のコスト
cost_yen = [[0 for i in range(N+1)] for j in range(N+1)]
cost_snu = [[0 for i in range(N+1)] for j in range(N+1)]
#weight[a] = start -> a のコスト 未探索->-1
weight_yen = [-1 for i in range(N+1)]
weight_snu = [-1 for i in range(N+1)]
weight_yen[s] = 0
weight_snu[t] = 0
#q = 次に探索する(確定する)もの q[0]=[w,n]
q_yen = [[0,s]]
q_snu = [[0,t]]
heapq.heapify(q_yen)
heapq.heapify(q_snu)
for i in range(M):
u,v,a,b = list(map(int,input().split())) #
root_yen[u].add(v)
root_yen[v].add(u)
root_snu[u].add(v)
root_snu[v].add(u)
cost_yen[u][v] = a
cost_yen[v][u] = a
cost_snu[u][v] = b
cost_snu[v][u] = b
def search_yen (n,w_0): #nから更新 w_0:確定コスト
global cost_yen
global weight_yen
global q_yen
for i in list(root_yen[n]):
w = w_0 + cost_yen[n][i]
if weight_yen[i] == -1 or weight_yen[i] > w: #未探索orより小さい
heapq.heappush(q_yen, [w,i])
weight_yen[i] = w
def search_snu (n,w_0): #nから更新 w_0:確定コスト
global cost_snu
global weight_snu
global q_snu
for i in list(root_snu[n]):
w = w_0 + cost_snu[n][i]
if weight_snu[i] == -1 or weight_snu[i] > w: #未探索orより小さい
heapq.heappush(q_snu, [w,i])
weight_snu[i] = w
while q_yen:
w,n = heapq.heappop(q_yen)
search_yen(n,w)
while q_snu:
w,n = heapq.heappop(q_snu)
search_snu(n,w)
finalans = float('inf')
ans_li = []
for i in range(0,N):
ans = weight_yen[N-i] + weight_snu[N-i]
finalans = min(finalans, ans)
ans_li.append(finalans)
for i in range(N):
print((10**15 - ans_li[N-i-1])) | from collections import defaultdict
import sys
import heapq
sys.setrecursionlimit(10**8)
#N:頂点数 M:辺数
N,M,s,t = list(map(int,input().split()))
#root[n] -> nからいけるlist
roots = defaultdict(set)
#weight[a] = start -> a のコスト 未探索->-1
weight_yen = [-1 for i in range(N+1)]
weight_snu = [-1 for i in range(N+1)]
weight_yen[s] = 0
weight_snu[t] = 0
for i in range(M):
u,v,a,b = list(map(int,input().split())) #
roots[u].add((v,a,b))
roots[v].add((u,a,b))
def search_yen (n,w_0): #nから更新 w_0:確定コスト
global weight_yen
for root in list(roots[n]):
i = root[0]
w = w_0 + root[1]
if weight_yen[i] == -1 or weight_yen[i] > w: #未探索orより小さい
heapq.heappush(q, [w,i])
weight_yen[i] = w
def search_snu (n,w_0): #nから更新 w_0:確定コスト
global weight_snu
for root in list(roots[n]):
i = root[0]
w = w_0 + root[2]
if weight_snu[i] == -1 or weight_snu[i] > w: #未探索orより小さい
heapq.heappush(q, [w,i])
weight_snu[i] = w
#q = 次に探索する(確定する)もの q[0]=[w,n]
q = [[0,s]]
heapq.heapify(q)
while q:
w,n = heapq.heappop(q)
search_yen(n,w)
heapq.heappush(q, [0,t])
while q:
w,n = heapq.heappop(q)
search_snu(n,w)
finalans = float('inf')
ans_li = []
for i in range(0,N):
ans = weight_yen[N-i] + weight_snu[N-i]
finalans = min(finalans, ans)
ans_li.append(finalans)
for i in range(N):
print((10**15 - ans_li[N-i-1])) | p03305 |
from collections import defaultdict
import sys
import heapq
sys.setrecursionlimit(10**8)
#N:頂点数 M:辺数
N,M,s,t = list(map(int,input().split()))
#root[n] -> nからいけるlist
root_yen = defaultdict(set)
root_snu = defaultdict(set)
#cost[a][b] = a -> b のコスト
cost_yen = [[0 for i in range(N+1)] for j in range(N+1)]
cost_snu = [[0 for i in range(N+1)] for j in range(N+1)]
#weight[a] = start -> a のコスト 未探索->-1
weight_yen = [-1 for i in range(N+1)]
weight_snu = [-1 for i in range(N+1)]
weight_yen[s] = 0
weight_snu[t] = 0
#q = 次に探索する(確定する)もの q[0]=[w,n]
q_yen = [[0,s]]
q_snu = [[0,t]]
heapq.heapify(q_yen)
heapq.heapify(q_snu)
for i in range(M):
u,v,a,b = list(map(int,input().split())) #
root_yen[u].add(v)
root_yen[v].add(u)
root_snu[u].add(v)
root_snu[v].add(u)
cost_yen[u][v] = a
cost_yen[v][u] = a
cost_snu[u][v] = b
cost_snu[v][u] = b
def search_yen (n,w_0): #nから更新 w_0:確定コスト
global cost_yen
global weight_yen
global q_yen
for i in list(root_yen[n]):
w = w_0 + cost_yen[n][i]
if weight_yen[i] == -1 or weight_yen[i] > w: #未探索orより小さい
heapq.heappush(q_yen, [w,i])
weight_yen[i] = w
def search_snu (n,w_0): #nから更新 w_0:確定コスト
global cost_snu
global weight_snu
global q_snu
for i in list(root_snu[n]):
w = w_0 + cost_snu[n][i]
if weight_snu[i] == -1 or weight_snu[i] > w: #未探索orより小さい
heapq.heappush(q_snu, [w,i])
weight_snu[i] = w
while q_yen:
w,n = heapq.heappop(q_yen)
search_yen(n,w)
while q_snu:
w,n = heapq.heappop(q_snu)
search_snu(n,w)
finalans = float('inf')
ans_li = []
for i in range(0,N):
ans = weight_yen[N-i] + weight_snu[N-i]
finalans = min(finalans, ans)
ans_li.append(finalans)
for i in range(N):
print((10**15 - ans_li[N-i-1]))
| from collections import defaultdict
import sys
import heapq
sys.setrecursionlimit(10**8)
#N:頂点数 M:辺数
N,M,s,t = list(map(int,input().split()))
#root[n] -> nからいけるlist
roots = defaultdict(set)
#weight[a] = start -> a のコスト 未探索->-1
weight_yen = [-1 for i in range(N+1)]
weight_snu = [-1 for i in range(N+1)]
weight_yen[s] = 0
weight_snu[t] = 0
for i in range(M):
u,v,a,b = list(map(int,input().split())) #
roots[u].add((v,a,b))
roots[v].add((u,a,b))
def search_yen (n,w_0): #nから更新 w_0:確定コスト
global weight_yen
for root in list(roots[n]):
i = root[0]
w = w_0 + root[1]
if weight_yen[i] == -1 or weight_yen[i] > w: #未探索orより小さい
heapq.heappush(q, [w,i])
weight_yen[i] = w
def search_snu (n,w_0): #nから更新 w_0:確定コスト
global weight_snu
for root in list(roots[n]):
i = root[0]
w = w_0 + root[2]
if weight_snu[i] == -1 or weight_snu[i] > w: #未探索orより小さい
heapq.heappush(q, [w,i])
weight_snu[i] = w
#q = 次に探索する(確定する)もの q[0]=[w,n]
q = [[0,s]]
heapq.heapify(q)
while q:
w,n = heapq.heappop(q)
search_yen(n,w)
heapq.heappush(q, [0,t])
while q:
w,n = heapq.heappop(q)
search_snu(n,w)
finalans = float('inf')
ans_li = []
for i in range(0,N):
ans = weight_yen[N-i] + weight_snu[N-i]
finalans = min(finalans, ans)
ans_li.append(finalans)
for i in range(N):
print((10**15 - ans_li[N-i-1]))
| p03305 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(n, m, s, t, UVAB):
g = defaultdict(dict)
for u, v, a, b in UVAB:
g[u][v] = (a, b)
g[v][u] = (a, b)
def d(s, ck):
dist = [0 if s == i else sys.maxsize for i in range(n+1)]
# p = [None for i in range(n+1)]
q =[]
heapq.heappush(q, (dist[s], s))
while q:
c, u = heapq.heappop(q)
if dist[u] > c:
continue
for v, cost in g[u].items():
alt = dist[u] + cost[ck]
if dist[v] > alt:
dist[v] = alt
# p[v] = u
heapq.heappush(q, (alt, v))
return dist
dist0 = d(s, 0)
dist1 = d(t, 1)
def find(i):
c = 10**15
costs = []
for j in range(i+1, n+1):
costs.append(dist1[j] + dist0[j])
return c - min(costs)
ans = []
for i in range(n):
ans.append(find(i))
return '\n'.join(map(str, ans))
def main():
n, m, s, t = read_int_n()
UVAB = [read_int_n() for _ in range(m)]
print(slv(n, m, s, t, UVAB))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(n, m, s, t, UVAB):
g = defaultdict(list)
for u, v, a, b in UVAB:
g[u].append((v, (a, b)))
g[v].append((u, (a, b)))
def d(s, ck):
dist = [0 if s == i else sys.maxsize for i in range(n+1)]
# p = [None for i in range(n+1)]
q =[]
heapq.heappush(q, (dist[s], s))
while q:
c, u = heapq.heappop(q)
if dist[u] > c:
continue
for v, cost in g[u]:
alt = dist[u] + cost[ck]
if dist[v] > alt:
dist[v] = alt
heapq.heappush(q, (alt, v))
return dist
dist0 = d(s, 0)
dist1 = d(t, 1)
ans = [sys.maxsize] * (n+1)
for i in range(n-1, -1, -1):
# print(i)
ans[i] = min(ans[i+1], dist1[i+1] + dist0[i+1])
c = 10**15
return '\n'.join(map(lambda x: str(c-x), ans[:-1]))
def main():
n, m, s, t = read_int_n()
UVAB = [read_int_n() for _ in range(m)]
print(slv(n, m, s, t, UVAB))
if __name__ == '__main__':
main()
| p03305 |
from heapq import heappush, heappop
n,m,s,t = list(map(int,input().split()))
e = [[] for i in range(n+1)]
for i in range(m):
u,v,a,b = list(map(int,input().split()))
e[u].append((v,a,b))
e[v].append((u,a,b))
S = [float("INF")]*(n+1)
S[s] = 0
h = []
heappush(h,[s,0])
while h:
now,d = heappop(h)
for nex,a,b in e[now]:
if d+a < S[nex]:
S[nex] = d+a
heappush(h,[nex,d+a])
T = [float("INF")]*(n+1)
T[t] = 0
h = []
heappush(h,[t,0])
while h:
now,d = heappop(h)
for nex,a,b in e[now]:
if d+b < T[nex]:
T[nex] = d+b
heappush(h,[nex,d+b])
ans = [0]*(n+1)
cost = 10**15
now = 0
for i in range(n,0,-1):
now = max(now,cost-S[i]-T[i])
ans[i] = now
for i in ans[1:]:
print(i) | from heapq import heappush, heappop
n,m,s,t = list(map(int,input().split()))
e = [[] for i in range(n+1)]
for i in range(m):
u,v,a,b = list(map(int,input().split()))
e[u].append((v,a,b))
e[v].append((u,a,b))
S = [float("INF")]*(n+1)
S[s] = 0
h = []
heappush(h,[0,s])
while h:
d,now = heappop(h)
for nex,a,b in e[now]:
if d+a < S[nex]:
S[nex] = d+a
heappush(h,[d+a,nex])
T = [float("INF")]*(n+1)
T[t] = 0
h = []
heappush(h,[0,t])
while h:
d,now = heappop(h)
for nex,a,b in e[now]:
if d+b < T[nex]:
T[nex] = d+b
heappush(h,[d+b,nex])
ans = [0]*(n+1)
cost = 10**15
now = 0
for i in range(n,0,-1):
now = max(now,cost-S[i]-T[i])
ans[i] = now
for i in ans[1:]:
print(i) | p03305 |
from heapq import heappush, heappop
n,m,s,t = map(int,input().split())
e = [[] for i in range(n+1)]
for i in range(m):
u,v,a,b = map(int,input().split())
e[u].append((v,a,b))
e[v].append((u,a,b))
def dik(s,v):
S = [float("INF")]*(n+1)
S[s] = 0
h = []
heappush(h,[0,s])
while h:
d,now = heappop(h)
for nex in e[now]:
a,b = nex[0],nex[v]
if d+b < S[a]:
S[a] = d+b
heappush(h,[d+b,a])
return S
S = dik(s,1)
T = dik(t,2)
ans = [0]*(n)
cost = 10**15
now = 0
for i in range(n-1,-1,-1):
now = max(now,cost-S[i+1]-T[i+1])
ans[i] = now
print(*ans,sep="\n")
| from heapq import heappush as pu, heappop as po
n,m,s,t = map(int,input().split())
e = [[] for i in range(n+1)]
for i in range(m):
u,v,a,b = map(int,input().split())
e[u].append((v,a,b))
e[v].append((u,a,b))
def dik(s,v):
S = [float("INF")]*(n+1)
S[s] = 0
h = []
pu(h,[0,s])
while h:
d,now = po(h)
for nex in e[now]:
a,b = nex[0],nex[v]
if d+b < S[a]:
S[a] = d+b
pu(h,[d+b,a])
return S[::-1]
ans = []
cost = 10**15
now = 0
for i,j in zip(dik(s,1),dik(t,2)):
now = max(now,cost-i-j)
ans.append(now)
print(*ans[:-1][::-1],sep="\n")
| p03305 |
from collections import defaultdict
import heapq
class Dijkstra:
"""
dijkstraの最短経路問題を解く
input:
S: start node
mat : mat[a][b] = edge_weight(a,b)
"""
def __init__(self, start, num_node, mat):
"""
mat: mat[a][b] = edge_weight(a,b)
num_node: num of nodes
dist: dist from start_node
prev: 最短経路において、一つ前のノードを記憶。経路復元に使う?
"""
self.start_node = start
self.mat = mat
self.num_node = num_node
self.dist = [float('inf')]*num_node
self.prev = defaultdict(lambda: None)
# dist form S to S = 0
self.dist[start] = 0
def calc_dist(self):
"""
最短経路 distを計算する
Q: content (dist_from_start,node)
Qはheapqとして使う。dist_from_startの小さい順になる
"""
Q = []
heapq.heappush(Q, (0, self.start_node))
while Q:
dist_to_node, node = heapq.heappop(Q)
# 現在の値よりも大きくて、更新にならない場合
if self.dist[node] < dist_to_node:
continue
# 次のホップを計算する
for nex in range(self.num_node):
weight = self.mat[node][nex]
cand = dist_to_node + weight
if self.dist[nex] > cand: # update
self.dist[nex] = cand
self.prev[nex] = node
heapq.heappush(Q, (cand, nex))
def get_dist(self, d):
"""
startからdまでの距離を返す
これの前にcalc()を実行しておく
たどり着けない場合は、float('inf')がかえる
"""
return self.dist[d]
def get_path(self,dst):
"""
startからdstまでのpathをlistでreturn
valifyしてないので怪しい
"""
cur=dst
ret=[cur]
while cur!=self.start_node:
cur=self.prev[cur]
ret.append(cur)
return list(reversed(ret))
N,M,S,T = list(map(int,input().split()))
mat_s=[[float('inf')]*N for _ in range(N)]
mat_t=[[float('inf')]*N for _ in range(N)]
for _ in range(M):
a,b,c,d = list(map(int,input().split()))
mat_s[a-1][b-1]=c
mat_s[b-1][a-1]=c
mat_t[a-1][b-1]=d
mat_t[b-1][a-1]=d
D_S = Dijkstra(S-1,N,mat_s)
D_T = Dijkstra(T-1,N,mat_t)
D_S.calc_dist()
D_T.calc_dist()
ans=[None]*N
for i in range(N):
ans[i]= D_S.get_dist(i)+D_T.get_dist(i)
tmp=float("inf")
ans_list=[]
for i in reversed(list(range(N))):
tmp = min(tmp,ans[i])
ans_list.append(10**15-tmp)
print(("\n".join(map(str,reversed(ans_list)))))
| import heapq
N,M,S,T = list(map(int,input().split()))
adj=[[] for _ in range(N)]
for _ in range(M):
a,b,c,d = list(map(int,input().split()))
adj[a-1].append((b-1,c,d))
adj[b-1].append((a-1,c,d))
D_S=[float("inf")]*N
D_T=[float("inf")]*N
D_S[S-1]=0
D_T[T-1]=0
Q=[]
heapq.heappush(Q,S-1)
while Q:
v = heapq.heappop(Q)
dist_to_node,node=v//N,v%N
for nex in adj[node]:
(next_node,yen,_) = nex
if dist_to_node+yen<D_S[next_node]:
D_S[next_node] = dist_to_node+yen
heapq.heappush(Q,D_S[next_node]*N+next_node)
Q=[]
heapq.heappush(Q,T-1)
while Q:
v = heapq.heappop(Q)
dist_to_node,node=v//N,v%N
if D_T[node]< dist_to_node:
continue
for nex in adj[node]:
(next_node,_,yen) = nex
if dist_to_node+yen<D_T[next_node]:
D_T[next_node] = dist_to_node+yen
heapq.heappush(Q,D_T[next_node]*N+next_node)
tmp_min=float("inf")
ans=[]
for i in reversed(list(range(N))):
tmp_min = min(tmp_min,D_S[i]+D_T[i])
ans.append(tmp_min)
for a in reversed(ans):
print((10**15-a))
| p03305 |
import heapq as hq
from collections import deque
n,m,s,t=list(map(int,input().split()))
yenLinks={}
snkLinks={}
for _ in range(m):
u,v,a,b=list(map(int,input().split()))
if u not in yenLinks:
yenLinks[u]=[(v,a)]
snkLinks[u]=[(v,b)]
else:
yenLinks[u].append((v,a))
snkLinks[u].append((v,b))
if v not in yenLinks:
yenLinks[v]=[(u,a)]
snkLinks[v]=[(u,b)]
else:
yenLinks[v].append((u,a))
snkLinks[v].append((u,b))
#Dijkstra
INF=100000000000001
for i in range(1,n+1):
yenDijk=[[INF,0] for _ in range(n+1)] #Distance,Determined index0 never used#
snkDijk=[[INF,0] for _ in range(n+1)]
#yen route
pQueue=[(0,s)]
yenDijk[s]=[0,0]
hq.heapify(pQueue)
while pQueue:
d,v = hq.heappop(pQueue)
if yenDijk[v][1]:
continue
else:
yenDijk[v][1] = 1
for (w,D) in yenLinks[v]:
if yenDijk[w][1]:
continue
else:
if yenDijk[w][0]>yenDijk[v][0]+D:
yenDijk[w][0] = yenDijk[v][0]+D
hq.heappush(pQueue,(yenDijk[w][0],w))
#snuuk route
pQueue=[(0,t)]
snkDijk[t]=[0,0]
hq.heapify(pQueue)
while pQueue:
d,v = hq.heappop(pQueue)
if snkDijk[v][1]:
continue
else:
snkDijk[v][1] = 1
for (w,D) in snkLinks[v]:
if snkDijk[w][1]:
continue
else:
if snkDijk[w][0]>snkDijk[v][0]+D:
snkDijk[w][0] = snkDijk[v][0]+D
hq.heappush(pQueue,(snkDijk[w][0],w))
#OUTPUT
i = n
ans = INF
answers=[]
while i>0:
ans = min(ans,yenDijk[i][0]+snkDijk[i][0])
answers.append(1000000000000000-ans)
i-=1
answers.reverse()
for ans in answers:
print(ans) | import heapq as hq
from collections import deque
n,m,s,t=list(map(int,input().split()))
#リンク情報をつくる
yenLinks={}
snkLinks={}
for _ in range(m):
u,v,a,b=list(map(int,input().split()))
if u not in yenLinks:
yenLinks[u]=[(v,a)]
snkLinks[u]=[(v,b)]
else:
yenLinks[u].append((v,a))
snkLinks[u].append((v,b))
if v not in yenLinks:
yenLinks[v]=[(u,a)]
snkLinks[v]=[(u,b)]
else:
yenLinks[v].append((u,a))
snkLinks[v].append((u,b))
#Dijkstra法をする関数
INF=float('inf')
def dijkstra(start,links,nodeNum):
ans=[INF for _ in range(nodeNum+1)]
ans[start]=0
PQ=[(0,start)]
hq.heapify(PQ)
while PQ:
(Vd,V) = hq.heappop(PQ)
#print([V,Vd,ans[V]])
if Vd > ans[V]:
continue
for (W,D) in links[V]:
cand = ans[V] + D
if cand < ans[W]:
ans[W] = cand
hq.heappush(PQ,(ans[W],W))
#print(PQ)
return(ans)
#Dijkstra法実行
yenKstra=dijkstra(s,yenLinks,n)
snkKstra=dijkstra(t,snkLinks,n)
#答えを求める
i=n
ans=INF
answers=[]
while i>0:
cand = yenKstra[i]+snkKstra[i]
ans = min(ans,cand)
answers.append(10**15-ans)
i-=1
answers.reverse()
#出力
for ans in answers:
print(ans) | p03305 |
import heapq as hq
from collections import deque
n,m,s,t=list(map(int,input().split()))
#リンク情報をつくる
yenLinks={}
snkLinks={}
for _ in range(m):
u,v,a,b=list(map(int,input().split()))
if u not in yenLinks:
yenLinks[u]=[(v,a)]
snkLinks[u]=[(v,b)]
else:
yenLinks[u].append((v,a))
snkLinks[u].append((v,b))
if v not in yenLinks:
yenLinks[v]=[(u,a)]
snkLinks[v]=[(u,b)]
else:
yenLinks[v].append((u,a))
snkLinks[v].append((u,b))
#Dijkstra法をする関数
INF=float('inf')
def dijkstra(start,links,nodeNum):
ans=[INF for _ in range(nodeNum+1)]
ans[start]=0
PQ=[(0,start)]
hq.heapify(PQ)
while PQ:
(Vd,V) = hq.heappop(PQ)
#print([V,Vd,ans[V]])
if Vd > ans[V]:
continue
for (W,D) in links[V]:
cand = ans[V] + D
if cand < ans[W]:
ans[W] = cand
hq.heappush(PQ,(ans[W],W))
#print(PQ)
return(ans)
#Dijkstra法実行
yenKstra=dijkstra(s,yenLinks,n)
snkKstra=dijkstra(t,snkLinks,n)
#答えを求める
i=n
ans=INF
answers=[]
while i>0:
cand = yenKstra[i]+snkKstra[i]
ans = min(ans,cand)
answers.append(10**15-ans)
i-=1
answers.reverse()
#出力
for ans in answers:
print(ans) | import heapq as hq
from collections import deque
n,m,s,t=list(map(int,input().split()))
#リンク情報をつくる
yenLinks={}
snkLinks={}
for _ in range(m):
u,v,a,b=list(map(int,input().split()))
if u not in yenLinks:
yenLinks[u]=[(v,a)]
snkLinks[u]=[(v,b)]
else:
yenLinks[u].append((v,a))
snkLinks[u].append((v,b))
if v not in yenLinks:
yenLinks[v]=[(u,a)]
snkLinks[v]=[(u,b)]
else:
yenLinks[v].append((u,a))
snkLinks[v].append((u,b))
#Dijkstra法をする関数
INF=float('inf')
def dijkstra(start,links,nodeNum):
ans=[INF for _ in range(nodeNum+1)]
ans[start]=0
PQ=[(0,start)]
hq.heapify(PQ)
while PQ:
(Vd,V) = hq.heappop(PQ)
#print([V,Vd,ans[V]])
if Vd > ans[V]:
continue
for (W,D) in links[V]:
cand = ans[V] + D
if cand < ans[W]:
ans[W] = cand
hq.heappush(PQ,(ans[W],W))
#print(PQ)
return(ans)
#Dijkstra法実行
yenKstra=dijkstra(s,yenLinks,n)
snkKstra=dijkstra(t,snkLinks,n)
#答えを求める
i=n
ans=INF
answers=deque()
while i>0:
cand = yenKstra[i]+snkKstra[i]
ans = min(ans,cand)
answers.append(10**15-ans)
i-=1
#出力
for _ in range(n):
print((answers.pop())) | p03305 |
import sys
import heapq
from operator import itemgetter
from collections import deque, defaultdict
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 10**9 + 7
import heapq
class Heapq:
def __init__(self, que=[], asc=True):
if not asc:
que = [-a for a in que]
self.__que = que
heapq.heapify(self.__que)
self.__sign = 1 if asc else -1
def pop(self):
return heapq.heappop(self.__que) * self.__sign
def push(self, value):
heapq.heappush(self.__que, value * self.__sign)
def pushpop(self, value):
return heapq.heappushpop(self.__que, value * self.__sign) * self.__sign
def top(self):
return self.__que[0] * self.__sign
def size(self):
return len(self.__que)
def sol():
N, M, start, end = list(map(int, input().split()))
start -= 1
end -= 1
edgeA = [[] for _ in range(N)]
edgeB = [[] for _ in range(N)]
for _ in range(M):
fr, to, a, b = list(map(int, input().split()))
fr -= 1
to -= 1
edgeA[fr].append((to, a))
edgeA[to].append((fr, a))
edgeB[fr].append((to, b))
edgeB[to].append((fr, b))
minDistA = [float('inf')] * N
minDistB = [float('inf')] * N
que = Heapq([])
que.push((0, start))
while que.size():
dist, now = que.pop()
if minDistA[now] <= dist:
continue
minDistA[now] = dist
for to, cost in edgeA[now]:
if minDistA[to] > dist + cost:
que.push((cost + dist, to))
que = Heapq([])
que.push((0, end))
while que.size():
dist, now = que.pop()
if minDistB[now] <= dist:
continue
minDistB[now] = dist
for to, cost in edgeB[now]:
if minDistB[to] > dist + cost:
que.push((cost + dist, to))
ans = [float('inf')] * (N + 1)
for day in range(N)[:: -1]:
newDist = minDistA[day] + minDistB[day]
ans[day] = min(ans[day + 1], newDist)
offset = 10**15
for a in ans[: N]:
print((offset - a))
sol() | from heapq import heappop, heappush
N, M, S, T = map(int, input().split())
K = 10**15
S -= 1
T -= 1
edgesYen = [[] for _ in range(N)]
edgesSun = [[] for _ in range(N)]
for _ in range(M):
fr, to, yen, sun = map(int, input().split())
fr -= 1
to -= 1
edgesYen[fr].append((to, yen))
edgesYen[to].append((fr, yen))
edgesSun[fr].append((to, sun))
edgesSun[to].append((fr, sun))
def calcMinDist(edges, start):
minDist = [10**18] * N
minDist[start] = 0
que = [(0, start)]
while que:
dist, now = heappop(que)
if minDist[now] < dist:
continue
for to, d in edges[now]:
if minDist[to] > dist + d:
heappush(que, (dist + d, to))
minDist[to] = dist + d
return minDist
minDistYenS = calcMinDist(edgesYen, S)
minDistSunT = calcMinDist(edgesSun, T)
ans = [0] * N
for mid in range(N):
ans[mid] = K - minDistYenS[mid] - minDistSunT[mid]
for mid in range(N - 1)[::-1]:
ans[mid] = max(ans[mid], ans[mid + 1])
print(*ans, sep='\n')
| p03305 |
import heapq
n, m, s, t = list(map(int, input().split()))
INF = 2**63-1
data = []
for _ in range(m):
data.append(list(map(int, input().split())))
check = [False for i in range(n+1)]
graph = [[] for i in range(n+1)]
for i in range(m):
graph[data[i][0]].append([data[i][1], data[i][2], data[i][3]])
graph[data[i][1]].append([data[i][0], data[i][2], data[i][3]])
city_yen_cost = [INF for i in range(n+1)]
city_yen_cost[s] = 0
queue = []
#[cost, vertex]
heapq.heappush(queue, [0, s])
while len(queue) > 0:
now = heapq.heappop(queue)
if check[now[1]]:
continue
else:
check[now[1]] = True
for path in graph[now[1]]:
city_yen_cost[path[0]] = min(city_yen_cost[now[1]]+path[1], city_yen_cost[path[0]])
heapq.heappush(queue, [city_yen_cost[now[1]]+path[1], path[0]])
check = [False for i in range(n+1)]
city_snuke_cost = [INF for i in range(n+1)]
city_snuke_cost[t] = 0
queue = []
heapq.heappush(queue, [0, t])
while len(queue) > 0:
now = heapq.heappop(queue)
if check[now[1]]:
continue
else:
check[now[1]] = True
for path in graph[now[1]]:
city_snuke_cost[path[0]] = min(city_snuke_cost[now[1]]+path[2], city_snuke_cost[path[0]])
heapq.heappush(queue, [city_snuke_cost[now[1]]+path[2], path[0]])
totalcost = [None] * (n+1)
for i in range(n+1):
totalcost[i] = city_yen_cost[i] + city_snuke_cost[i]
for i in range(n):
totalcost[-i-2] = min(totalcost[-i-2], totalcost[-i-1])
for i in range(n):
print((10**15-totalcost[i+1]))
| import heapq
n, m, s, t = list(map(int, input().split()))
INF = 2**63-1
data = []
for _ in range(m):
data.append(list(map(int, input().split())))
check = [False for i in range(n+1)]
graph = [[] for i in range(n+1)]
for i in range(m):
graph[data[i][0]].append([data[i][1], data[i][2], data[i][3]])
graph[data[i][1]].append([data[i][0], data[i][2], data[i][3]])
city_yen_cost = [INF for i in range(n+1)]
city_yen_cost[s] = 0
queue = []
#[cost, vertex]
heapq.heappush(queue, [0, s])
while len(queue) > 0:
now = heapq.heappop(queue)
if check[now[1]]:
continue
else:
check[now[1]] = True
for path in graph[now[1]]:
if city_yen_cost[now[1]]+path[1] < city_yen_cost[path[0]]:
city_yen_cost[path[0]] = min(city_yen_cost[now[1]]+path[1], city_yen_cost[path[0]])
if not check[path[0]]:
heapq.heappush(queue, [city_yen_cost[now[1]]+path[1], path[0]])
check = [False for i in range(n+1)]
city_snuke_cost = [INF for i in range(n+1)]
city_snuke_cost[t] = 0
queue = []
heapq.heappush(queue, [0, t])
while len(queue) > 0:
now = heapq.heappop(queue)
if check[now[1]]:
continue
else:
check[now[1]] = True
for path in graph[now[1]]:
if city_snuke_cost[now[1]]+path[2] < city_snuke_cost[path[0]]:
city_snuke_cost[path[0]] = min(city_snuke_cost[now[1]]+path[2], city_snuke_cost[path[0]])
if not check[path[0]]:
heapq.heappush(queue, [city_snuke_cost[now[1]]+path[2], path[0]])
totalcost = [None] * (n+1)
for i in range(n+1):
totalcost[i] = city_yen_cost[i] + city_snuke_cost[i]
for i in range(n):
totalcost[-i-2] = min(totalcost[-i-2], totalcost[-i-1])
for i in range(n):
print((10**15-totalcost[i+1]))
| p03305 |
import heapq
n, m, s, t = list(map(int, input().split()))
INF = 10**20
data = []
for _ in range(m):
data.append(list(map(int, input().split())))
check = [False] * (n+1)
graph = [[] for i in range(n+1)]
for i in range(m):
graph[data[i][0]].append([data[i][1], data[i][2], data[i][3]])
graph[data[i][1]].append([data[i][0], data[i][2], data[i][3]])
city_yen_cost = [INF] * (n+1)
city_yen_cost[s] = 0
queue = []
#[cost, vertex]
heapq.heappush(queue, [0, s])
count = 0
while count != n:
now = heapq.heappop(queue)
if check[now[1]]:
continue
else:
count += 1
check[now[1]] = True
for path in graph[now[1]]:
if not check[path[0]]:
city_yen_cost[path[0]] = min(city_yen_cost[now[1]]+path[1], city_yen_cost[path[0]])
heapq.heappush(queue, [city_yen_cost[now[1]]+path[1], path[0]])
check = [False] * (n+1)
city_snuke_cost = [INF] * (n+1)
city_snuke_cost[t] = 0
queue = []
heapq.heappush(queue, [0, t])
count = 0
while count != n:
now = heapq.heappop(queue)
if check[now[1]]:
continue
else:
count += 1
check[now[1]] = True
for path in graph[now[1]]:
if not check[path[0]]:
city_snuke_cost[path[0]] = min(city_snuke_cost[now[1]]+path[2], city_snuke_cost[path[0]])
heapq.heappush(queue, [city_snuke_cost[now[1]]+path[2], path[0]])
for i in range(n+1):
city_yen_cost[i] += city_snuke_cost[i]
for i in range(n):
city_yen_cost[-i-2] = min(city_yen_cost[-i-2], city_yen_cost[-i-1])
for i in range(n):
print((10**15-city_yen_cost[i+1]))
| import heapq
n, m, s, t = list(map(int, input().split()))
INF = 10**20
data = []
for _ in range(m):
data.append(list(map(int, input().split())))
check = [False] * (n+1)
graph = [[] for i in range(n+1)]
for i in range(m):
graph[data[i][0]].append([data[i][1], data[i][2], data[i][3]])
graph[data[i][1]].append([data[i][0], data[i][2], data[i][3]])
city_yen_cost = [INF] * (n+1)
city_yen_cost[s] = 0
queue = []
#[cost, vertex]
heapq.heappush(queue, [0, s])
count = 0
while count != n:
now = heapq.heappop(queue)
if check[now[1]]:
continue
else:
count += 1
check[now[1]] = True
for path in graph[now[1]]:
if not check[path[0]]:
if city_yen_cost[now[1]]+path[1] < city_yen_cost[path[0]]:
city_yen_cost[path[0]] = city_yen_cost[now[1]]+path[1]
heapq.heappush(queue, [city_yen_cost[now[1]]+path[1], path[0]])
check = [False] * (n+1)
city_snuke_cost = [INF] * (n+1)
city_snuke_cost[t] = 0
queue = []
heapq.heappush(queue, [0, t])
count = 0
while count != n:
now = heapq.heappop(queue)
if check[now[1]]:
continue
else:
count += 1
check[now[1]] = True
for path in graph[now[1]]:
if not check[path[0]]:
if city_snuke_cost[now[1]]+path[2] < city_snuke_cost[path[0]]:
city_snuke_cost[path[0]] = city_snuke_cost[now[1]]+path[2]
heapq.heappush(queue, [city_snuke_cost[now[1]]+path[2], path[0]])
for i in range(n+1):
city_yen_cost[i] += city_snuke_cost[i]
for i in range(n):
city_yen_cost[-i-2] = min(city_yen_cost[-i-2], city_yen_cost[-i-1])
for i in range(n):
print((10**15-city_yen_cost[i+1]))
| p03305 |
import heapq
class Dijkstra:
def __init__(self, rote_map, start_point, goal_point=None):
self.rote_map = rote_map
self.start_point = start_point
self.goal_point = goal_point
def execute(self):
"""
:param rote_map:
:param start_point:
:param distance:
:return:
"""
num_of_city = len(self.rote_map)
dist = [float("inf") for _ in range(num_of_city)]
prev = [float("inf") for _ in range(num_of_city)]
dist[self.start_point] = 0
heap_q = []
heapq.heappush(heap_q, (0, self.start_point))
while len(heap_q) != 0:
prov_cost, src = heapq.heappop(heap_q)
if dist[src] < prov_cost:
continue
for dest in range(num_of_city):
cost = self.rote_map[src][dest]
if cost != float("inf") and dist[dest] > dist[src] + cost:
dist[dest] = dist[src] + cost
heapq.heappush(heap_q, (dist[dest], dest))
prev[dest] = src
if self.goal_point is not None:
return self.get_path(self.goal_point, prev)
else:
return dist
def get_path(self, goal, prev):
path = [goal]
dest = goal
while prev[dest] != float("inf"):
path.append(prev[dest])
dest = prev[dest]
return list(reversed(path))
n, m, s, t = map(int, input().split())
yen_route_map = [[float("inf") for j in range(n)] for _ in range(n)]
snuuk_route_map = [[float("inf") for j in range(n)] for _ in range(n)]
for i in range(m):
u, v, a, b = map(int, input().split())
u, v = u-1, v-1
yen_route_map[u][v] = a
yen_route_map[v][u] = a
snuuk_route_map[u][v] = b
snuuk_route_map[v][u] = b
yen_dijkstra = Dijkstra(yen_route_map, s-1).execute()
snuuk_dijkstra = Dijkstra(snuuk_route_map, t-1).execute()
from itertools import accumulate
ans = list(accumulate([y+s for y, s in zip(yen_dijkstra, snuuk_dijkstra)][::-1],min))
[print(10**15-ans[i]) for i in range(n-1,-1,-1)]
| import heapq
class Dijkstra:
def __init__(self, rote_map, start_point, goal_point=None):
self.rote_map = rote_map
self.start_point = start_point
self.goal_point = goal_point
def execute(self):
"""
:param rote_map:
:param start_point:
:param distance:
:return:
"""
num_of_city = len(self.rote_map)
dist = [float("inf") for _ in range(num_of_city)]
prev = [float("inf") for _ in range(num_of_city)]
dist[self.start_point] = 0
heap_q = []
heapq.heappush(heap_q, (0, self.start_point))
while len(heap_q) != 0:
prov_cost, src = heapq.heappop(heap_q)
if dist[src] < prov_cost:
continue
for dest, cost in self.rote_map[src].items():
if cost != float("inf") and dist[dest] > dist[src] + cost:
dist[dest] = dist[src] + cost
heapq.heappush(heap_q, (dist[dest], dest))
prev[dest] = src
if self.goal_point is not None:
return self.get_path(self.goal_point, prev)
else:
return dist
def get_path(self, goal, prev):
path = [goal]
dest = goal
while prev[dest] != float("inf"):
path.append(prev[dest])
dest = prev[dest]
return list(reversed(path))
n, m, s, t = map(int, input().split())
yen_route_map = [dict() for _ in range(n)]
snuuk_route_map = [dict() for _ in range(n)]
for i in range(m):
u, v, a, b = map(int, input().split())
u, v = u-1, v-1
yen_route_map[u][v] = yen_route_map[v][u] = a
snuuk_route_map[u][v] = snuuk_route_map[v][u] = b
yen_dijkstra = Dijkstra(yen_route_map, s-1).execute()
snuuk_dijkstra = Dijkstra(snuuk_route_map, t-1).execute()
from itertools import accumulate
ans = list(accumulate([y+s for y, s in zip(yen_dijkstra, snuuk_dijkstra)][::-1],min))
[print(10**15-ans[i]) for i in range(n-1,-1,-1)]
# answer1 = [yen + snuuk for yen, snuuk in zip(yen_dijkstra, snuuk_dijkstra)]
# answer2
#
# for i in range(n):
# print(10**15 - answer1[i])
| p03305 |
from heapq import heappush, heappop
from collections import defaultdict
n, m, s, t = list(map(int, input().split()))
y = 10**15
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def add_edge(self, src, dst, weight=1):
self.graph[src].append((dst, weight))
class Dijkstra(object):
def __init__(self, graph, start):
self.g = graph.graph
self.dist = defaultdict(lambda: float('inf'))
self.dist[start] = 0
self.Q = []
heappush(self.Q, (self.dist[start], start))
while self.Q:
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, weight in self.g[u]:
alt = dist_u + weight
if self.dist[v] > alt:
self.dist[v] = alt
heappush(self.Q, (alt, v))
yen_g = Graph()
sno_g = Graph()
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
yen_g.add_edge(u, v, a)
yen_g.add_edge(v, u, a)
sno_g.add_edge(u, v, b)
sno_g.add_edge(v, u, b)
cost = [0] * n
yen_d = Dijkstra(yen_g, s)
sno_d = Dijkstra(sno_g, t)
for i in range(1, n + 1):
cost[i - 1] = yen_d.dist[i] + sno_d.dist[i]
for i in range(n):
print((y - min(cost[i:])))
| from heapq import heappush, heappop
from collections import defaultdict
n, m, s, t = list(map(int, input().split()))
y = 10**15
class Graph(object):
def __init__(self):
self.graph = defaultdict(list)
def add_edge(self, src, dst, weight=1):
self.graph[src].append((dst, weight))
class Dijkstra(object):
def __init__(self, graph, start):
self.g = graph.graph
self.dist = defaultdict(lambda: float('inf'))
self.dist[start] = 0
self.Q = []
heappush(self.Q, (self.dist[start], start))
while self.Q:
dist_u, u = heappop(self.Q)
if self.dist[u] < dist_u:
continue
for v, weight in self.g[u]:
alt = dist_u + weight
if self.dist[v] > alt:
self.dist[v] = alt
heappush(self.Q, (alt, v))
yen_g = Graph()
sno_g = Graph()
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
yen_g.add_edge(u, v, a)
yen_g.add_edge(v, u, a)
sno_g.add_edge(u, v, b)
sno_g.add_edge(v, u, b)
cost = [0] * n
yen_d = Dijkstra(yen_g, s)
sno_d = Dijkstra(sno_g, t)
for i in range(1, n + 1):
cost[i - 1] = y - (yen_d.dist[i] + sno_d.dist[i])
ans = [y] * n
ans[n - 1] = cost[n - 1]
for i in range(n - 2, -1, -1):
ans[i] = max(ans[i + 1], cost[i])
for a in ans:
print(a)
| p03305 |
import heapq
def dijkstra(s, type=0):
dist = [float('inf')] * N
dist[s] = 0
que = [(0, s)]
heapq.heapify(que)
while que:
d, v = heapq.heappop(que)
if d > dist[v]:
continue
for u, a, b in E[v]:
if type != 0:
a, b = b, a
tmp_d = d + a
if tmp_d < dist[u]:
dist[u] = tmp_d
heapq.heappush(que, (tmp_d, u))
return dist
N, M, s, t = list(map(int, input().split()))
E = [[] for _ in range(N)]
for _ in range(M):
u, v, a, b = list(map(int, input().split()))
E[u-1].append((v-1, a, b))
E[v-1].append((u-1, a, b))
dist_s = dijkstra(s-1)
dist_t = dijkstra(t-1, 1)
ans = float('inf')
idx = -1
for i in range(N):
if idx >= i:
print((10 ** 15 - ans))
continue
tmp = float('inf')
for j in range(i, N):
if dist_s[j] + dist_t[j] <= tmp:
tmp = dist_s[j] + dist_t[j]
ans = tmp
idx = j
print((10 ** 15 - ans))
| import heapq
def dijkstra(s, neighbor):
dist = [float('inf')] * N
dist[s] = 0
que = [(0, s)]
heapq.heapify(que)
while que:
d, v = heapq.heappop(que)
if d > dist[v]:
continue
for u, l in neighbor[v]:
tmp_d = d + l
if tmp_d < dist[u]:
dist[u] = tmp_d
heapq.heappush(que, (tmp_d, u))
return dist
N, M, s, t = map(int, input().split())
yen = [[] for _ in range(N)]
snuuk = [[] for _ in range(N)]
for _ in range(M):
u, v, a, b = map(int, input().split())
yen[u-1].append((v-1, a))
yen[v-1].append((u-1, a))
snuuk[u-1].append((v-1, b))
snuuk[v-1].append((u-1, b))
dist_s = dijkstra(s-1, yen)
dist_t = dijkstra(t-1, snuuk)
ans = [-1] * N
tmp = float('inf')
for i in range(N-1, -1, -1):
if dist_s[i] + dist_t[i] < tmp:
tmp = dist_s[i] + dist_t[i]
ans[i] = 10 ** 15 - tmp
print(*ans, sep='\n')
| p03305 |
from collections import defaultdict
from queue import PriorityQueue
def dijkstra(G, s):
q = PriorityQueue()
prev = [None] * len(list(G.keys()))
dist = [float('inf')] * len(list(G.keys()))
dist[s] = 0
for v in sorted(G.keys()):
q.put((dist[v],v))
while not q.empty():
_, u = q.get()
for v, d in G[u]:
tmp = dist[u] + d
if dist[v] > tmp:
dist[v] = tmp
prev[v] = u
q.put((tmp, v))
return dist
n, m, s, t = list(map(int, input().split()))
G1 = defaultdict(list)
G2 = defaultdict(list)
for i in range(m):
u, v, a, b = list(map(int, input().split()))
u -= 1
v -= 1
G1[u].append((v, a))
G1[v].append((u, a))
G2[u].append((v, b))
G2[v].append((u, b))
dist1 = dijkstra(G1, s-1)
dist2 = dijkstra(G2, t-1)
mv = 0
ans = []
for i in range(n-1, -1, -1):
mv = max(mv, 10**15 - dist1[i] - dist2[i])
ans.append(mv)
ans.reverse()
for a in ans:
print(a) | from collections import defaultdict
import heapq
def dijkstra(G, s):
q = []
heapq.heapify(q)
prev = [None] * len(list(G.keys()))
dist = [float('inf')] * len(list(G.keys()))
dist[s] = 0
for v in sorted(G.keys()):
heapq.heappush(q, (dist[v],v))
while True:
try:
_, u = heapq.heappop(q)
except:
break
for v, d in G[u]:
tmp = dist[u] + d
if dist[v] > tmp:
dist[v] = tmp
prev[v] = u
heapq.heappush(q, (tmp, v))
return dist
n, m, s, t = list(map(int, input().split()))
G1 = defaultdict(list)
G2 = defaultdict(list)
for i in range(m):
u, v, a, b = list(map(int, input().split()))
u -= 1
v -= 1
G1[u].append((v, a))
G1[v].append((u, a))
G2[u].append((v, b))
G2[v].append((u, b))
dist1 = dijkstra(G1, s-1)
dist2 = dijkstra(G2, t-1)
mv = 0
ans = []
for i in range(n-1, -1, -1):
mv = max(mv, 10**15 - dist1[i] - dist2[i])
ans.append(mv)
ans.reverse()
for a in ans:
print(a) | p03305 |
import heapq
N, M, S, T = list(map(int, input().split()))
class Dijkstra:
def dijkstra(self, adj, start, goal=None):
num = N # グラフのノード数
dist = [float('inf') for i in range(num)] # 始点から各頂点までの最短距離を格納する
prev = [float('inf') for i in range(num)] # 最短経路における，その頂点の前の頂点のIDを格納する
dist[start] = 0
q = [] # プライオリティキュー．各要素は，(startからある頂点vまでの仮の距離, 頂点vのID)からなるタプル
heapq.heappush(q, (0, start)) # 始点をpush
for i in range(num-1):
prov_cost, src = heapq.heappop(q) # pop
# プライオリティキューに格納されている最短距離が，現在計算できている最短距離より大きければ，distの更新をする必要はない
if dist[src] < prov_cost:
continue
# 他の頂点の探索
for dest, cost in list(adj[src].items()):
if cost != float('inf') and dist[dest] > dist[src] + cost:
dist[dest] = dist[src] + cost # distの更新
heapq.heappush(q, (dist[dest], dest)) # キューに新たな仮の距離の情報をpush
prev[dest] = src # 前の頂点を記録
if goal is not None:
return self.get_path(goal, prev)
else:
return dist
def get_path(self, goal, prev):
'''
始点startから終点goalまでの最短経路を求める
'''
path = [goal] # 最短経路
dest = goal
# 終点から最短経路を逆順に辿る
while prev[dest] != float('inf'):
path.append(prev[dest])
dest = prev[dest]
# 経路をreverseして出力
return list(reversed(path))
from collections import defaultdict
Ey = defaultdict(lambda: defaultdict(lambda: float("inf")))
Es = defaultdict(lambda: defaultdict(lambda: float("inf")))
E = [list(map(int, input().split())) for i in range(M)]
for e in E:
u, v, a, b = e
Ey[u-1][v-1] = Ey[v-1][u-1] = a
Es[u-1][v-1] = Es[v-1][u-1] = b
dj = Dijkstra()
Dy = dj.dijkstra(Ey, S-1)
Ds = dj.dijkstra(Es, T-1)
mi = float("inf")
Ans = [0] * N
for i in range(N-1, -1, -1):
mi = min(mi, Dy[i]+Ds[i])
Ans[i] = mi
for a in Ans:
print((10**15-a))
| import heapq
N, M, S, T = list(map(int, input().split()))
class Dijkstra:
def dijkstra(self, adj, start, goal=None):
num = N # グラフのノード数
dist = [float('inf') for i in range(num)] # 始点から各頂点までの最短距離を格納する
prev = [float('inf') for i in range(num)] # 最短経路における，その頂点の前の頂点のIDを格納する
dist[start] = 0
q = [] # プライオリティキュー．各要素は，(startからある頂点vまでの仮の距離, 頂点vのID)からなるタプル
heapq.heappush(q, (0, start)) # 始点をpush
for i in range(num-1):
prov_cost, src = heapq.heappop(q) # pop
# プライオリティキューに格納されている最短距離が，現在計算できている最短距離より大きければ，distの更新をする必要はない
if dist[src] < prov_cost:
continue
# 他の頂点の探索
for dest, cost in list(adj[src].items()):
if dist[dest] > dist[src] + cost:
dist[dest] = dist[src] + cost # distの更新
heapq.heappush(q, (dist[dest], dest)) # キューに新たな仮の距離の情報をpush
prev[dest] = src # 前の頂点を記録
if goal is not None:
return self.get_path(goal, prev)
else:
return dist
def get_path(self, goal, prev):
'''
始点startから終点goalまでの最短経路を求める
'''
path = [goal] # 最短経路
dest = goal
# 終点から最短経路を逆順に辿る
while prev[dest] != float('inf'):
path.append(prev[dest])
dest = prev[dest]
# 経路をreverseして出力
return list(reversed(path))
from collections import defaultdict
Ey = defaultdict(lambda: defaultdict(lambda: float("inf")))
Es = defaultdict(lambda: defaultdict(lambda: float("inf")))
E = [list(map(int, input().split())) for i in range(M)]
for e in E:
u, v, a, b = e
Ey[u-1][v-1] = Ey[v-1][u-1] = a
Es[u-1][v-1] = Es[v-1][u-1] = b
dj = Dijkstra()
Dy = dj.dijkstra(Ey, S-1)
Ds = dj.dijkstra(Es, T-1)
mi = float("inf")
Ans = [0] * N
for i in range(N-1, -1, -1):
mi = min(mi, Dy[i]+Ds[i])
Ans[i] = mi
for a in Ans:
print((10**15-a))
| p03305 |
import heapq
N, M, S, T = list(map(int, input().split()))
class Dijkstra:
def dijkstra(self, adj, start, goal=None):
num = N # グラフのノード数
dist = [float('inf') for i in range(num)] # 始点から各頂点までの最短距離を格納する
prev = [float('inf') for i in range(num)] # 最短経路における，その頂点の前の頂点のIDを格納する
dist[start] = 0
q = [] # プライオリティキュー．各要素は，(startからある頂点vまでの仮の距離, 頂点vのID)からなるタプル
heapq.heappush(q, (0, start)) # 始点をpush
for i in range(num-1):
prov_cost, src = heapq.heappop(q) # pop
# プライオリティキューに格納されている最短距離が，現在計算できている最短距離より大きければ，distの更新をする必要はない
if dist[src] < prov_cost:
continue
# 他の頂点の探索
for dest, cost in list(adj[src].items()):
if dist[dest] > dist[src] + cost:
dist[dest] = dist[src] + cost # distの更新
heapq.heappush(q, (dist[dest], dest)) # キューに新たな仮の距離の情報をpush
prev[dest] = src # 前の頂点を記録
if goal is not None:
return self.get_path(goal, prev)
else:
return dist
def get_path(self, goal, prev):
'''
始点startから終点goalまでの最短経路を求める
'''
path = [goal] # 最短経路
dest = goal
# 終点から最短経路を逆順に辿る
while prev[dest] != float('inf'):
path.append(prev[dest])
dest = prev[dest]
# 経路をreverseして出力
return list(reversed(path))
from collections import defaultdict
Ey = defaultdict(lambda: defaultdict(lambda: float("inf")))
Es = defaultdict(lambda: defaultdict(lambda: float("inf")))
E = [list(map(int, input().split())) for i in range(M)]
for e in E:
u, v, a, b = e
Ey[u-1][v-1] = Ey[v-1][u-1] = a
Es[u-1][v-1] = Es[v-1][u-1] = b
dj = Dijkstra()
Dy = dj.dijkstra(Ey, S-1)
Ds = dj.dijkstra(Es, T-1)
mi = float("inf")
Ans = [0] * N
for i in range(N-1, -1, -1):
mi = min(mi, Dy[i]+Ds[i])
Ans[i] = mi
for a in Ans:
print((10**15-a))
| import sys
def main():
N, M, S, T = list(map(int, input().split()))
A = [[] for _ in range(N+1)]
B = [[] for _ in range(N+1)]
for u, v, a, b in zip(*[iter(map(int, sys.stdin.read().split()))]*4):
A[u].append((v, a))
A[v].append((u, a))
B[u].append((v, b))
B[v].append((u, b))
def dijkstra(E, start):
from heapq import heappush, heappop
N = len(E)
inf = float("inf")
dist = [inf] * N
dist[start] = 0
q = [(0, start)]
while q:
dist_v, v = heappop(q)
if dist[v] != dist_v:
continue
for u, dist_vu in E[v]:
dist_u = dist_v + dist_vu
if dist_u < dist[u]:
dist[u] = dist_u
heappush(q, (dist_u, u))
return dist
dist_A = dijkstra(A, S)
dist_B = dijkstra(B, T)
init = 10**15
Ans = []
ans = float("inf")
for a, b in zip(dist_A[:0:-1], dist_B[:0:-1]):
ans = min(ans, a+b)
Ans.append(init-ans)
Ans.reverse()
print(("\n".join(map(str, Ans))))
main()
| p03305 |
from collections import defaultdict
from heapq import heappush, heappop
def dijkstra(V, E, s):
'''
Input:
V = list(range(N))
E = defaultdict(dict)
s (in V) : start vertex
Output:
dist: the list of the minimum cost from s to arbitrary vertex v in the given graph
'''
INF = float('inf')
dist = {v: INF for v in V}
heap = []
heappush(heap, (0, s))
while heap:
d, v = heappop(heap)
# don't need to check when the stored value is greater than provisional distance
if d > dist[v]:
continue
dist[v] = d
for u, c in E[v].items():
temp = d + c
if temp < dist[u]:
heappush(heap, (temp, u))
return dist
MON = 10**15
n, m, s, t = map(int, input().split())
V = list(range(1, n+1))
E1, E2 = {v: {} for v in V}, {v: {} for v in V}
for _ in range(m):
u, v, a, b = map(int, input().split())
E1[u][v] = a
E1[v][u] = a
E2[u][v] = b
E2[v][u] = b
ans = [MON]*n
dist_yen = dijkstra(V, E1, s)
dist_snuuk = dijkstra(V, E2, t)
temp = float('inf')
for v in V[::-1]:
temp = min(temp, dist_yen[v] + dist_snuuk[v])
ans[v-1] -= temp
print(*ans, sep='\n')
| from collections import defaultdict
from heapq import heappush, heappop
def dijkstra(V, E, s):
'''
Input:
V = list(range(N))
E = defaultdict(dict)
s (in V) : start vertex
Output:
dist: the list of the minimum cost from s to arbitrary vertex v in the given graph
'''
INF = float('inf')
dist = {v: INF for v in V}
heap = []
dist[s] = 0; rem = len(V);
heappush(heap, (0, s))
while heap and rem:
d, v = heappop(heap)
# don't need to check when the stored value is greater than provisional distance
if d > dist[v]: continue
rem -= 1;
for u, c in E[v].items():
temp = d + c
if temp < dist[u]:
dist[u] = temp
heappush(heap, (temp, u))
return dist
MON = 10**15
n, m, s, t = map(int, input().split())
V = list(range(1, n+1))
E1, E2 = {v: {} for v in V}, {v: {} for v in V}
for _ in range(m):
u, v, a, b = map(int, input().split())
E1[u][v] = a
E1[v][u] = a
E2[u][v] = b
E2[v][u] = b
ans = [MON]*n
dist_yen = dijkstra(V, E1, s)
dist_snuuk = dijkstra(V, E2, t)
temp = float('inf')
for v in V[::-1]:
temp = min(temp, dist_yen[v] + dist_snuuk[v])
ans[v-1] -= temp
print(*ans, sep='\n')
| p03305 |
from heapq import *
n,m,s,t=list(map(int,input().split()))
s-=1
t-=1
INF=10**19
Gyen=[[]for i in range(n)]
Gsnu=[[]for i in range(n)]
for i in range(m):
u,v,a,b=list(map(int,input().split()))
u-=1
v-=1
Gyen[u].append([v,a])
Gyen[v].append([u,a])
Gsnu[u].append([v,b])
Gsnu[v].append([u,b])
def dijkstra(G,s):
que=[]
d=[INF]*n
d[s]=0
visited={s}
heappush(que,[0,s])
while(que):
p=heappop(que)
v=p[1]
visited.add(v)
if d[v]<p[0]:
continue
for node,cost in G[v]:
if (node not in visited) and d[node]>d[v]+cost:
d[node]=d[v]+cost
heappush(que,[d[node],node])
return d
yen=dijkstra(Gyen,s)
snu=dijkstra(Gsnu,t)
ans=10**15
ans_list=[]
for i in reversed(list(range(n))):
ans=min(ans,yen[i]+snu[i])
ans_list.append(10**15-ans)
for i in reversed(list(range(n))):
print((ans_list[i]))
| from heapq import *
n,m,s,t=map(int,input().split())
s-=1
t-=1
INF=10**19
Gyen=[[]for i in range(n)]
Gsnu=[[]for i in range(n)]
for i in range(m):
u,v,a,b=map(int,input().split())
u-=1
v-=1
Gyen[u].append([v,a])
Gyen[v].append([u,a])
Gsnu[u].append([v,b])
Gsnu[v].append([u,b])
def dijkstra(G,s):
que=[]
d=[INF]*n
d[s]=0
visited={s}
heappush(que,[0,s])
while(que):
p=heappop(que)
v=p[1]
visited.add(v)
if d[v]<p[0]:
continue
for node,cost in G[v]:
if (node not in visited) and d[node]>d[v]+cost:
d[node]=d[v]+cost
heappush(que,[d[node],node])
return d
yen=dijkstra(Gyen,s)
snu=dijkstra(Gsnu,t)
ans=10**15
ans_list=[]
for i in reversed(range(n)):
ans=min(ans,yen[i]+snu[i])
ans_list.append(10**15-ans)
print(*ans_list[::-1], sep='\n')
| p03305 |
from heapq import *
n,m,s,t=map(int,input().split())
s-=1
t-=1
INF=10**19
Gyen=[[]for i in range(n)]
Gsnu=[[]for i in range(n)]
for i in range(m):
u,v,a,b=map(int,input().split())
u-=1
v-=1
Gyen[u].append([v,a])
Gyen[v].append([u,a])
Gsnu[u].append([v,b])
Gsnu[v].append([u,b])
def dijkstra(G,s):
que=[]
d=[INF]*n
d[s]=0
visited={s}
heappush(que,[0,s])
while(que):
p=heappop(que)
v=p[1]
visited.add(v)
if d[v]<p[0]:
continue
for node,cost in G[v]:
if (node not in visited) and d[node]>d[v]+cost:
d[node]=d[v]+cost
heappush(que,[d[node],node])
return d
yen=dijkstra(Gyen,s)
snu=dijkstra(Gsnu,t)
ans=10**15
ans_list=[]
for i in reversed(range(n)):
ans=min(ans,yen[i]+snu[i])
ans_list.append(10**15-ans)
print(*ans_list[::-1], sep='\n')
| from heapq import *
n,m,s,t=map(int,input().split())
s-=1
t-=1
INF=10**19
Gyen=[[]for i in range(n)]
Gsnu=[[]for i in range(n)]
for i in range(m):
u,v,a,b=map(int,input().split())
u-=1
v-=1
Gyen[u].append([v,a])
Gyen[v].append([u,a])
Gsnu[u].append([v,b])
Gsnu[v].append([u,b])
def dijkstra(G,s):
que=[]
d=[INF]*n
d[s]=0
visited={s}
heappush(que,[0,s])
while(que):
p=heappop(que)
v=p[1]
visited.add(v)
for node,cost in G[v]:
if (node not in visited) and d[node]>d[v]+cost:
d[node]=d[v]+cost
heappush(que,[d[node],node])
return d
yen=dijkstra(Gyen,s)
snu=dijkstra(Gsnu,t)
ans=10**15
ans_list=[]
for i in reversed(range(n)):
ans=min(ans,yen[i]+snu[i])
ans_list.append(10**15-ans)
print(*ans_list[::-1], sep='\n')
| p03305 |
from heapq import *
n,m,s,t=map(int,input().split())
s-=1
t-=1
INF=float("inf")
Gyen=[[]for i in range(n)]
Gsnu=[[]for i in range(n)]
for i in range(m):
u,v,a,b=map(int,input().split())
u-=1
v-=1
Gyen[u].append([v,a])
Gyen[v].append([u,a])
Gsnu[u].append([v,b])
Gsnu[v].append([u,b])
def dijkstra(G,s):
d=[INF]*n
d[s]=0
visited={s}
que=[[0,s]]
while(que):
p=heappop(que)
v=p[1]
visited.add(v)
for node,cost in G[v]:
if (node not in visited) and d[node]>d[v]+cost:
d[node]=d[v]+cost
heappush(que,[d[node],node])
return d
yen=dijkstra(Gyen,s)
snu=dijkstra(Gsnu,t)
ans=10**15
ans_list=[]
for i in reversed(range(n)):
ans=min(ans,yen[i]+snu[i])
ans_list.append(10**15-ans)
print(*ans_list[::-1], sep='\n')
| from heapq import *
n,m,s,t=map(int,input().split())
s-=1
t-=1
INF=float("inf")
Gyen=[[]for i in range(n)]
Gsnu=[[]for i in range(n)]
for i in range(m):
u,v,a,b=map(int,input().split())
u-=1
v-=1
Gyen[u].append([v,a])
Gyen[v].append([u,a])
Gsnu[u].append([v,b])
Gsnu[v].append([u,b])
def dijkstra(G,s):
d=[INF]*n
d[s]=0
visited={s}
que=[(0,s)]
while(que):
p=heappop(que)
v=p[1]
visited.add(v)
for node,cost in G[v]:
if (node not in visited) and d[node]>d[v]+cost:
d[node]=d[v]+cost
heappush(que,(d[node],node))
return d
yen=dijkstra(Gyen,s)
snu=dijkstra(Gsnu,t)
ans=10**15
ans_list=[]
for i in reversed(range(n)):
ans=min(ans,yen[i]+snu[i])
ans_list.append(10**15-ans)
print(*ans_list[::-1], sep='\n')
| p03305 |
from heapq import *
n,m,s,t=list(map(int,input().split()))
s-=1
t-=1
INF=float("inf")
Gyen=[[]for i in range(n)]
Gsnu=[[]for i in range(n)]
for i in range(m):
u,v,a,b=list(map(int,input().split()))
u-=1
v-=1
Gyen[u].append([v,a])
Gyen[v].append([u,a])
Gsnu[u].append([v,b])
Gsnu[v].append([u,b])
def dijkstra(G,s):
d=[INF]*n
d[s]=0
visited={s}
que=[(0,s)]
while(que):
p=heappop(que)
v=p[1]
visited.add(v)
for node,cost in G[v]:
if (node not in visited) and d[node]>d[v]+cost:
d[node]=d[v]+cost
heappush(que,(d[node],node))
return d
yen=dijkstra(Gyen,s)
snu=dijkstra(Gsnu,t)
ans=10**15
ans_list=[]
for i in reversed(list(range(n))):
ans=min(ans,yen[i]+snu[i])
ans_list.append(10**15-ans)
for i in ans_list[::-1]:
print(i) | from heapq import *
n,m,s,t=map(int,input().split())
s-=1
t-=1
INF=10**19
Gyen=[[]for i in range(n)]
Gsnu=[[]for i in range(n)]
for i in range(m):
u,v,a,b=map(int,input().split())
u-=1
v-=1
Gyen[u].append([v,a])
Gyen[v].append([u,a])
Gsnu[u].append([v,b])
Gsnu[v].append([u,b])
def dijkstra(G,s):
d=[INF]*n
d[s]=0
visited={s}
que=[(0,s)]
while(que):
p=heappop(que)
v=p[1]
visited.add(v)
for node,cost in G[v]:
if (node not in visited) and d[node]>d[v]+cost:
d[node]=d[v]+cost
heappush(que,(d[node],node))
return d
yen=dijkstra(Gyen,s)
snu=dijkstra(Gsnu,t)
ans=10**15
ans_list=[]
for i in reversed(range(n)):
ans=min(ans,yen[i]+snu[i])
ans_list.append(10**15-ans)
print(*ans_list[::-1], sep='\n')
| p03305 |
#### import ####
import sys
import math
from collections import defaultdict
#### 設定 ####
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
#### 定数 ####
mod = 10**9 + 7
#### 読み込み ####
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N):
read_all = [tuple(map(int, input().split())) for _ in range(N)]
return list(map(list,list(zip(*read_all))))
#################
n,m,s,t = II()
u,v,a,b = Line(m)
from heapq import heappop, heappush
def dijkstra(E,s,n):
inf=float('inf')
d=[inf for _ in range(n)]
d[s]=0
q=[]
heappush(q,(0,s))
while q:
du, u1 = heappop(q)
if d[u1]<du: continue
for v1,weight in E.get(u1,[]):
alt=du+weight
if d[v1]>alt:
d[v1]=alt
heappush(q, (alt,v1))
return d
p = dict()
p2 = dict()
for i in range(m):
p[u[i]-1]=p.get(u[i]-1,[])+[(v[i]-1,a[i])]
p[v[i]-1]=p.get(v[i]-1,[])+[(u[i]-1,a[i])]
p2[u[i]-1]=p2.get(u[i]-1,[])+[(v[i]-1,b[i])]
p2[v[i]-1]=p2.get(v[i]-1,[])+[(u[i]-1,b[i])]
d = dijkstra(p,s-1,n)
d2 = dijkstra(p2,t-1,n)
ans = [0]*n
ans[0] = d[n-1]+d2[n-1]
for i in range(1,n):
ans[i] = min(ans[i-1],d[n-1-i]+d2[n-1-i])
for i in ans[::-1]:
print((10**15-i)) | #### import ####
import sys
import math
from collections import defaultdict
#### 設定 ####
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
#### 定数 ####
mod = 10**9 + 7
#### 読み込み ####
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N):
read_all = [tuple(map(int, input().split())) for _ in range(N)]
return list(map(list,list(zip(*read_all))))
#################
n,m,s,t = II()
u,v,a,b = Line(m)
from heapq import heappop, heappush
def dijkstra(E,s,n):
inf=float('inf')
d=[inf for _ in range(n)]
d[s]=0
q=[]
heappush(q,(0,s))
while q:
du, u1 = heappop(q)
if d[u1]<du: continue
for v1,weight in list(E[u1].items()):
alt=du+weight
if d[v1]>alt:
d[v1]=alt
heappush(q, (alt,v1))
return d
p = [dict() for _ in range(n)]
p2 = [dict() for _ in range(n)]
for i in range(m):
p[u[i]-1][v[i]-1] = a[i]
p[v[i]-1][u[i]-1] = a[i]
p2[u[i]-1][v[i]-1] = b[i]
p2[v[i]-1][u[i]-1] = b[i]
d = dijkstra(p,s-1,n)
d2 = dijkstra(p2,t-1,n)
ans = [0]*n
ans[0] = d[n-1]+d2[n-1]
for i in range(1,n):
ans[i] = min(ans[i-1],d[n-1-i]+d2[n-1-i])
for i in ans[::-1]:
print((10**15-i)) | p03305 |
n,m,s,t=map(int,input().split())
uvab=[map(int,input().split()) for i in range(m)]
inf=10**20
c1=[[inf]*n for i in range(n)]
c2=[[inf]*n for i in range(n)]
for u,v,a,b in uvab:
c1[u-1][v-1]=c1[v-1][u-1]=a
c2[u-1][v-1]=c2[v-1][u-1]=b
for i in range(n):
c1[i][i]=c2[i][i]=0
from heapq import heappop,heappush
def dij(c,N,start):
d=[inf]*N
d[start]=0
prev=[-1]*N
q=[]
heappush(q,(0,start))
while len(q)>0:
u=heappop(q)[1]
for v in range(N):
if c[u][v]<inf:
temp=d[u]+c[u][v]
if d[v]>temp:
d[v]=temp
prev[v]=u
heappush(q,(d[v],v))
return d
d1=dij(c1,n,s-1)
d2=dij(c2,n,t-1)
r=[0]*n
for i in range(n):
r[-i-1]=max(r[-i],10**15-int(d1[-i-1])-int(d2[-i-1]))
print(*r,sep='\n')
| n,m,s,t=map(int,input().split())
uvab=[map(int,input().split()) for i in range(m)]
inf=10**20
c1=[[] for i in range(n)]
c2=[[] for i in range(n)]
for u,v,a,b in uvab:
c1[u-1].append((v-1,a))
c1[v-1].append((u-1,a))
c2[u-1].append((v-1,b))
c2[v-1].append((u-1,b))
from heapq import heappop,heappush
def dij(c,N,start):
d=[inf]*N
d[start]=0
prev=[-1]*N
q=[]
heappush(q,(0,start))
while len(q)>0:
u=heappop(q)[1]
for v,w in c[u]:
if w<inf:
temp=d[u]+w
if d[v]>temp:
d[v]=temp
prev[v]=u
heappush(q,(d[v],v))
return d
d1=dij(c1,n,s-1)
d2=dij(c2,n,t-1)
r=[0]*n
for i in range(n):
r[-i-1]=max(r[-i],10**15-int(d1[-i-1])-int(d2[-i-1]))
print(*r,sep='\n')
| p03305 |
# -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/soundhound2018-summer-qual/editorial.pdf
https://ikatakos.com/pot/programming_algorithm/contest_history/atcoder/2018/0707_soundhound2018_summer_qual
"""
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians, log10
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul, xor
from copy import copy, deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
# ダイクストラ(頂点数, 隣接リスト(0-indexed), 始点)
def dijkstra(N: int, nodes: list, src: int) -> list:
# 頂点[ある始点からの最短距離]
# (経路自体を知りたい時はここに前の頂点も持たせる)
res = [float('inf')] * N
# スタート位置
que = [(0, src)]
res[src] = 0
# キューが空になるまで
while len(que) != 0:
# srcからの距離, 現在のノード
dist, cur = heappop(que)
# 出発ノードcurの到着ノードでループ
for nxt, cost in nodes[cur]:
# 今回の経路のが短い時
if res[cur] + cost < res[nxt]:
res[nxt] = res[cur] + cost
# 現在の移動距離をキューの優先度として、早い方から先に処理するようにする
heappush(que, (res[nxt], nxt))
# ノードsrcからの最短距離リストを返却
return res
N,M,S,T=MAP()
nodes1=[[] for i in range(N)]
nodes2=[[] for i in range(N)]
for i in range(M):
u,v,a,b=MAP()
# 円での始点からダイクストラ用
nodes1[u-1].append((v-1,a))
nodes1[v-1].append((u-1,a))
# スヌークでの終点からダイクストラ用
nodes2[u-1].append((v-1,b))
nodes2[v-1].append((u-1,b))
yen=dijkstra(N,nodes1,S-1)
snuk=dijkstra(N,nodes2,T-1)
ans=[0]*N
mn=INF
# 逆順で最小値を取っていけば効率よくやれる
for i in range(N-1, -1, -1):
ans[i]=mn=min(mn, yen[i]+snuk[i])
# 10^15から引けば答え
for i in range(N):
print((1000000000000000-ans[i]))
| # -*- coding: utf-8 -*-
import sys
from itertools import accumulate
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
def dijkstra(N: int, nodes: list, src: int) -> list:
""" ダイクストラ高速化版(頂点数, 隣接リスト(0-indexed), 始点) """
from heapq import heappush, heappop
# 頂点[ある始点からの最短距離]
res = [INF] * N
# スタート位置
que = [src]
res[src] = 0
# キューが空になるまで
while len(que) != 0:
# 距離*N + 現在のノード
cur = heappop(que)
# 距離とノードに分ける
dist = cur // N
cur %= N
# 出発ノードcurの到着ノードでループ
for nxt, cost in nodes[cur]:
# 今回の経路のが短い時
if dist + cost < res[nxt]:
res[nxt] = dist + cost
# 距離*N+ノード番号 の形でキューに詰める
heappush(que, (dist+cost)*N+nxt)
# ノードsrcからの最短距離リストを返却
return res
N, M, s, t = MAP()
s -= 1
t -= 1
nodes1 = tuple([] for i in range(N))
nodes2 = tuple([] for i in range(N))
for i in range(M):
u, v, a, b = MAP()
u -= 1
v -= 1
nodes1[u].append((v, a))
nodes1[v].append((u, a))
nodes2[u].append((v, b))
nodes2[v].append((u, b))
res1 = dijkstra(N, nodes1, s)
res2 = dijkstra(N, nodes2, t)
A = [0] * N
for i in range(N):
# sからiまで円、iからtまでスヌークで行く
A[i] = res1[i] + res2[i]
# 最後のが使える両替所が少ないので、後ろから累積minする
ans = list(accumulate(A[::-1], min))[::-1]
total = 10 ** 15
[print(total-a) for a in ans]
| p03305 |
import heapq
n,m,s,t = list(map(int,input().split()))
edgeY = [[] for _ in range(n)]
edgeS = [[] for _ in range(n)]
for i in range(m):
u,v,a,b = list(map(int,input().split()))
edgeY[u-1].append([a, v-1])
edgeY[v-1].append([a, u-1])
edgeS[u-1].append([b, v-1])
edgeS[v-1].append([b, u-1])
costY = [float('inf')]*n
costS = [float('inf')]*n
costY[s-1] = 0
costS[t-1] = 0
# 円の時
q = []
for i in edgeY[s-1]:
heapq.heappush(q, i)
while len(q):
nowEdge = heapq.heappop(q)
if costY[nowEdge[1]] == float('inf'):
costY[nowEdge[1]] = nowEdge[0]
for i in edgeY[nowEdge[1]]:
heapq.heappush(q , [i[0]+costY[nowEdge[1]], i[1]])
# スヌークの時
q = []
for i in edgeS[t-1]:
heapq.heappush(q, i)
while len(q):
nowEdge = heapq.heappop(q)
if costS[nowEdge[1]] == float('inf'):
costS[nowEdge[1]] = nowEdge[0]
for i in edgeS[nowEdge[1]]:
heapq.heappush(q , [i[0]+costS[nowEdge[1]], i[1]])
cost = []
ans = []
first = 10**15
minCost = 10**15
for i in range(n-1,-1,-1):
nowCost = costY[i]+costS[i]
if minCost > nowCost:
minCost = nowCost
ans.append(minCost)
for i in range(n-1,-1,-1):
print((first- ans[i])) | import heapq
n,m,s,t = list(map(int,input().split()))
edgeY = [[] for _ in range(n)]
edgeS = [[] for _ in range(n)]
for i in range(m):
u,v,a,b = list(map(int,input().split()))
edgeY[u-1].append((a, v-1))
edgeY[v-1].append((a, u-1))
edgeS[u-1].append((b, v-1))
edgeS[v-1].append((b, u-1))
costY = [float('inf')]*n
costS = [float('inf')]*n
costY[s-1] = 0
costS[t-1] = 0
# 円の時
q = []
for i in edgeY[s-1]:
heapq.heappush(q, i)
while len(q):
nowEdge = heapq.heappop(q)
if costY[nowEdge[1]] == float('inf'):
costY[nowEdge[1]] = nowEdge[0]
for i in edgeY[nowEdge[1]]:
heapq.heappush(q , (i[0]+costY[nowEdge[1]], i[1]))
# スヌークの時
q = []
for i in edgeS[t-1]:
heapq.heappush(q, i)
while len(q):
nowEdge = heapq.heappop(q)
if costS[nowEdge[1]] == float('inf'):
costS[nowEdge[1]] = nowEdge[0]
for i in edgeS[nowEdge[1]]:
heapq.heappush(q , (i[0]+costS[nowEdge[1]], i[1]))
cost = []
ans = []
first = 10**15
minCost = 10**15
for i in range(n-1,-1,-1):
nowCost = costY[i]+costS[i]
if minCost > nowCost:
minCost = nowCost
ans.append(minCost)
for i in range(n-1,-1,-1):
print((first- ans[i])) | p03305 |
# -*- coding: utf-8 -*-
import heapq
n,m,s,t = list(map(int, input().split()))
e = [[] for _ in range(n+1)]
for _ in range(m):
v,u,a,b = list(map(int, input().split()))
e[v].append((u,(a,b)))
e[u].append((v,(a,b)))
inf = 10**18
def dijkstra(s,cu):
d = [inf]*(n+1)
d[s] = 0
q = [s]
heapq.heapify([q])
while len(q)>0:
v = heapq.heappop(q)
for u,ud in e[v]:
if d[v]+ud[cu]>=d[u]:
continue
d[u] = d[v] + ud[cu]
heapq.heappush(q, u)
return d
da = dijkstra(s,0)
db = dijkstra(t,1)
res = [0]*n
res[n-1] = da[n]+db[n]
for i in range(n-2,-1,-1):
res[i] = min(res[i+1], da[i+1]+db[i+1])
for r in res:
print((10**15 - r)) | # -*- coding: utf-8 -*-
import heapq
n,m,s,t = list(map(int, input().split()))
e = [[] for _ in range(n+1)]
for _ in range(m):
v,u,a,b = list(map(int, input().split()))
e[v].append((u,(a,b)))
e[u].append((v,(a,b)))
inf = 10**18
def dijkstra(s,cu):
d = [inf]*(n+1)
d[s] = 0
q = [(d[s],s)]
heapq.heapify([q])
while len(q)>0:
_,v = heapq.heappop(q)
for u,ud in e[v]:
if d[v]+ud[cu]>=d[u]:
continue
d[u] = d[v] + ud[cu]
heapq.heappush(q, (d[u],u))
return d
da = dijkstra(s,0)
db = dijkstra(t,1)
res = [0]*n
res[n-1] = da[n]+db[n]
for i in range(n-2,-1,-1):
res[i] = min(res[i+1], da[i+1]+db[i+1])
for r in res:
print((10**15 - r)) | p03305 |
import heapq
n,m,s,t=list(map(int,input().split()))
src = [ tuple( map( int, input().split() ) ) for i in range(m)]
nl=[ [ ] for j in range(n+1) ]
for u,v,a,b in src:
nl[u].append( (v,a,b) )
nl[v].append( (u,a,b) )
def dij(v,type):
d=[ float("inf")]*(n+1)
d[v]=0
Q=[]
heapq.heappush(Q,v)
while Q:
u=heapq.heappop(Q)
for i in nl[u]:
v=i[0]
yen=i[1]
sunuku=i[2]
if type=="y":alt=d[u]+yen
elif type=="s":alt=d[u]+sunuku
if d[v]> alt:
d[v]=alt
heapq.heappush(Q,v)
return d
d_y=dij(s,"y")
d_s=dij(t,"s")
val=float("inf")
A=[]
for i in range(n,0,-1):
tmp=d_y[i]+d_s[i]
val=min(val, tmp)
A.append(val)
for i in reversed(A):
print(10**15-i) | import heapq
N,M,S,T = list(map(int,input().split()))
S,T = S-1,T-1
src = [tuple(map(int,input().split())) for i in range(M)]
es = [[] for i in range(N)]
for u,v,a,b in src:
u,v = u-1,v-1
es[u].append((v,a,b))
es[v].append((u,a,b))
INF = float('inf')
cy = [INF] * N
cy[S] = 0
hq = [(0,S)]
heapq.heapify(hq)
while hq:
cost,v = heapq.heappop(hq)
for to,a,b in es[v]:
if cost + a >= cy[to]: continue
cy[to] = cost + a
heapq.heappush(hq, (cy[to],to))
cs = [INF] * N
cs[T] = 0
hq = [(0,T)]
heapq.heapify(hq)
while hq:
cost,v = heapq.heappop(hq)
for to,a,b in es[v]:
if cost + b >= cs[to]: continue
cs[to] = cost + b
heapq.heappush(hq, (cs[to],to))
ans = [INF]
for i in reversed(list(range(N))):
tmp = cs[i] + cy[i]
ans.append(min(ans[-1],tmp))
for a in reversed(ans[1:]):
print((10**15 - a)) | p03305 |
import heapq
n,m,s,t=list(map(int,input().split()))
src = [ tuple( map( int, input().split() ) ) for i in range(m)]
nl=[ [ ] for j in range(n+1) ]
for u,v,a,b in src:
nl[u].append( (v,a,b) )
nl[v].append( (u,a,b) )
#Dijkstra yen
d_y=[ float("inf") ]*(n+1)
d_y[s]=0
Q=[]
heapq.heappush(Q,s)
while Q:
u=heapq.heappop(Q)
for v,yen,snuuk in nl[u]:
alt=d_y[u]+yen
if d_y[v]> alt:
d_y[v]=alt
heapq.heappush(Q,v)
#Dijkstra snuuk
d_s=[ float("inf")]*(n+1)
d_s[t]=0
Q=[]
heapq.heappush(Q,t)
while Q:
u=heapq.heappop(Q)
for v,yen,snuuk in nl[u]:
alt=d_s[u]+snuuk
if d_s[v]> alt:
d_s[v]=alt
heapq.heappush(Q,v)
val=float("inf")
A=[]
for i in range(n,0,-1):
tmp=d_y[i]+d_s[i]
val=min(val, tmp)
A.append(val)
for i in reversed(A):
print(10**15-i) | import heapq
n,m,s,t=list(map(int,input().split()))
src = [ tuple( map( int, input().split() ) ) for i in range(m)]
nl=[ [ ] for j in range(n+1) ]
for u,v,a,b in src:
nl[u].append( (v,a,b) )
nl[v].append( (u,a,b) )
#Dijkstra yen
d_y=[ float("inf") ]*(n+1)
d_y[s]=0
Q=[]
heapq.heappush(Q, (0,s) )
while Q:
cost, u=heapq.heappop(Q)
for v,yen,snuuk in nl[u]:
if d_y[v] > cost+yen:
d_y[v]=cost+yen
heapq.heappush(Q, (d_y[v], v) )
#Dijkstra snuuk
d_s=[ float("inf")]*(n+1)
d_s[t]=0
Q=[]
heapq.heappush(Q,(0,t) )
while Q:
cost, u=heapq.heappop(Q)
for v,yen,snuuk in nl[u]:
if d_s[v] > cost+snuuk:
d_s[v]=cost+snuuk
heapq.heappush(Q, (d_s[v], v) )
val=float("inf")
A=[]
for i in range(n,0,-1):
tmp=d_y[i]+d_s[i]
val=min(val, tmp)
A.append(val)
for i in reversed(A):
print(10**15-i) | p03305 |
import heapq as hq
#0 input
INF = 10**16
OKANE = 10**15
N, M, S, T = list(map(int, input().split()))
graph_yen = [[] for _ in range(N+1)]
graph_snk = [[] for _ in range(N+1)]
for i in range(M):
u, v, a, b = list(map(int, input().split()))
graph_yen[u].append((v, a))
graph_yen[v].append((u, a))
graph_snk[u].append((v, b))
graph_snk[v].append((u, b))
def dijkstra(st, ryogae, graph):
dist = [INF]*(N+1)
hasVisited = [False]*(N+1)
hasVisited[0] = True
dist[st] = 0
hasVisited[st] = True
# ryogaeをvisitするまで続く
cand_list = []
cr_point = st
while not hasVisited[ryogae]:
# 次の候補をheapに入れる
for neighb in graph[cr_point]:
if not hasVisited[neighb[0]]:
cand_list.append([dist[cr_point]+neighb[1], neighb[0]])
#print("cand_list:{}".format(cand_list))
# 次の候補を確定
hq.heapify(cand_list)
while 1:
next_node = hq.heappop(cand_list)
if not hasVisited[next_node[1]]:
break
#print(next_node)
# distの更新
cr_point = next_node[1]
dist[cr_point] = next_node[0]
hasVisited[cr_point] = True
#print("dist:{}".format(dist))
return dist[ryogae]
min_list = [INF]*(N+1)
for i in range(N-1,-1,-1):
min_after_i = dijkstra(S,i+1,graph_yen) + dijkstra(T,i+1,graph_snk)
min_list[i] = min(min_after_i,min_list[i+1])
for i in range(N):
print((OKANE - min_list[i])) | import heapq
n,m,s,t=list(map(int,input().split()))
s-=1
t-=1
Gyen=[dict() for i in range(n)]
Gsnu=[dict() for i in range(n)]
for i in range(m):
u,v,a,b=list(map(int,input().split()))
u-=1
v-=1
Gyen[u][v]=a
Gyen[v][u]=a
Gsnu[u][v]=b
Gsnu[v][u]=b
def dijkstra(adj, start):
num = n # グラフのノード数
dist = [10**15 for i in range(num)] # 始点から各頂点までの最短距離を格納する
dist[start] = 0
q = [] # プライオリティキュー．各要素は，(startからある頂点vまでの仮の距離, 頂点vのID)からなるタプル
heapq.heappush(q, (0, start)) # 始点をpush
while (len(q) != 0):
prov_cost, src = heapq.heappop(q) # pop
# プライオリティキューに格納されている最短距離が，現在計算できている最短距離より大きければ，distの更新をする必要はない
if dist[src] < prov_cost:
continue
# 他の頂点の探索
for dest in adj[src]:
cost = adj[src][dest]
if dist[dest] > dist[src] + cost:
dist[dest] = dist[src] + cost # distの更新
heapq.heappush(q, (dist[dest], dest)) # キューに新たな仮の距離の情報をpush
return dist
CostYen=dijkstra(Gyen,s)
CostSnu=dijkstra(Gsnu,t)
Cost=[0 for i in range(n)]
for i in range(n):
Cost[i]=CostYen[i]+CostSnu[i]
ans=[0 for i in range(n)]
ans[-1]=Cost[-1]
for i in list(range(n-1))[::-1]:
ans[i]=min(ans[i+1],Cost[i])
for i in range(n):
print((10**15-ans[i])) | p03305 |
import heapq as hq
INF = 10**16
OKANE = 10**15
N, M, S, T = list(map(int, input().split()))
graph_yen = [[] for _ in range(N+1)]
graph_snk = [[] for _ in range(N+1)]
for i in range(M):
u, v, a, b = list(map(int, input().split()))
graph_yen[u].append((a, v))
graph_yen[v].append((a, u))
graph_snk[u].append((b, v))
graph_snk[v].append((b, u))
def dijkstra(st, graph, N):
dist = [INF]*(N+1)
hasVisited = [False]*(N+1)
hasVisited[0] = True
dist[st] = 0
hasVisited[st] = True
# startをpushする
cand_list = []
hq.heappush(cand_list, (0,st))
while len(cand_list) != 0:
nex, node = hq.heappop(cand_list)
if dist[node] < nex:
continue
for nb in graph[node]:
if dist[nb[1]] > nex+nb[0]:
dist[nb[1]] = nex+nb[0]
hq.heappush(cand_list,(dist[nb[1]], nb[1]))
return dist
dist_yen = dijkstra(S,graph_yen, N)
dist_snk = dijkstra(T,graph_snk, N)
del dist_yen[0]
del dist_snk[0]
min_list = [INF]*(N+1)
i = 0
for yen, snk in zip(dist_yen[::-1], dist_snk[::-1]):
i+=1
min_after_i = yen+snk
min_list[i] = min(min_after_i,min_list[i-1])
del min_list[0]
for cost in min_list[::-1]:
print((OKANE - cost)) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from heapq import heappush, heappop
def dijkstra(graph: list, start, INF=float('inf')) -> list:
n = len(graph)
dist = [INF] * n
visited = [False] * n
dist[start] = 0
que = [(0, start)]
while que:
cost, cur = heappop(que)
if visited[cur]:
continue
visited[cur] = True
for nextnode, edgecost in graph[cur]:
nextcost = cost + edgecost
if nextcost < dist[nextnode]:
dist[nextnode] = nextcost
heappush(que, (nextcost, nextnode))
return dist
n, m, s, t = li()
s -= 1
t -= 1
yen_graph = [[] for _ in range(n)]
snk_graph = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = li()
u -= 1
v -= 1
yen_graph[u].append((v, a))
yen_graph[v].append((u, a))
snk_graph[u].append((v, b))
snk_graph[v].append((u, b))
yen_dist = dijkstra(yen_graph, s)
snk_dist = dijkstra(snk_graph, t)
initial = 10**15
ans = [-1]*n
for i in range(n-1, -1, -1):
if i == n-1:
ans[i] = initial - (yen_dist[i] + snk_dist[i])
else:
ans[i] = max(ans[i+1], initial - (yen_dist[i] + snk_dist[i]))
for ansi in ans:
print(ansi) | p03305 |
def dijkstra_heap(n,s,edge):
# 始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n # True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heappush(edgelist, e)
while edgelist:
minedge = 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]]:
heappush(edgelist, [e[0] + d[v], e[1]])
return d
def examD():
N, M, s, t = LI()
edge = defaultdict(list)
edge2 = defaultdict(list)
# edge[i] : iから出る道の[重み,行先]の配列
for i in range(M):
x, y, z1, z2 = list(map(int, input().split()))
x -=1; y -=1
edge[x].append([z1, y])
edge[y].append([z1, x])
edge2[x].append([z2, y])
edge2[y].append([z2, x])
start1 = s-1
start2 = t-1
res1 = dijkstra_heap(N,start1, edge)
res2 = dijkstra_heap(N,start2, edge2)
ans = []
snuke = 10**15
cur = res1[N-1] + res2[N-1]
ans.append(snuke-cur)
for i in range(N-2,-1,-1):
if res1[i] + res2[i]<cur:
cur = res1[i] + res2[i]
ans.append(snuke-cur)
else:
ans.append(snuke-cur)
for v in ans[::-1]:
print(v)
import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')
examD()
| def dijkstra_heap(n,s,edge,k):
# 始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n # True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heappush(edgelist, [e[k],e[2]])
while edgelist:
minedge = 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[2]]:
heappush(edgelist, [e[k] + d[v], e[2]])
return d
def examD():
N, M, s, t = LI()
edge = defaultdict(list)
# edge2 = defaultdict(list)
# edge2 メモリ無駄
for i in range(M):
x, y, z1, z2 = list(map(int, input().split()))
x -=1; y -=1
edge[x].append([z1,z2,y])
edge[y].append([z1,z2,x])
start1 = s-1
start2 = t-1
res1 = dijkstra_heap(N,start1, edge,0)
res2 = dijkstra_heap(N,start2, edge,1)
ans = []
snuke = 10**15
cur = res1[N-1] + res2[N-1]
ans.append(snuke-cur)
for i in range(N-2,-1,-1):
if res1[i] + res2[i]<cur:
cur = res1[i] + res2[i]
ans.append(snuke-cur)
else:
ans.append(snuke-cur)
for v in ans[::-1]:
print(v)
import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')
examD()
| p03305 |
def dijkstra_heap(n,s,edge,k):
# 始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n # True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heappush(edgelist, [e[k],e[2]])
while edgelist:
minedge = 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[2]]:
heappush(edgelist, [e[k] + d[v], e[2]])
return d
def examD():
N, M, s, t = LI()
edge = defaultdict(list)
# edge2 = defaultdict(list)
# edge2 メモリ無駄
for i in range(M):
x, y, z1, z2 = list(map(int, input().split()))
x -=1; y -=1
edge[x].append((z1,z2,y))
edge[y].append((z1,z2,x))
start1 = s-1
start2 = t-1
res1 = dijkstra_heap(N,start1, edge,0)
res2 = dijkstra_heap(N,start2, edge,1)
ans = []
snuke = 10**15
cur = res1[N-1] + res2[N-1]
ans.append(snuke-cur)
for i in range(N-2,-1,-1):
if res1[i] + res2[i]<cur:
cur = res1[i] + res2[i]
ans.append(snuke-cur)
else:
ans.append(snuke-cur)
for v in ans[::-1]:
print(v)
import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')
examD()
| def dijkstra_heap(n,s,edge,k):
# 始点sから各頂点への最短距離
d = [float("inf")] * n
d[s] = 0
edgelist = [s]
while edgelist:
nextedge = []
for i in edgelist:
for j in edge[i]:
next = j[2]
c = j[k]
if d[next] > c + d[i]:
d[next] = c + d[i]
nextedge.append(next)
edgelist = nextedge
return d
def examD():
N, M, s, t = LI()
edge = defaultdict(list)
# edge2 = defaultdict(list)
# edge2 メモリ無駄
for i in range(M):
x, y, z1, z2 = list(map(int, input().split()))
x -=1; y -=1
edge[x].append((z1,z2,y))
edge[y].append((z1,z2,x))
start1 = s-1
start2 = t-1
res1 = dijkstra_heap(N,start1, edge,0)
res2 = dijkstra_heap(N,start2, edge,1)
ans = []
snuke = 10**15
cur = res1[N-1] + res2[N-1]
ans.append(cur)
for i in range(N-2,-1,-1):
if res1[i] + res2[i]<cur:
cur = res1[i] + res2[i]
ans.append(cur)
else:
ans.append(cur)
for v in ans[::-1]:
print((snuke-v))
import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')
examD()
| p03305 |
import sys
input = sys.stdin.buffer.readline
from collections import deque
def main():
N,M,s,t = map(int,input().split())
INF = 10**15
yedge = [[] for _ in range(N)]
sedge = [[] for _ in range(N)]
for _ in range(M):
u,v,a,b = map(int,input().split())
yedge[u-1].append((v-1,a))
yedge[v-1].append((u-1,a))
sedge[u-1].append((v-1,b))
sedge[v-1].append((u-1,b))
def dij(x,z):
q = deque([x])
go = [INF for _ in range(N)]
go[x] = 0
while q:
now = q.pop()
for fol,d in z[now]:
if go[fol] > go[now]+d:
go[fol] = go[now]+d
q.append(fol)
return go
y,s = dij(s-1,yedge),dij(t-1,sedge)
ans = []
u = 0
for i,j in zip(y[::-1],s[::-1]):
u = max(u,INF-i-j)
ans.append(u)
print(*ans[::-1],sep="\n")
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline
import heapq
def main():
N,M,s,t = map(int,input().split())
INF = 10**15
yedge = [[] for _ in range(N)]
sedge = [[] for _ in range(N)]
for _ in range(M):
u,v,a,b = map(int,input().split())
yedge[u-1].append((a,v-1))
yedge[v-1].append((a,u-1))
sedge[u-1].append((b,v-1))
sedge[v-1].append((b,u-1))
def dij(x,z):
q = [(0,x)]
heapq.heapify(q)
go = [INF for _ in range(N)]
go[x] = 0
while q:
d,now = heapq.heappop(q)
if go[now] > d:
continue
for d,fol in z[now]:
if go[fol] > go[now]+d:
go[fol] = go[now]+d
heapq.heappush(q,(go[fol],fol))
return go
y,s = dij(s-1,yedge),dij(t-1,sedge)
ans = []
u = 0
for i,j in zip(y[::-1],s[::-1]):
u = max(u,INF-i-j)
ans.append(u)
print(*ans[::-1],sep="\n")
if __name__ == "__main__":
main()
| p03305 |
from heapq import heappush, heappop
def dijkstra(s, edge):
'''
始点sから各頂点への最短距離を求める
'''
d = [float("inf")] * n
d[s] = 0
used = [False] * n
used[s] = True
edgelist = []
for e in edge[s]:
heappush(edgelist, e)
while edgelist:
cost, v = heappop(edgelist)
if used[v]:
continue
d[v] = cost
used[v] = True
for e in edge[v]:
if not used[e[1]]:
heappush(edgelist, [e[0] + d[v], e[1]])
return d
def segfunc(x, y):
'''
問題に応じて返り値を設定
'''
return min(x, y)
def init(a):
'''
配列aで初期化
'''
for i in range(n):
seg[i+num-1] = a[i]
for i in range(num-2, -1, -1) :
seg[i] = segfunc(seg[2*i+1], seg[2*i+2])
def update(k, x):
'''
a[k]の値をxに更新
'''
k += num - 1
seg[k] = x
while k:
k = (k - 1) // 2
seg[k] = segfunc(seg[k*2+1], seg[k*2+2])
def query(p, q):
'''
[p, q)についてsegfuncを適用したものを返す
'''
if q <= p:
return ide_ele
p += num - 1
q += num - 2
res = ide_ele
while q - p > 1:
if p & 1 == 0:
res = segfunc(res, seg[p])
if q & 1 == 1:
res = segfunc(res, seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = segfunc(res, seg[p])
else:
res = segfunc(res, segfunc(seg[p], seg[q]))
return res
n, m, s, t = list(map(int, input().split()))
e1 = [[] for _ in range(n)]
e2 = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
e1[u-1].append([a, v-1])
e1[v-1].append([a, u-1])
e2[u-1].append([b, v-1])
e2[v-1].append([b, u-1])
d1 = dijkstra(s-1, e1)
d2 = dijkstra(t-1, e2)
dist = [d1[i] + d2[i] for i in range(n)]
num = (2 ** len(bin(n - 1)) - 2)
ide_ele = float('inf')
seg = [ide_ele] * 2 * num
init(dist)
for i in range(n):
print((10 ** 15 - query(i, n))) | from heapq import heappush, heappop
def dijkstra(s, edge):
'''
始点sから各頂点への最短距離を求める
'''
d = [float("inf")] * n
d[s] = 0
used = [False] * n
used[s] = True
edgelist = []
for e in edge[s]:
heappush(edgelist, e)
while edgelist:
cost, v = heappop(edgelist)
if used[v]:
continue
d[v] = cost
used[v] = True
for e in edge[v]:
if not used[e[1]]:
heappush(edgelist, [e[0] + d[v], e[1]])
return d
n, m, s, t = list(map(int, input().split()))
e1 = [[] for _ in range(n)]
e2 = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
e1[u-1].append([a, v-1])
e1[v-1].append([a, u-1])
e2[u-1].append([b, v-1])
e2[v-1].append([b, u-1])
d1 = dijkstra(s-1, e1)
d2 = dijkstra(t-1, e2)
dist = [d1[i] + d2[i] for i in range(n)]
res = [0] * n
min_dist = float('inf')
for i in range(n-1, -1, -1):
min_dist = min(min_dist, dist[i])
res[i] = 10 ** 15 - min_dist
for v in res:
print(v) | p03305 |
import heapq
from collections import defaultdict
def gijkstra(n,E,s=1):
d = [float('inf')]*(n+1)
p = [-1]*(n+1)
hq = [(0,s)]
d[s] = 0
while hq:
u = heapq.heappop(hq)[1]
for v, c in E[u]:
if d[v] > d[u] + c:
d[v], p[v] = d[u]+c, u
heapq.heappush(hq, (d[u]+c, v))
return d, p
n, m, s, t = map(int,input().split())
E1 = defaultdict(set)
E2 = defaultdict(set)
for i in range(m):
u,v,a,b = tuple(map(int,input().split()))
E1[u].add((v,a))
E1[v].add((u,a))
E2[u].add((v,b))
E2[v].add((u,b))
d1, _ = gijkstra(n,E1,s=s)
d2, _ = gijkstra(n,E2,s=t)
d = [d1[-1] + d2[-1],]
for i in range(n-1,0,-1):
d = [min(d[0],d1[i]+d2[i])] + d
[print(10**15-c) for c in d]
| import heapq
from collections import defaultdict
def gijkstra(n,E,s=1):
d = [float('inf')]*(n+1)
p = [-1]*(n+1)
hq = [(0,s)]
d[s] = 0
while hq:
u = heapq.heappop(hq)[1]
for v, c in E[u]:
if d[v] > d[u] + c:
d[v], p[v] = d[u]+c, u
heapq.heappush(hq, (d[u]+c, v))
return d, p
n, m, s, t = map(int,input().split())
E1 = defaultdict(set)
E2 = defaultdict(set)
for i in range(m):
u,v,a,b = tuple(map(int,input().split()))
E1[u].add((v,a))
E1[v].add((u,a))
E2[u].add((v,b))
E2[v].add((u,b))
d1, _ = gijkstra(n,E1,s=s)
d2, _ = gijkstra(n,E2,s=t)
d = [d1[-1] + d2[-1],]
for i in range(n-1,0,-1):
d.append(min(d[-1],d1[i]+d2[i]))
[print(10**15-c) for c in reversed(d)]
| p03305 |
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):
"""
:param s: 始点
:return: 始点から各点までの最短経路
"""
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()))
UVAB = [list(map(int, input().split())) for i in range(M)]
graph1 = Dijkstra()
graph2 = Dijkstra()
for u, v, a, b in UVAB:
graph1.add(u, v, a)
graph2.add(u, v, b)
result_a = graph1.search(S)
result_b = graph2.search(T)
ans_list = [float('inf')]
for i in range(N, 0, -1):
cur = result_a[i] + result_b[i]
if cur > ans_list[-1]:
cur = ans_list[-1]
ans_list.append(cur)
for i in range(len(ans_list[1:])):
print((10**15-ans_list[-(i+1)])) | 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):
"""
:param s: 始点
:return: 始点から各点までの最短経路
"""
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
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()))
UVAB = [list(map(int, input().split())) for i in range(M)]
graph1 = Dijkstra()
graph2 = Dijkstra()
for u, v, a, b in UVAB:
graph1.add(u, v, a)
graph2.add(u, v, b)
result_a = graph1.search(S)
result_b = graph2.search(T)
ans_list = [float('inf')]
for i in range(N, 0, -1):
cur = result_a[i] + result_b[i]
if cur > ans_list[-1]:
cur = ans_list[-1]
ans_list.append(cur)
for i in range(len(ans_list[1:])):
print((10**15-ans_list[-(i+1)]))
| p03305 |
N,M,S,T = map(int,input().split())
S,T = S-1,T-1
UVAB = [tuple(map(int,input().split())) for i in range(M)]
es = [[] for _ in range(N)]
for u,v,a,b in UVAB:
u,v = u-1,v-1
es[u].append((v,a,b))
es[v].append((u,a,b))
import heapq
INF = float('inf')
dy = [INF]*N
dy[S] = 0
hq = [(0,S)]
heapq.heapify(hq)
while hq:
d,v = heapq.heappop(hq)
for to,a,_ in es[v]:
if d+a >= dy[to]: continue
dy[to] = d+a
heapq.heappush(hq, (d+a, to))
ds = [INF]*N
ds[T] = 0
hq = [(0,T)]
heapq.heapify(hq)
while hq:
d,v = heapq.heappop(hq)
for to,_,a in es[v]:
if d+a >= ds[to]: continue
ds[to] = d+a
heapq.heappush(hq, (d+a, to))
ans = []
m = 0
for y,s in reversed(list(zip(dy,ds))):
m = max(m, 10**15-y-s)
ans.append(m)
ans.reverse()
print(*ans, sep='\n')
| N,M,S,T = map(int,input().split())
S,T = S-1,T-1
UVAB = [tuple(map(int,input().split())) for i in range(M)]
es = [[] for _ in range(N)]
for u,v,a,b in UVAB:
u,v = u-1,v-1
es[u].append((v,a,b))
es[v].append((u,a,b))
import heapq
INF = float('inf')
cy = [INF] * N
cy[S] = 0
hq = [(0,S)]
heapq.heapify(hq)
while hq:
c,v = heapq.heappop(hq)
for to,a,_ in es[v]:
if c+a >= cy[to]: continue
cy[to] = c+a
heapq.heappush(hq, (c+a, to))
cs = [INF] * N
cs[T] = 0
hq = [(0,T)]
heapq.heapify(hq)
while hq:
c,v = heapq.heappop(hq)
for to,_,b in es[v]:
if c+b >= cs[to]: continue
cs[to] = c+b
heapq.heappush(hq, (c+b, to))
ans = [-1] * N
minc = INF
for i,(y,s) in reversed(list(enumerate(zip(cy,cs)))):
minc = min(minc, y+s)
ans[i] = 10**15 - minc
print(*ans, sep='\n')
| p03305 |
import heapq
import sys
input = sys.stdin.readline
N, M, S, T = list(map(int, input().split()))
import heapq
class Edge():
""" 重み付き有向辺 """
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
class Dijkstra():
def __init__(self, V):
self.G = [[] for i in range(V+1)]
self._E = 0
self._V = V
def add(self, _from, _to, _cost):
""" 2頂点と、辺のコストを追加"""
self.G[_from].append(Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
""" 始点sから頂点iまでの最短路リスト
"""
que = []
heapq.heapify(que)
d = [float("inf")] * (self._V+1)
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost:
continue
for i in range(len(self.G[v])):
e = self.G[v][i] # vのi個目の隣接辺e
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
graph_snuke = Dijkstra(N)
graph_yen = Dijkstra(N)
for _ in range(M):
u, v, a, b = list(map(int, input().split()))
graph_yen.add(u, v, a)
graph_yen.add(v, u, a)
graph_snuke.add(u, v, b)
graph_snuke.add(v, u, b)
yen = graph_yen.shortest_path(S)
snuke = graph_snuke.shortest_path(T)
minimum_case = [10**15 for i in range(N+1)]
for i in range(N):
minimum_case[1+i] -= (yen[i+1]+snuke[i+1])
for i in range(N-1, -1, -1):
minimum_case[i] = max(minimum_case[i], minimum_case[i+1])
for i in range(1, N+1):
print((minimum_case[i])) | import heapq
import sys
input = sys.stdin.readline
N, M, S, T = list(map(int, input().split()))
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
class Dijkstra():
def __init__(self, V):
self.G = [[] for i in range(V+1)]
self._E = 0
self._V = V
def add(self, _from, _to, _cost):
""" 2頂点と、辺のコストを追加"""
self.G[_from].append(Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
""" 始点sから頂点iまでの最短路リスト
"""
que = []
heapq.heapify(que)
d = [10**15] * (self._V+1)
d[s] = 0
heapq.heappush(que, (0, s)) # 始点の(最短距離, 頂点番号)をヒープに追加
while que:
cost, v = heapq.heappop(que)
if d[v] < cost:
continue
for e in self.G[v]:
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
graph_snuke = Dijkstra(N)
graph_yen = Dijkstra(N)
for _ in range(M):
u, v, a, b = list(map(int, input().split()))
graph_yen.add(u, v, a)
graph_yen.add(v, u, a)
graph_snuke.add(u, v, b)
graph_snuke.add(v, u, b)
yen = graph_yen.shortest_path(S)
snuke = graph_snuke.shortest_path(T)
minimum_case = [10**15 for i in range(N+1)]
for i in range(N):
minimum_case[1+i] -= (yen[i+1]+snuke[i+1])
for i in range(N-1, -1, -1):
minimum_case[i] = max(minimum_case[i], minimum_case[i+1])
for i in range(1, N+1):
print((minimum_case[i])) | p03305 |
import heapq
n, m, s, t = list(map(int, input().split()))
def to_v(i, j):
return 2*i+j
N = 2*n
edges = [[]for _ in range(N)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
u -= 1
v -= 1
edges[to_v(u, 0)].append((a, to_v(v, 0)))
edges[to_v(v, 0)].append((a, to_v(u, 0)))
edges[to_v(u, 1)].append((b, to_v(v, 1)))
edges[to_v(v, 1)].append((b, to_v(u, 1)))
for u in range(n):
edges[to_v(u, 0)].append((0, to_v(u, 1)))
def dijkstra(init_v):
next_v = [(0, init_v)]
INF = 10**18
dist = [INF]*N
dist[init_v] = 0
while next_v:
d, v = heapq.heappop(next_v)
if dist[v] < d:
continue
for d, v2 in edges[v]:
if dist[v2] <= dist[v]+d:
continue
dist[v2] = dist[v]+d
heapq.heappush(next_v, (dist[v2], v2))
return dist
for i in range(n):
if i != 0:
i -= 1
edges[to_v(i, 0)].pop()
dist = dijkstra(to_v(s-1, 0))
print((10**15-dist[to_v(t-1, 1)]))
| import heapq
n, m, s, t = list(map(int, input().split()))
edges_yen = [[]for _ in range(n)]
edges_snuuk = [[]for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
edges_yen[u-1].append((a, v-1))
edges_yen[v-1].append((a, u-1))
edges_snuuk[u-1].append((b, v-1))
edges_snuuk[v-1].append((b, u-1))
def dijkstra(init_v, edges):
next_v = [(0, init_v)]
INF = 10**18
dist = [INF]*n
dist[init_v] = 0
while next_v:
d, v = heapq.heappop(next_v)
if dist[v] < d:
continue
for d, v2 in edges[v]:
if dist[v2] <= dist[v]+d:
continue
dist[v2] = dist[v]+d
heapq.heappush(next_v, (dist[v2], v2))
return dist
dist_yen = dijkstra(s-1, edges_yen)
dist_snuuk = dijkstra(t-1, edges_snuuk)
dist = [x+y for x, y in zip(dist_yen, dist_snuuk)]
ans = []
INF = 10**18
MIN = INF
for x in dist[::-1]:
if x < MIN:
MIN = x
ans.append(MIN)
for x in ans[::-1]:
print((10**15-x)) | p03305 |
import heapq
import sys
input = sys.stdin.readline
def dijkstra(start: int, graph: list) -> list:
"""dijkstra法: 始点startから各頂点への最短距離を求める
重み付きグラフgraphは隣接リストで与えられる
計算量: O(|E|log|V|)
"""
INF = float("inf")
n = len(graph)
distance = [INF] * n
distance[start] = 0
q = [(start, 0)] #q = [(現在地, startからの距離)]
while q:
pos, dist = heapq.heappop(q)
if distance[pos] < dist:
continue
distance[pos] = dist
for next_pos, cost in graph[pos]:
if distance[pos] + cost < distance[next_pos]:
distance[next_pos] = distance[pos] + cost
heapq.heappush(q, (next_pos, distance[next_pos]))
return distance
n, m, s, t = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(m)]
y_graph = [[] for i in range(n)]
s_graph = [[] for i in range(n)]
for u, v, a, b in info:
u -= 1
v -= 1
y_graph[u].append((v, a))
y_graph[v].append((u, a))
s_graph[u].append((v, b))
s_graph[v].append((u, b))
s -= 1
t -= 1
y_cost = dijkstra(s, y_graph)
s_cost = dijkstra(t, s_graph)
ans = [0]*n
for i in range(n):
ans[i] = y_cost[i] + s_cost[i]
for i in range(n-1)[::-1]:
ans[i] = min(ans[i], ans[i+1])
for num in ans:
print((10**15 - num)) | import heapq
import sys
input = sys.stdin.readline
def dijkstra(start: int, graph: list) -> list:
"""dijkstra法: 始点startから各頂点への最短距離を求める
重み付きグラフgraphは隣接リストで与えられる
計算量: O(|E|log|V|)
"""
INF = float("inf")
n = len(graph)
distance = [INF] * n
distance[start] = 0
q = [(0, start)] #q = [(startからの距離, 現在地)]
while q:
dist, pos = heapq.heappop(q)
if distance[pos] < dist:
continue
for next_pos, cost in graph[pos]:
if distance[pos] + cost < distance[next_pos]:
distance[next_pos] = distance[pos] + cost
heapq.heappush(q, (distance[next_pos], next_pos))
return distance
n, m, s, t = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(m)]
y_graph = [[] for i in range(n)]
s_graph = [[] for i in range(n)]
for i in range(m):
u, v, a, b = info[i]
u -= 1
v -= 1
y_graph[u].append((v, a))
y_graph[v].append((u, a))
s_graph[u].append((v, b))
s_graph[v].append((u, b))
s -= 1
t -= 1
y_cost = dijkstra(s, y_graph)
s_cost = dijkstra(t, s_graph)
ans = [0]*n
for i in range(n):
ans[i] = y_cost[i] + s_cost[i]
for i in range(n-1)[::-1]:
ans[i] = min(ans[i], ans[i+1])
for num in ans:
print((10**15 - num)) | p03305 |
from queue import PriorityQueue
from collections import defaultdict
n,m,s,t = map(int,input().split())
s-=1
t-=1
edge_a = defaultdict(set)
edge_b = defaultdict(set)
for i in range(m):
u,v,a,b = map(int, input().split())
u -= 1
v -= 1
edge_a[u].add((v, a))
edge_a[v].add((u, a))
edge_b[u].add((v, b))
edge_b[v].add((u, b))
def djikstra(s,edges):
n = len(edges)
visited = {}
q = PriorityQueue()
while len(visited) != n:
if len(visited) == 0:
next_p = s
visited[s] = 0
else:
while not q.empty():
cost, to_ = q.get()
if to_ not in visited:
visited[to_] = cost
next_p = to_
break
for to_, cost in edges[next_p]:
if cost >= 0 and to_ not in visited:
q.put((visited[next_p] + cost, to_))
return visited
cost_a = djikstra(s,edge_a)
cost_b = djikstra(t, edge_b)
ans = []
for i in range(n)[::-1]:
nokori = 10**15 - cost_a[i] - cost_b[i]
if len(ans) == 0:
ans.append(nokori)
else:
ans.append(max(nokori, ans[-1]))
print(*ans[::-1], sep="\n")
| from heapq import heapify, heappop, heappush
from collections import defaultdict
n,m,s,t = map(int,input().split())
s-=1
t-=1
edge_a = defaultdict(set)
edge_b = defaultdict(set)
for i in range(m):
u,v,a,b = map(int, input().split())
u -= 1
v -= 1
edge_a[u].add((v, a))
edge_a[v].add((u, a))
edge_b[u].add((v, b))
edge_b[v].add((u, b))
def djikstra(s,edges):
n = len(edges)
visited = {}
q = []
while len(visited) != n:
if len(visited) == 0:
next_p = s
visited[s] = 0
else:
while q:
cost, to_ = heappop(q)
if to_ not in visited:
visited[to_] = cost
next_p = to_
break
for to_, cost in edges[next_p]:
if cost >= 0 and to_ not in visited:
heappush(q, (visited[next_p] + cost, to_))
return visited
cost_a = djikstra(s,edge_a)
cost_b = djikstra(t, edge_b)
ans = []
for i in range(n)[::-1]:
nokori = 10**15 - cost_a[i] - cost_b[i]
if len(ans) == 0:
ans.append(nokori)
else:
ans.append(max(nokori, ans[-1]))
print(*ans[::-1], sep="\n")
| p03305 |
from heapq import *
from collections import defaultdict
def Dijkstra(s, V, E):
# https://ja.wikipedia.org/wiki/%E3%83%80%E3%82%A4%E3%82%AF%E3%82%B9%E3%83%88%E3%83%A9%E6%B3%95
d = defaultdict(lambda:10**30)
d[s] = 0
Q = []
for v in V:
heappush(Q, (d[v], v))
while Q:
x, u = heappop(Q)
for v, y in list(E[u].items()):
alt = d[u] + y
if d[v] > alt:
d[v] = alt
heappush(Q, (alt, v))
return d
N, M, S, T = [int(_) for _ in input().split()]
UVAB = [[int(_) for _ in input().split()] for i in range(M)]
Ea = defaultdict(dict)
Eb = defaultdict(dict)
for u, v, a, b in UVAB:
Ea[u][v] = a
Ea[v][u] = a
Eb[u][v] = b
Eb[v][u] = b
V = list(range(1, N + 1))
Da = Dijkstra(S, V, Ea)
Db = Dijkstra(T, V, Eb)
T = [None] * (N + 1)
t = 10**30
for i in range(N, 0, -1):
r = Da[i] + Db[i]
t = min(t, r)
T[i] = t
ST = 10**15
for i in range(1, N + 1):
print((ST-T[i]))
|
from heapq import *
from collections import defaultdict
def Dijkstra(s, N, E):
# https://ja.wikipedia.org/wiki/%E3%83%80%E3%82%A4%E3%82%AF%E3%82%B9%E3%83%88%E3%83%A9%E6%B3%95
d = [10**30] * (N + 1)
d[s] = 0
Q = []
for v in range(1, N + 1):
heappush(Q, (d[v], v))
while Q:
x, u = heappop(Q)
for v, y in list(E[u].items()):
alt = d[u] + y
if d[v] > alt:
d[v] = alt
heappush(Q, (alt, v))
return d
N, M, S, T = [int(_) for _ in input().split()]
UVAB = [[int(_) for _ in input().split()] for i in range(M)]
Ea = defaultdict(dict)
Eb = defaultdict(dict)
for u, v, a, b in UVAB:
Ea[u][v] = a
Ea[v][u] = a
Eb[u][v] = b
Eb[v][u] = b
Da = Dijkstra(S, N, Ea)
Db = Dijkstra(T, N, Eb)
T = [None] * (N + 1)
t = 10**30
for i in range(N, 0, -1):
r = Da[i] + Db[i]
t = min(t, r)
T[i] = t
ST = 10**15
for i in range(1, N + 1):
print((ST-T[i]))
| p03305 |
from collections import defaultdict
from itertools import accumulate
import heapq
n,m,s,t=list(map(int, input().split()))
s-=1
t-=1
yen=[[0 for _ in range(n)] for _ in range(n)]
snk=[[0 for _ in range(n)] for _ in range(n)]
adj=defaultdict(list)
for _ in range(m):
u,v,a,b=list(map(int, input().split()))
u-=1
v-=1
adj[u].append(v)
adj[v].append(u)
yen[u][v]=a
yen[v][u]=a
snk[u][v]=b
snk[v][u]=b
def dijkstra(s, t, cost):
q=[]
d=[float('inf')]*n
d[s]=0
heapq.heappush(q, (d[s], s))
while q!=[]:
du, u=heapq.heappop(q)
if du>d[u]:
continue
for v in adj[u]:
tmp=du+cost[u][v]
if d[v]>tmp:
d[v]=tmp
heapq.heappush(q, (d[v], v))
return d
d1=dijkstra(s, t, yen)
d2=dijkstra(t, s, snk)
snuke=[]
for d1i, d2i in zip(d1,d2):
snuke.append(d1i+d2i)
ans=list(accumulate(reversed([y+s for y,s in zip(d1, d2)]), min))
for ai in reversed(ans):
print((10**15-ai))
| from collections import defaultdict
from itertools import accumulate
import heapq
n,m,s,t=list(map(int, input().split()))
s-=1
t-=1
yen={}
snk={}
adj=defaultdict(list)
for _ in range(m):
u,v,a,b=list(map(int, input().split()))
u-=1
v-=1
adj[u].append(v)
adj[v].append(u)
yen[u,v]=a
yen[v,u]=a
snk[u,v]=b
snk[v,u]=b
def dijkstra(s, t, cost):
q=[]
d=[float('inf')]*n
d[s]=0
heapq.heappush(q, (d[s], s))
while q!=[]:
du, u=heapq.heappop(q)
if du>d[u]:
continue
for v in adj[u]:
if d[v]>du+cost[u,v]:
d[v]=du+cost[u,v]
heapq.heappush(q, (d[v], v))
return d
d1=dijkstra(s, t, yen)
d2=dijkstra(t, s, snk)
ans=list(accumulate(reversed([y+s for y,s in zip(d1, d2)]), min))
for ai in reversed(ans):
print((10**15-ai))
| p03305 |
from collections import defaultdict
from itertools import accumulate
import heapq
n,m,s,t=list(map(int, input().split()))
s-=1
t-=1
yen={}
snk={}
adj=defaultdict(list)
for _ in range(m):
u,v,a,b=list(map(int, input().split()))
u-=1
v-=1
adj[u].append(v)
adj[v].append(u)
yen[u,v]=a
yen[v,u]=a
snk[u,v]=b
snk[v,u]=b
def dijkstra(s, t, cost):
q=[]
d=[float('inf')]*n
d[s]=0
heapq.heappush(q, (d[s], s))
while q!=[]:
du, u=heapq.heappop(q)
if du>d[u]:
continue
for v in adj[u]:
if d[v]>du+cost[u,v]:
d[v]=du+cost[u,v]
heapq.heappush(q, (d[v], v))
return d
d1=dijkstra(s, t, yen)
d2=dijkstra(t, s, snk)
ans=list(accumulate(reversed([y+s for y,s in zip(d1, d2)]), min))
for ai in reversed(ans):
print((10**15-ai))
| from itertools import accumulate
import heapq
n,m,s,t=list(map(int, input().split()))
s-=1
t-=1
yen=[{} for _ in range(n)]
snk=[{} for _ in range(n)]
for _ in range(m):
u,v,a,b=list(map(int, input().split()))
u-=1
v-=1
yen[u][v]=a
yen[v][u]=a
snk[u][v]=b
snk[v][u]=b
def dijkstra(s, t, g):
q=[]
d=[float('inf')]*n
d[s]=0
heapq.heappush(q, (d[s], s))
while q!=[]:
du, u=heapq.heappop(q)
if du>d[u]:
continue
for v in g[u]:
if d[v]>du+g[u][v]:
d[v]=du+g[u][v]
heapq.heappush(q, (d[v], v))
return d
d1=dijkstra(s, t, yen)
d2=dijkstra(t, s, snk)
ans=list(accumulate(reversed([y+s for y,s in zip(d1, d2)]), min))
for ai in reversed(ans):
print((10**15-ai))
| p03305 |
import heapq
from collections import defaultdict
n, m, s, t = list(map(int, input().split()))
money = defaultdict(set)
snuke = defaultdict(set)
for i in range(m):
a, b, c, d = list(map(int, input().split()))
money[a-1].add((b-1, c))
money[b-1].add((a-1, c))
snuke[a-1].add((b-1, d))
snuke[b-1].add((a-1, d))
def dijkstra(n, v, dedic):
d = [float('inf')] * n
d[v] = 0
hq = [(0, v)]
while hq:
u = heapq.heappop(hq)[1]
for nv, c in dedic[u]:
if d[nv] > d[u] + c:
d[nv] = d[u] + c
heapq.heappush(hq, (d[u] + c, nv))
return d
money_cost = dijkstra(n, s - 1, money)
snuke_cost = dijkstra(n, t - 1, snuke)
result = [10 ** 15 for _ in range(n)]
for i in range(n):
result[i] -= money_cost[i] + snuke_cost[i]
for i in range(n):
print((max(result[i:])))
| import heapq
from collections import defaultdict
n, m, s, t = list(map(int, input().split()))
money = defaultdict(set)
snuke = defaultdict(set)
for i in range(m):
a, b, c, d = list(map(int, input().split()))
money[a-1].add((b-1, c))
money[b-1].add((a-1, c))
snuke[a-1].add((b-1, d))
snuke[b-1].add((a-1, d))
def dijkstra(n, v, dedic):
d = [float('inf')] * n
d[v] = 0
hq = [(0, v)]
while hq:
u = heapq.heappop(hq)[1]
for nv, c in dedic[u]:
if d[nv] > d[u] + c:
d[nv] = d[u] + c
heapq.heappush(hq, (d[u] + c, nv))
return d
money_cost = dijkstra(n, s - 1, money)
snuke_cost = dijkstra(n, t - 1, snuke)
result = [10 ** 15 for _ in range(n)]
temp = 10 ** 15
for i in range(n - 1, -1, -1):
temp = min(money_cost[i] + snuke_cost[i], temp)
result[i] -= temp
for i in range(n):
print((result[i]))
| p03305 |
import sys
input = sys.stdin.buffer.readline
def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getlist():
return list(map(int, input().split()))
import math
import heapq
import fractions
from collections import defaultdict, Counter, deque
MOD = 10**9 + 7
INF = 10**21
def verify(graph, start, n):
h = []
for edge in graph[start]:
heapq.heappush(h, edge)
cost = [INF for i in range(n)]
cost[start] = 0
while(h):
tcost, cur, tgt = heapq.heappop(h)
if cost[cur] + tcost < cost[tgt]:
cost[tgt] = cost[cur] + tcost
for edge in graph[tgt]:
heapq.heappush(h, edge)
return cost
def main():
money = 10 ** 15
n,m,s,t = getlist()
yengraph = [[] for i in range(n)]
snuukgraph = [[] for i in range(n)]
for i in range(m):
a,b,c,d = getlist()
yengraph[a - 1].append((c, a- 1, b - 1))
yengraph[b - 1].append((c, b-1, a - 1))
snuukgraph[a - 1].append((d, a-1, b - 1))
snuukgraph[b - 1].append((d, b-1, a - 1))
ycost = verify(yengraph, s-1, n)
scost = verify(snuukgraph, t-1, n)
sumcost = []
idx = 1
for y, s in zip(ycost, scost):
sumcost.append((y+s, idx))
idx += 1
sumcost.sort()
idx = 0
for i in range(n):
while(True):
ans, cid = sumcost[idx]
if cid > i:
print((money - ans))
break
else:
idx += 1
# print(ycost)
# print(scost)
# print(sumcost)
if __name__ == '__main__':
main()
"""
9999
3
2916
""" | import sys
input = sys.stdin.buffer.readline
def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getlist():
return list(map(int, input().split()))
import math
import heapq
import fractions
from collections import defaultdict, Counter, deque
MOD = 10**9 + 7
INF = 10**21
def dijkstra(graph, start, n):
h = []
heapq.heappush(h, (0, start))
costs = [INF for _ in range(n)]
while h:
cost, cur = heapq.heappop(h)
if costs[cur] != INF:
continue
costs[cur] = cost
for edge in graph[cur]:
ecost, tgt = edge
if costs[tgt] == INF:
heapq.heappush(h, (cost + ecost, tgt))
return costs
def main():
money = 10 ** 15
n, m, s, t = getlist()
s -= 1; t -= 1
yengraph = [[] for _ in range(n)]
snuukgraph = [[] for _ in range(n)]
for i in range(m):
a, b, c, d = getlist()
a -= 1; b -= 1
yengraph[a].append([c, b])
yengraph[b].append([c, a])
snuukgraph[a].append([d, b])
snuukgraph[b].append([d, a])
ycost = dijkstra(yengraph, s, n)
scost = dijkstra(snuukgraph, t, n)
sumcost = []
idx = 1
for y, s in zip(ycost, scost):
sumcost.append((y+s, idx))
idx += 1
sumcost.sort()
idx = 0
for i in range(n):
while True:
ans, cid = sumcost[idx]
if cid > i:
print((money - ans))
break
else:
idx += 1
# print(ycost)
# print(scost)
# print(sumcost)
if __name__ == '__main__':
main()
"""
9999
3
2916
""" | p03305 |
import heapq
from heapq import heapify, heappush, heappop
global G
def input_graph(M, uvab):
global G
for i in range(M):
u, v, a, b = uvab[i]
G[u-1] += [[v-1, (a, b)]]
G[v-1] += [[u-1, (a, b)]]
def dijkstra(N, S, flag):
global G
dist = [float('inf') for _ in range(N)]
dist[S] = 0
Q = [(0, S)]
while Q:
c, v = heappop(Q)
if dist[v] < c:
continue
for t, cost in G[v]:
yen, snuuk = cost
if flag:
if dist[v] + yen < dist[t]:
dist[t] = dist[v] + yen
heappush(Q, (dist[t], t))
else:
if dist[v] + snuuk < dist[t]:
dist[t] = dist[v] + snuuk
heappush(Q, (dist[t], t))
return dist
def main():
global G, dist
N, M, S, T = list(map(int, input().split()))
S -= 1
T -= 1
uvab = [list(map(int, input().split())) for _ in range(M)]
G = [[] for _ in range(N)]
dist = [float('inf') for _ in range(N)]
dist[S] = 0
input_graph(M, uvab)
yen_dist = dijkstra(N, S, True)
snuuk_dist = dijkstra(N, T, False)
dist = [yen_dist[i]+snuuk_dist[i] for i in range(N)]
for i in range(N):
print((10**15-min(dist[i:])))
if __name__ == "__main__":
main() | import heapq
from heapq import heapify, heappush, heappop
global G
def input_graph(M, uvab):
global G
for i in range(M):
u, v, a, b = uvab[i]
G[u-1] += [[v-1, (a, b)]]
G[v-1] += [[u-1, (a, b)]]
def dijkstra(N, S, flag):
global G
dist = [float('inf') for _ in range(N)]
dist[S] = 0
Q = [(0, S)]
while Q:
c, v = heappop(Q)
if dist[v] < c:
continue
for t, cost in G[v]:
yen, snuuk = cost
if flag:
if dist[v] + yen < dist[t]:
dist[t] = dist[v] + yen
heappush(Q, (dist[t], t))
else:
if dist[v] + snuuk < dist[t]:
dist[t] = dist[v] + snuuk
heappush(Q, (dist[t], t))
return dist
def main():
global G, dist
N, M, S, T = list(map(int, input().split()))
S -= 1
T -= 1
uvab = [list(map(int, input().split())) for _ in range(M)]
G = [[] for _ in range(N)]
dist = [float('inf') for _ in range(N)]
dist[S] = 0
input_graph(M, uvab)
yen_dist = dijkstra(N, S, True)
snuuk_dist = dijkstra(N, T, False)
#print(yen_dist)
#print(snuuk_dist)
dist = [yen_dist[i]+snuuk_dist[i] for i in range(N)]
for i in range(N-2, -1, -1):
dist[i] = min(dist[i+1], dist[i])
for i in range(N):
print((10**15-dist[i]))
if __name__ == "__main__":
main()
| p03305 |
import heapq
n, m, s, t = list(map(int, input().split()))
money = 10**15
graph = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
u -= 1
v -= 1
graph[u] += [[v, a, b]]
graph[v] += [[u, a, b]]
def dijkstra(s, y):
dist = [float('inf')]*n
dist[s] = 0
q = [[0, s]]
heapq.heapify(q)
while q:
cost, u = heapq.heappop(q)
for v, yen, snuuk in graph[u]:
if y:
if dist[u] + yen < dist[v]:
dist[v] = dist[u] + yen
heapq.heappush(q, [dist[v], v])
else:
if dist[u] + snuuk < dist[v]:
dist[v] = dist[u] + snuuk
heapq.heappush(q, [dist[v], v])
return dist
y_result = dijkstra(s-1, True)
s_result = dijkstra(t-1, False)
result = [y_result[i]+s_result[i] for i in range(n)]
for i in range(n):
print((money-min(result[i:])))
|
import heapq
n, m, s, t = list(map(int, input().split()))
money = 10**15
graph = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
u -= 1
v -= 1
graph[u] += [[v, a, b]]
graph[v] += [[u, a, b]]
def dijkstra(s, y):
dist = [float('inf')]*n
dist[s] = 0
q = [[0, s]]
heapq.heapify(q)
while q:
cost, u = heapq.heappop(q)
for v, yen, snuuk in graph[u]:
if y:
if dist[u] + yen < dist[v]:
dist[v] = dist[u] + yen
heapq.heappush(q, [dist[v], v])
else:
if dist[u] + snuuk < dist[v]:
dist[v] = dist[u] + snuuk
heapq.heappush(q, [dist[v], v])
return dist
y_result = dijkstra(s-1, True)
s_result = dijkstra(t-1, False)
result = [y_result[i]+s_result[i] for i in range(n)]
for i in range(n-1, 0, -1):
result[i-1] = min(result[i], result[i-1])
for i in range(n):
print((money-result[i]))
| p03305 |
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
N, M, S, T = [int(_) for _ in input().split()]
UVAB = [[int(_) for _ in input().split()] for _ in range(M)]
G1 = collections.defaultdict(lambda: collections.defaultdict(int))
G2 = collections.defaultdict(lambda: collections.defaultdict(int))
for u, v, a, b in UVAB:
u -= 1
v -= 1
G1[u][v] = G1[v][u] = a
G2[u][v] = G2[v][u] = b
def dijkstra(V, G, i):
INF = float('inf')
H = []
d = 0
D = [INF] * V
D[i] = 0
used = [False] * V
used[i] = True
while True:
for j in G[i].keys():
heapq.heappush(H, (d + G[i][j], j))
v = -1
while H:
d, j = heapq.heappop(H)
if not used[j]:
v = j
break
if v == -1:
break
else:
used[v] = True
D[v] = d
i = v
return D
D1 = dijkstra(N, G1, S - 1)
D2 = dijkstra(N, G2, T - 1)
D = [10**15 - sum(_) for _ in zip(D1, D2)]
for i in range(N - 1, 0, -1):
D[i - 1] = max(D[i - 1], D[i])
print(*D, sep='\n')
| import math, string, itertools, fractions, collections, re, array, bisect, sys, random, time, copy, functools
from heapq import heappush, heappop, heappushpop, heapify, heapreplace
input = sys.stdin.readline
N, M, S, T = [int(_) for _ in input().split()]
UVAB = [[int(_) for _ in input().split()] for _ in range(M)]
G1 = collections.defaultdict(lambda: collections.defaultdict(int))
G2 = collections.defaultdict(lambda: collections.defaultdict(int))
for u, v, a, b in UVAB:
u -= 1
v -= 1
G1[u][v] = G1[v][u] = a
G2[u][v] = G2[v][u] = b
def dijkstra(V, G, start):
INF = float('inf')
D = [INF for _ in range(V)]
D[start] = 0
H = [(0, start)]
while H:
du, u = heappop(H)
if D[u] < du:
continue
for v, d in G[u].items():
if D[v] > du + d:
D[v] = du + d
heappush(H, (D[v], v))
return D
D1 = dijkstra(N, G1, S - 1)
D2 = dijkstra(N, G2, T - 1)
D = [10**15 - sum(_) for _ in zip(D1, D2)]
for i in range(N - 1, 0, -1):
D[i - 1] = max(D[i - 1], D[i])
print(*D, sep='\n')
| p03305 |
import math, string, itertools, fractions, collections, re, array, bisect, sys, random, time, copy, functools
from heapq import heappush, heappop, heappushpop, heapify, heapreplace
#input = sys.stdin.readline
N, M, S, T = [int(_) for _ in input().split()]
UVAB = [[int(_) for _ in input().split()] for _ in range(M)]
G1 = collections.defaultdict(lambda: collections.defaultdict(int))
G2 = collections.defaultdict(lambda: collections.defaultdict(int))
for u, v, a, b in UVAB:
u -= 1
v -= 1
G1[u][v] = G1[v][u] = a
G2[u][v] = G2[v][u] = b
def dijkstra(V, G, start):
INF = float('inf')
D = [INF for _ in range(V)]
D[start] = 0
H = [(0, start)]
while H:
du, u = heappop(H)
if D[u] < du:
continue
for v, d in G[u].items():
if D[v] > du + d:
D[v] = du + d
heappush(H, (D[v], v))
return D
D1 = dijkstra(N, G1, S - 1)
D2 = dijkstra(N, G2, T - 1)
D = [10**15 - sum(_) for _ in zip(D1, D2)]
for i in range(N - 1, 0, -1):
D[i - 1] = max(D[i - 1], D[i])
print(*D, sep='\n')
| import math, string, itertools, fractions, collections, re, array, bisect, sys, random, time, copy, functools
from heapq import heappush, heappop, heappushpop, heapify, heapreplace
N, M, S, T = [int(_) for _ in input().split()]
UVAB = [[int(_) for _ in input().split()] for _ in range(M)]
G1 = collections.defaultdict(lambda: collections.defaultdict(int))
G2 = collections.defaultdict(lambda: collections.defaultdict(int))
for u, v, a, b in UVAB:
u -= 1
v -= 1
G1[u][v] = G1[v][u] = a
G2[u][v] = G2[v][u] = b
def dijkstra(V, G, start):
INF = float('inf')
D = [INF for _ in range(V)]
D[start] = 0
H = [(0, start)]
while H:
du, u = heappop(H)
if D[u] < du:
continue
for v, d in G[u].items():
if D[v] > du + d:
D[v] = du + d
heappush(H, (D[v], v))
return D
D1 = dijkstra(N, G1, S - 1)
D2 = dijkstra(N, G2, T - 1)
D = [10**15 - sum(_) for _ in zip(D1, D2)]
for i in range(N - 1, 0, -1):
D[i - 1] = max(D[i - 1], D[i])
print(*D, sep='\n')
| p03305 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
n, m, s, t = list(map(int, input().split()))
graph = [0] + [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
# (cost, dest)
graph[u].append(({'yen': a, 'sunuke': b}, v))
graph[v].append(({'yen': a, 'sunuke': b}, u))
import heapq
def dijkstra(graph, queue, dist, cost_type):
while queue:
d, n = heapq.heappop(queue)
if dist[n] != -1 and dist[n] < d:
continue
for cost, next_n in graph[n]:
cost_with_type = cost[cost_type]
if dist[next_n] > d + cost_with_type:
dist[next_n] = d + cost_with_type
queue.append((dist[next_n], next_n))
queue = [(0, s)]
dist_yen = [10 ** 16] + [10 ** 16] * n
dist_yen[s] = 0
dijkstra(graph, queue, dist_yen, 'yen')
queue = [(0, t)]
dist_sunuke = [10 ** 16] + [10 ** 16] * n
dist_sunuke[t] = 0
dijkstra(graph, queue, dist_sunuke, 'sunuke')
# FYI: https://atcoder.jp/contests/soundhound2018-summer-qual/submissions/10738125
answer = [0] + [0] * n
for i in range(n, 0, -1):
answer[i - 1] = max(answer[i], 10 ** 15 - (dist_yen[i] + dist_sunuke[i]))
for i in range(n):
print((answer[i]))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
n, m, s, t = list(map(int, input().split()))
graph = [0] + [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
# (cost, dest)
graph[u].append(({'yen': a, 'sunuke': b}, v))
graph[v].append(({'yen': a, 'sunuke': b}, u))
import heapq
def dijkstra(graph, queue, dist, cost_type):
while queue:
d, n = heapq.heappop(queue)
if dist[n] != -1 and dist[n] < d:
continue
for cost, next_n in graph[n]:
cost_with_type = cost[cost_type]
if dist[next_n] > d + cost_with_type:
dist[next_n] = d + cost_with_type
heapq.heappush(queue, (dist[next_n], next_n))
queue = [(0, s)]
dist_yen = [10 ** 16] + [10 ** 16] * n
dist_yen[s] = 0
dijkstra(graph, queue, dist_yen, 'yen')
queue = [(0, t)]
dist_sunuke = [10 ** 16] + [10 ** 16] * n
dist_sunuke[t] = 0
dijkstra(graph, queue, dist_sunuke, 'sunuke')
# FYI: https://atcoder.jp/contests/soundhound2018-summer-qual/submissions/10738125
answer = [0] + [0] * n
for i in range(n, 0, -1):
answer[i - 1] = max(answer[i], 10 ** 15 - (dist_yen[i] + dist_sunuke[i]))
for i in range(n):
print((answer[i]))
| p03305 |
n,m,s,t = list(map(int,input().split()))
en = []
su = []
for i in range(m):
x1,y1,z1,a1=[int(i) for i in input().split()]
en.append([x1-1,y1-1,z1])
en.append([y1-1,x1-1,z1])
su.append([x1-1,y1-1,a1])
su.append([y1-1,x1-1,a1])
def shortest_path(edge,num_v,start):
inf = float("inf")
cost = [[inf for i in range(num_v)] for j in range(num_v)]
for e in edge: cost[e[0]][e[1]] = e[2]
used = [False for i in range(num_v)]
d = [inf for j in range(num_v)]
d[start] = 0;
while True:
v = -1
for u in range(num_v):
if (not used[u]) and (v == -1 or d[u] < d[v]):
v = u
if v == -1: break
used[v] = True
for x in range(num_v):
d[x] = d[x] if d[x] < d[v] + cost[v][x] else d[v] + cost[v][x]
return d
from collections import deque
ans = deque([])
tori = shortest_path(en,n,s-1)
kae = shortest_path(su,n,t-1)
sai = float("inf")
for i in range(n-1,-1,-1):
kon = kae[i]+tori[i]
if sai > kon:
ans.appendleft(kon)
sai = kon
else:
ans.appendleft(sai)
moti = 10**15
for i in range(n):
print((moti-ans[i])) | import heapq
n,m,s,t = list(map(int,input().split()))
en = []
su = []
for i in range(m):
x1,y1,z1,a1=[int(i) for i in input().split()]
en.append([x1-1,y1-1,z1])
en.append([y1-1,x1-1,z1])
su.append([x1-1,y1-1,a1])
su.append([y1-1,x1-1,a1])
def shortest_path(edge,num_v,start):
inf = float("inf")
cost = [[inf for i in range(num_v)] for j in range(num_v)]
for e in edge: cost[e[0]][e[1]] = e[2]
d = [inf for j in range(num_v)]
q = []
heapq.heappush(q, (0, start))
d[start] = 0
while len(q) != 0:
prov_cost, src = heapq.heappop(q)
if d[src] < prov_cost:
continue
for dest in range(num_v):
you = cost[src][dest]
if you != float('inf') and d[dest] > d[src] + you:
d[dest] = d[src] + you
heapq.heappush(q, (d[dest], dest))
return d
from collections import deque
ans = deque([])
tori = shortest_path(en,n,s-1)
kae = shortest_path(su,n,t-1)
sai = float("inf")
for i in range(n-1,-1,-1):
kon = kae[i]+tori[i]
if sai > kon:
ans.appendleft(kon)
sai = kon
else:
ans.appendleft(sai)
moti = 10**15
for i in range(n):
print((moti-ans[i])) | p03305 |
import heapq
def dijkstra(adj, start):
# adj: [[to, cost] * vertices], 0th index must be empty
dist = [float('inf')] * len(adj)
dist[start] = 0
q = []
heapq.heappush(q, [0, start])
while q:
min_dist, v_from = heapq.heappop(q)
if min_dist > dist[v_from]:
continue
v_tos = adj[v_from]
for v_to in v_tos:
if min_dist + v_to[1] < dist[v_to[0]]:
dist[v_to[0]] = min_dist + v_to[1]
heapq.heappush(q, [dist[v_to[0]], v_to[0]])
return dist
n, m, start, goal = list(map(int, input().split()))
adj_yen = [[] for _ in range(n+1)]
adj_snuuk = [[] for _ in range(n+1)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
adj_yen[u].append([v, a])
adj_yen[v].append([u, a])
adj_snuuk[u].append([v, b])
adj_snuuk[v].append([u, b])
min_dist_yen = dijkstra(adj_yen, start)
min_dist_snuuk = dijkstra(adj_snuuk, goal)
lose = [float('inf')] * n
for i in range(1, n+1):
lose[-i] = min(lose[-i+1], min_dist_yen[n-i+1] + min_dist_snuuk[n-i+1])
for i in range(n):
print((10 ** 15 - lose[i]))
| import heapq
import sys
input = sys.stdin.readline
def dijkstra(adj, start):
# adj: [[to, cost] * vertices], 0th index must be empty
dist = [float('inf')] * len(adj)
dist[start] = 0
q = []
heapq.heappush(q, [0, start])
while q:
min_dist, v_from = heapq.heappop(q)
if min_dist > dist[v_from]:
continue
v_tos = adj[v_from]
for v_to in v_tos:
if min_dist + v_to[1] < dist[v_to[0]]:
dist[v_to[0]] = min_dist + v_to[1]
heapq.heappush(q, [dist[v_to[0]], v_to[0]])
return dist
n, m, start, goal = list(map(int, input().split()))
adj_yen = [[] for _ in range(n+1)]
adj_snuuk = [[] for _ in range(n+1)]
for _ in range(m):
u, v, a, b = list(map(int, input().split()))
adj_yen[u].append([v, a])
adj_yen[v].append([u, a])
adj_snuuk[u].append([v, b])
adj_snuuk[v].append([u, b])
min_dist_yen = dijkstra(adj_yen, start)
min_dist_snuuk = dijkstra(adj_snuuk, goal)
lose = [float('inf')] * n
for i in range(1, n+1):
lose[-i] = min(lose[-i+1], min_dist_yen[n-i+1] + min_dist_snuuk[n-i+1])
for i in range(n):
print((10 ** 15 - lose[i]))
| p03305 |
n,m,s,t = map(int,input().split())
uvab = [list(map(int,input().split())) for i in range(m)]
gyen = [[] for i in range(n+1)]
gsnu = [[] for i in range(n+1)]
for u,v,a,b in uvab:
gyen[u].append((v,a))
gyen[v].append((u,a))
gsnu[u].append((v,b))
gsnu[v].append((u,b))
import heapq as hq
def dijkstra(start,graph):
dist = [10**18]*(n+1)
dist[start] = 0
q = [(0,start)]
hq.heapify(q)
while q:
_,x = hq.heappop(q)
for y,dd in graph[x]:
if dist[y] > dist[x]+dd:
dist[y] = dist[x]+dd
hq.heappush(q,(dist[y],y))
return dist
distyen = dijkstra(s,gyen)
distsnu = dijkstra(t,gsnu)
ans = []
for i in range(n,0,-1):
x = 10**15-(distyen[i]+distsnu[i])
if i == n:
ans.append(x)
else:
ans.append(max(ans[-1],x))
ans = ans[::-1]
print(*ans,sep="\n")
| import sys
input = sys.stdin.readline
n,m,s,t = map(int,input().split())
uvab = [list(map(int,input().split())) for i in range(m)]
gyen = [[] for i in range(n+1)]
gsnu = [[] for i in range(n+1)]
for u,v,a,b in uvab:
gyen[u].append((v,a))
gyen[v].append((u,a))
gsnu[u].append((v,b))
gsnu[v].append((u,b))
import heapq as hq
def dijkstra(start,graph):
dist = [10**18]*(n+1)
dist[start] = 0
q = [(0,start)]
hq.heapify(q)
while q:
_,x = hq.heappop(q)
for y,dd in graph[x]:
if dist[y] > dist[x]+dd:
dist[y] = dist[x]+dd
hq.heappush(q,(dist[y],y))
return dist
distyen = dijkstra(s,gyen)
distsnu = dijkstra(t,gsnu)
ans = []
for i in range(n,0,-1):
x = 10**15-(distyen[i]+distsnu[i])
if i == n:
ans.append(x)
else:
ans.append(max(ans[-1],x))
ans = ans[::-1]
print(*ans,sep="\n")
| p03305 |
from heapq import heappush, heappop
money = 10**15
N, M, s, t = map(int, input().split())
s -= 1; t -= 1
graph = [[[] for i in range(N)] for _ in range(2)]
for i in range(M):
u, v, a, b = map(int, input().split())
u -= 1; v -= 1
graph[0][u].append((v, a)); graph[0][v].append((u, a))
graph[1][u].append((v, b)); graph[1][v].append((u, b))
def dijkstra(s, mode):
dist = [-1] * N
dist[s] = 0
e = []
for child, cost in graph[mode][s]:
heappush(e, (cost, child))
while e:
cost, node = heappop(e)
if dist[node] >= 0:
continue
dist[node] = cost
for child, c in graph[mode][node]:
if dist[child] >= 0:
continue
heappush(e, (cost+c, child))
return dist
dist = [dijkstra(s, 0), dijkstra(t, 1)]
value = [dist[0][i]+dist[1][i] for i in range(N)]
ans = []
cost = []
for i in range(N-1, -1, -1):
heappush(cost, value[i])
ans.append(money - cost[0])
print(*(ans[::-1]), sep='\n')
| from heapq import heappush, heappop
import sys
input = sys.stdin.readline
money = 10**15
N, M, s, t = map(int, input().split())
s -= 1; t -= 1
graph = [[[] for i in range(N)] for _ in range(2)]
for i in range(M):
u, v, a, b = map(int, input().split())
u -= 1; v -= 1
graph[0][u].append((v, a)); graph[0][v].append((u, a))
graph[1][u].append((v, b)); graph[1][v].append((u, b))
def dijkstra(s, mode):
dist = [-1] * N
dist[s] = 0
e = []
for child, cost in graph[mode][s]:
heappush(e, (cost, child))
while e:
cost, node = heappop(e)
if dist[node] >= 0:
continue
dist[node] = cost
for child, c in graph[mode][node]:
if dist[child] >= 0:
continue
heappush(e, (cost+c, child))
return dist
dist = [dijkstra(s, 0), dijkstra(t, 1)]
value = [dist[0][i]+dist[1][i] for i in range(N)]
ans = []
cost = []
for i in range(N-1, -1, -1):
heappush(cost, value[i])
ans.append(money - cost[0])
print(*(ans[::-1]), sep='\n')
| p03305 |
def main():
import sys
input = sys.stdin.readline
import heapq
n,m,s,t = list(map(int,input().split()))
edgesYen = [[]for _ in range(n+1)]
edgesSnuuk = [[]for _ in range(n+1)]
for _ in range(m):
u,v,a,b = list(map(int,input().split()))
edgesYen[u].append((v,a))
edgesSnuuk[u].append((v,b))
edgesYen[v].append((u,a))
edgesSnuuk[v].append((u,b))
def dijkstra(edges,costDic,startPoint):
que=[(0,startPoint)]
heapq.heapify(que)
while que:
cost,now = heapq.heappop(que)
if now not in costDic:
costDic[now] = cost
for nx,c in edges[now]:
if nx not in costDic:
heapq.heappush(que,(cost+c,nx))
costDicYen = {}
costDicSnuuk = {}
dijkstra(edgesYen,costDicYen,s)
dijkstra(edgesSnuuk,costDicSnuuk,t)
costList = []
for i in range(1,n+1):
cost = costDicYen[i]+costDicSnuuk[i]
costList.append((cost,i))
heapq.heapify(costList)
c,l = heapq.heappop(costList)
for i in range(n):
while l<=i:
c,l = heapq.heappop(costList)
print((10**15-c))
main() | """
前処理として、各地点で両替した場合に最終的に残るスヌークを計算しておく。
これは、s地点から各地点までの円での最小コストと t地点から各地点までのスヌークでの最小コストを計算することで可能である。
次に、各地点で両替した場合に残るスヌークを昇順で保持しておく。
これで前処理は完了。
あとは、小さい順に残スヌークを取り出し、その両替地点の番号がi以下であれば、新しい最小値を取り出し、そうでなければ、その値を出力する。
"""
def main():
import sys
input = sys.stdin.readline
import heapq
n,m,s,t = list(map(int,input().split()))
def dijkstra(edges,costDic,startPoint):
que=[(0,startPoint)]
heapq.heapify(que)
while que:
cost,now = heapq.heappop(que)
if now not in costDic:
costDic[now] = cost
for nx,c in edges[now]:
if nx not in costDic:
heapq.heappush(que,(cost+c,nx))
yenEdges = [[] for _ in range(n+1)]
snuukEdges = [[] for _ in range(n+1)]
for _ in range(m):
u,v,a,b = list(map(int,input().split()))
yenEdges[u].append((v,a))
yenEdges[v].append((u,a))
snuukEdges[u].append((v,b))
snuukEdges[v].append((u,b))
yenDic = {}
snuukDic = {}
dijkstra(yenEdges,yenDic,s)
dijkstra(snuukEdges,snuukDic,t)
remainingSnuuk = []
for i in range(1,n+1):
remainingSnuuk.append((10**15-(yenDic[i]+snuukDic[i]),i))
remainingSnuuk.sort(key=lambda x: x[0], reverse=True)
j = 0
for i in range(n):
while remainingSnuuk[j][1] <= i:
j += 1
print((remainingSnuuk[j][0]))
main() | p03305 |
from heapq import heappop,heappush
def dijkstra(s,n,edge):
"""
始点sから各頂点への最短距離を返す
Parameters
----------
s : int
視点とする頂点（0-indexed）
n : int
グラフの要素数
eage:list
グラグ
Returns
-------
dist ：list
始点sから各頂点への最短距離
"""
dist=[float("inf")]*n
dist[s]=0
used=[-1]*n
hq=[[dist[s],s]]
while hq:
d,cur=heappop(hq)
if dist[cur]<d:continue # 距離が最小でない場合は飛ばす
for nx,nxd in edge[cur]:
if dist[cur]+nxd<dist[nx]:
dist[nx]=dist[cur]+nxd
used[nx]=cur
heappush(hq,[dist[cur]+nxd,nx])
return dist
n,m,s,t=list(map(int,input().split()))
Gs=[[] for i in range(n)]
Gt=[[] for i in range(n)]
for i in range(m):
u,v,a,b=list(map(int,input().split()))
Gs[u-1].append([v-1,a])
Gs[v-1].append([u-1,a])
Gt[u-1].append([v-1,b])
Gt[v-1].append([u-1,b])
s-=1
t-=1
yen=dijkstra(s,n,Gs)
snk=dijkstra(t,n,Gt)
cost=[10**15-(yen[i]+snk[i]) for i in range(n)]
for i in range(n-2,-1,-1):
cost[i]=max(cost[i],cost[i+1])
for c in cost:
print(c)
| import sys
input=sys.stdin.readline
from heapq import heappop,heappush
def dijkstra(s,n,edge):
"""
始点sから各頂点への最短距離を返す
Parameters
----------
s : int
視点とする頂点（0-indexed）
n : int
グラフの要素数
eage:list
グラグ
Returns
-------
dist ：list
始点sから各頂点への最短距離
"""
dist=[float("inf")]*n
dist[s]=0
used=[-1]*n
hq=[[dist[s],s]]
while hq:
d,cur=heappop(hq)
if dist[cur]<d:continue # 距離が最小でない場合は飛ばす
for nx,nxd in edge[cur]:
if dist[cur]+nxd<dist[nx]:
dist[nx]=dist[cur]+nxd
used[nx]=cur
heappush(hq,[dist[cur]+nxd,nx])
return dist
n,m,s,t=list(map(int,input().split()))
Gs=[[] for i in range(n)]
Gt=[[] for i in range(n)]
for i in range(m):
u,v,a,b=list(map(int,input().split()))
Gs[u-1].append([v-1,a])
Gs[v-1].append([u-1,a])
Gt[u-1].append([v-1,b])
Gt[v-1].append([u-1,b])
s-=1
t-=1
yen=dijkstra(s,n,Gs)
snk=dijkstra(t,n,Gt)
cost=[10**15-(yen[i]+snk[i]) for i in range(n)]
for i in range(n-2,-1,-1):
cost[i]=max(cost[i],cost[i+1])
for c in cost:
print(c)
| p03305 |
from heapq import heappush, heappop
inf = float('inf')
mod = 10**9 + 7
class dijkstra:
def __init__(self, to, start):
self.N = len(to)
self.to = [s[:] for s in to]
self.start = start
self.dist = [inf] * self.N
self.dist[start] = 0
self.cnt = [0] * self.N
self.cnt[start] = 1
self.pq = [(self.dist[start], start)]
def update(self) -> None:
while self.pq:
_, v = heappop(self.pq)
for nv, w in self.to[v]:
if self.dist[nv] > self.dist[v] + w:
self.dist[nv] = self.dist[v] + w
heappush(self.pq, (self.dist[nv], nv))
if self.dist[nv] == self.dist[v] + w:
self.cnt[nv] += self.cnt[v]
self.cnt[nv] %= mod
n, m, s, t = list(map(int,input().split()))
s -= 1; t -= 1
jpy = [[] for _ in range(n)]
snuke = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int,input().split()))
u -= 1; v -= 1
jpy[u].append((v, a))
jpy[v].append((u, a))
snuke[u].append((v, b))
snuke[v].append((u, b))
JPY = dijkstra(jpy, s)
JPY.update()
SNUKE = dijkstra(snuke, t)
SNUKE.update()
cost_list = []
cost = inf
for i in range(n)[::-1]:
cost = min(cost, JPY.dist[i] + SNUKE.dist[i])
cost_list.append(cost)
cost_list.reverse()
for cost in cost_list:
ans = pow(10, 15) - cost
print(ans) | from heapq import heappush, heappop
inf = float('inf')
# mod = 10**9 + 7
class dijkstra:
def __init__(self, to, start):
self.N = len(to)
self.to = [s[:] for s in to]
self.start = start
self.dist = [inf] * self.N
self.dist[start] = 0
# self.cnt = [0] * self.N
# self.cnt[start] = 1
self.pq = [(self.dist[start], start)]
def update(self) -> None:
while self.pq:
_, v = heappop(self.pq)
for nv, w in self.to[v]:
if self.dist[nv] > self.dist[v] + w:
self.dist[nv] = self.dist[v] + w
heappush(self.pq, (self.dist[nv], nv))
# if self.dist[nv] == self.dist[v] + w:
# self.cnt[nv] += self.cnt[v]
# self.cnt[nv] %= mod
n, m, s, t = list(map(int,input().split()))
s -= 1; t -= 1
jpy = [[] for _ in range(n)]
snuke = [[] for _ in range(n)]
for _ in range(m):
u, v, a, b = list(map(int,input().split()))
u -= 1; v -= 1
jpy[u].append((v, a))
jpy[v].append((u, a))
snuke[u].append((v, b))
snuke[v].append((u, b))
JPY = dijkstra(jpy, s)
JPY.update()
SNUKE = dijkstra(snuke, t)
SNUKE.update()
cost_list = []
cost = inf
for i in range(n)[::-1]:
cost = min(cost, JPY.dist[i] + SNUKE.dist[i])
cost_list.append(cost)
cost_list.reverse()
for cost in cost_list:
ans = pow(10, 15) - cost
print(ans) | p03305 |
INF = 10 ** 20
def main():
d, n = list(map(int,input().split()))
temp = [int(eval(input())) for i in range(d)]
temp.insert(0,0)
alst = []
blst = []
clst = []
for i in range(n):
a,b,c = list(map(int,input().split()))
alst.append(a)
blst.append(b)
clst.append(c)
dp = [[0] * n for i in range(d + 1)]
t1 = temp[1]
for i in range(n):
if not (alst[i] <= t1 <= blst[i]):
dp[1][i] = -INF
for i in range(2, d + 1):
t = temp[i]
predp = dp[i - 1]
for j in range(n):
cj = clst[j]
if alst[j] <= t <= blst[j]:
dp[i][j] = max(predp[x] + (cj - clst[x] if cj >= clst[x] else clst[x] - cj) for x in range(n))
print((max(dp[d])))
main()
| INF = 10 ** 20
def main():
d, n = list(map(int,input().split()))
temp = [int(eval(input())) for i in range(d)]
temp.insert(0,0)
alst = []
blst = []
clst = []
for i in range(n):
a,b,c = list(map(int,input().split()))
alst.append(a)
blst.append(b)
clst.append(c)
dp = [[0] * n for i in range(d + 1)]
t1 = temp[1]
for i in range(n):
if not (alst[i] <= t1 <= blst[i]):
dp[1][i] = -INF
for i in range(2, d + 1):
t = temp[i]
predp = dp[i - 1]
for j in range(n):
cj = clst[j]
if alst[j] <= t <= blst[j]:
save = 0
for x in range(n):
cx = clst[x]
if cj >= cx:
v = predp[x] + cj - cx
else:
v = predp[x] - cj + cx
if save < v:
save = v
dp[i][j] = save
print((max(dp[d])))
main()
| p00502 |
import sys
from pprint import pprint
s = sys.stdin.readline().strip()
t = sys.stdin.readline().strip()
len_s = len(s)
len_t = len(t)
# print(len_s, len_t)
cand = []
for i in range(0, len_s - len_t + 1):
a = list(s)
flag = True
for j in range(len_t):
# print(s[i+j], t[j])
if s[i+j] == "?":
a[i+j] = t[j]
elif s[i+j] != t[j]:
flag = False
break
if flag:
cand.append(a)
if cand:
print(("".join(cand[-1]).replace("?", "a")))
sys.exit()
else:
print("UNRESTORABLE") | import sys
S = list(sys.stdin.readline().rstrip())
T = list(sys.stdin.readline().rstrip())
len_s = len(S)
len_t = len(T)
for i in range(len_s - len_t, -1, -1):
for j in range(len_t):
if S[i+j] == T[j] or S[i+j] == "?":
continue
else:
break
else:
for k in range(len_t):
S[i+k] = T[k]
print((("".join(S)).replace("?","a")))
exit()
print("UNRESTORABLE") | p03565 |
S = input()[::-1]
T = input()[::-1]
flag = False
for i in range(len(S) - len(T) + 1):
matched = True
for j in range(len(T)):
if S[i + j] != "?" and S[i + j] != T[j]:
matched = False
if matched:
S = S[:i] + T + S[i + len(T):]
flag = True
break
if flag:
print((S.replace("?", "a")[::-1]))
else:
print("UNRESTORABLE") | S = input()[::-1]
T = input()[::-1]
flag = False
for i in range(len(S) - len(T) + 1):
matched = True
for j in range(len(T)):
if S[i + j] != "?" and S[i + j] != T[j]:
matched = False
break
if matched:
S = S[:i] + T + S[i + len(T):]
flag = True
break
if flag:
print((S.replace("?", "a")[::-1]))
else:
print("UNRESTORABLE") | p03565 |
def resolve():
'''
code here
'''
S_dash = input()
T = input()
is_flag = False
res = ''
res_list = ['zzzzz']
for i in range(len(S_dash) - len(T) +1):
res = S_dash[:i]
# print(i, res)
if len(S_dash) - len(res) >= len(T):
for j in range(len(T)):
if S_dash[i+j] == T[j] or S_dash[i+j] == '?':
res += T[j]
else:
# print('bk')
break
else:
is_flag = True
res += S_dash[i+len(T):]
res_list.append(res)
# print(res_list)
res2_list = []
for res in res_list:
res = res.replace('?','a')
res2_list.append(res)
res2_list.sort()
res = res2_list[0]
print(res) if is_flag else print('UNRESTORABLE')
if __name__ == "__main__":
resolve()
| def resolve():
'''
code here
'''
S_dash = input()[::-1]
T = input()[::-1]
is_flag = False
res = ''
for i in range(len(S_dash)):
res = S_dash[:i]
# print(res)
if len(S_dash) - len(res) >= len(T):
for j in range(len(T)):
if S_dash[i+j] == T[j] or S_dash[i+j] == '?':
res += T[j]
else:
# print('bk')
break
else:
is_flag = True
break
# print(res)
# print(S_dash, T, res)
# print(S_dash[len(T):])
res = res + S_dash[len(T)+i:]
res = res.replace('?','a')
print(res[::-1]) if is_flag else print('UNRESTORABLE')
if __name__ == "__main__":
resolve()
| p03565 |
S = input().strip()
T = input().strip()
N = len(S)
K = len(T)
A = list(S)
for i in range(N-K,-1,-1):
a = S[i:i+K]
flag = 0
for j in range(K):
if a[j]!="?" and a[j]!=T[j]:
flag = 1
break
if flag==1:continue
A[i:i+K] = T[:]
for j in range(N):
if A[j]=="?":
A[j]="a"
break
if "?" in A:
print("UNRESTORABLE")
else:
print(("".join(A))) | S1 = list(input().strip())
T = list(input().strip())
n = len(S1)
k = len(T)
G = []
for i in range(n-k+1):
flag = 0
for j in range(i,i+k):
if S1[j]!="?" and S1[j]!=T[j-i]:
flag = 1
break
if flag==0:
A = S1[:]
A[i:i+k] = T[:]
for j in range(n):
if A[j]=="?":
A[j] = "a"
G.append(A)
G = sorted(G)
if len(G)>0:
print(("".join(G[0])))
else:
print("UNRESTORABLE") | p03565 |
S1 = list(input().strip())
T = list(input().strip())
n = len(S1)
k = len(T)
G = []
for i in range(n-k+1):
flag = 0
for j in range(i,i+k):
if S1[j]!="?" and S1[j]!=T[j-i]:
flag = 1
break
if flag==0:
A = S1[:]
A[i:i+k] = T[:]
for j in range(n):
if A[j]=="?":
A[j] = "a"
G.append(A)
G = sorted(G)
if len(G)>0:
print(("".join(G[0])))
else:
print("UNRESTORABLE") | S = input().strip()
N=len(S)
T = input().strip()
M=len(T)
A = []
for i in range(N-M+1):
flag = 0
for j in range(i,i+M):
if S[j]=="?" or S[j]==T[j-i]:continue
else:
flag=1
break
if flag==0:
X = list(S)
for j in range(i,i+M):
X[j] = T[j-i]
for i in range(N):
if X[i]=="?":
X[i]="a"
A.append(X)
if len(A)==0:
print("UNRESTORABLE")
else:
A = sorted(A)
print(("".join(A[0]))) | p03565 |
S = input().strip()
N=len(S)
T = input().strip()
M=len(T)
A = []
for i in range(N-M+1):
flag = 0
for j in range(i,i+M):
if S[j]=="?" or S[j]==T[j-i]:continue
else:
flag=1
break
if flag==0:
X = list(S)
for j in range(i,i+M):
X[j] = T[j-i]
for i in range(N):
if X[i]=="?":
X[i]="a"
A.append(X)
if len(A)==0:
print("UNRESTORABLE")
else:
A = sorted(A)
print(("".join(A[0]))) | S = input().strip()
N = len(S)
T = input().strip()
K = len(T)
flag = 0
ind = -1
for i in range(N-K,-1,-1):
A = list(S[i:i+K])
flag = 0
for j in range(K):
if A[j]!="?" and A[j]!=T[j]:
flag = 1
break
if flag == 0:
ind = i
break
if ind<0:
print("UNRESTORABLE")
else:
S = list(S)
for j in range(K):
if S[ind+j]=="?":
S[ind+j] = T[j]
for i in range(N):
if S[i]=="?":
S[i]="a"
print(("".join(S))) | p03565 |
import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
s = str(readline().rstrip().decode('utf-8'))
t = str(readline().rstrip().decode('utf-8'))
k = len(t)
for i in range(len(s) - k, -1, -1):
ts = s[i:i+k]
b = True
for j in range(k):
if ts[j] != "?" and ts[j] != t[j]:
b = False
break
if b:
a = []
f = True
for j in range(len(s)):
if j < i or i + k <= j:
if s[j] == "?":
a.append("a")
else:
a.append(s[j])
else:
if f:
a = a + list(t)
f = False
print(("".join(a)))
exit()
print("UNRESTORABLE")
if __name__ == '__main__':
solve()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
s = str(readline().rstrip().decode('utf-8'))
t = str(readline().rstrip().decode('utf-8'))
lt = len(t)
for i in range(len(s) - lt, -1, -1):
ts = s[i:i+lt]
b = True
for j in range(len(ts)):
if ts[j] != "?" and ts[j] != t[j]:
b = False
break
if b:
ans = []
for j in range(len(s)):
if i <= j < i + lt:
ans.append(t[j-i])
else:
if s[j] == "?":
ans.append("a")
else:
ans.append(s[j])
print(("".join(ans)))
exit()
print("UNRESTORABLE")
if __name__ == '__main__':
solve()
| p03565 |
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-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 input()
def pf(s): return print(s, flush=True)
def main():
S = input()
# 10文字までしかないので、一個ずつ見ていっても良いのでは
result = 10**10
for i in range(0, len(S) - 2):
r = min(abs(753 - int(S[i:i+3])), abs(int(S[i:i+3]) - 753))
if r < result:
result = r
print(result)
main()
| import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-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 input()
def pf(s): return print(s, flush=True)
def main():
S = input()
# 10文字までしかないので、一個ずつ見ていっても良いのでは
result = 10**10
for i in range(0, len(S) - 2):
result = min(abs(753 - int(S[i:i+3])), result)
print(result)
main()
| p03211 |
# 2019-11-11 16:07:35(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np
like = 753
def main():
S = sys.stdin.readline().rstrip()
min_diff = 642
for i in range(len(S)-2):
x = int(S[i:i+3])
diff = abs(753 - x)
min_diff = min(min_diff, diff)
print(min_diff)
if __name__ == "__main__":
main()
| import sys
target = 753
s = sys.stdin.readline().rstrip()
def main():
d = 642
for i in range(len(s) - 2):
d = min(d, abs(target - int(s[i:i+3])))
return d
if __name__ == '__main__':
ans = main()
print(ans) | p03211 |
def cmb(n, r, mod):#コンビネーションの高速計算
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 998244353
N = 2*10**3
g1 = [1]*(N+1) # 元テーブル
g2 = [1]*(N+1) #逆元テーブル
inverse = [1]*(N+1) #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1[i]=( ( g1[i-1] * i ) % mod )
inverse[i]=( ( -inverse[mod % i] * (mod//i) ) % mod )
g2[i]=( (g2[i-1] * inverse[i]) % mod )
inverse[0]=0
import time
S=input()
N=len(S)
#print(N)
start=time.time()
if N==1:
exit(print(1))
dp=[[[-10**5 for i in range(N+2)] for j in range(N+2)] for k in range(N+1)]
dpf=[[[-10**5 for i in range(N+2)] for j in range(N+2)] for k in range(N+1)]
dpf[0][0][0]=1
if S[0]=="0":
dpf[1][1][0]=0
if S[1]=="0":
dp[1][1][0]=0
if S[0]=="1":
dpf[1][0][1]=0
if S[1]=="1":
dp[1][0][1]=0
dpf[1][0][0]=2
Zero=1-int(S[0])+1-int(S[1])
One=int(S[0])+int(S[1])
for i in range(2,N):
Zero+=1-int(S[i])
One+=int(S[i])
for j in range(Zero+1):
for k in range(One+1):
a,b=1-int(S[i]),int(S[i])
dp[i][j][k]=max(dp[i-1][j-a][k-b]-2,dpf[i-1][j-a][k-b]-1)
a,b=1-int(S[i-1]),int(S[i-1])
if dp[i-2][j-a][k-b]>=0:
dpf[i][j][k]=2*(dp[i-2][j-a][k-b]//2)
if dpf[i-2][j-a][k-b]>=0:
dpf[i][j][k]=max(2*(dpf[i-2][j-a][k-b]//2),dpf[i][j][k])
if dp[i-1][j][k]>=0:
dpf[i][j][k]=max(dp[i-1][j][k]+1-dp[i-1][j][k]%2,dpf[i][j][k])
dpf[i][j][k]=max(dpf[i][j][k],dpf[i-1][j][k]+1)
dpf[i][0][0]=i+1
data=[[[(dp[i][j][k]>=0 or dpf[i][j][k]>=0)&((j,k)!=(0,0)) for k in range(N+1)] for j in range(N+1)] for i in range(N)]
med=time.time()
#print(med-start)
S=[S[-i-1] for i in range(N)]
Zero=0
One=0
ans=1
check=set([])
one,zero=S.count("1"),S.count("0")
for i in range(N):
Zero+=(S[i]=="1")
One+=(S[i]=="0")
for j in range(zero+1):
for k in range(one+1):
if data[N-1-i][j][k]:
check.add((j,k))
ncheck=set([])
for j,k in check:
A,B=1,1
if j!=0:
A=cmb(Zero+j-1,j,mod)
if k!=0:
B=cmb(One+k-1,k,mod)
ans+=A*B
ans%=mod
a,b=1-int(S[i]),int(S[i])
if j>=a and k>=b:
ncheck.add((j-a,k-b))
check=ncheck
zero-=1-int(S[i])
one-=int(S[i])
print(ans)
def check():
res=0
for i in range(N):
for j in range(N+1):
for k in range(N+1) :
if data[i][j][k]:
print(i,j,k)
res+=1
return res
#print(time.time()-start)
| def cmb(n, r, mod):#コンビネーションの高速計算
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 998244353
N = 2*10**3
g1 = [1]*(N+1) # 元テーブル
g2 = [1]*(N+1) #逆元テーブル
inverse = [1]*(N+1) #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1[i]=( ( g1[i-1] * i ) % mod )
inverse[i]=( ( -inverse[mod % i] * (mod//i) ) % mod )
g2[i]=( (g2[i-1] * inverse[i]) % mod )
inverse[0]=0
import time
S=input()
N=len(S)
#print(N)
start=time.time()
if N==1:
exit(print(1))
dp=[[[-10**15 for i in range(N+2)] for j in range(N+2)] for k in range(N+1)]
dpf=[[[-10**15 for i in range(N+2)] for j in range(N+2)] for k in range(N+1)]
dpf[0][0][0]=1
if S[0]=="0":
dp[1][1][0]=0
if S[1]=="0":
dp[1][1][0]=0
if S[0]=="1":
dp[1][0][1]=0
if S[1]=="1":
dp[1][0][1]=0
dpf[1][0][0]=2
Zero=1-int(S[0])+1-int(S[1])
One=int(S[0])+int(S[1])
for i in range(2,N):
Zero+=1-int(S[i])
One+=int(S[i])
for j in range(Zero+1):
for k in range(One+1):
a,b=1-int(S[i]),int(S[i])
dp[i][j][k]=max(dp[i-1][j-a][k-b]-2,dpf[i-1][j-a][k-b]-1)
a,b=1-int(S[i-1]),int(S[i-1])
dpf[i][j][k]=max(dpf[i-1][j][k]+1,dp[i-1][j][k]+1-dp[i-1][j][k]%2)
dp[i][j][k]=max(dp[i][j][k],2*(dpf[i-2][j-a][k-b]//2),2*(dp[i-2][j-a][k-b]//2))
if dp[i][j][k]<0:
dp[i][j][k]=-10**5
if dpf[i][j][k]<0:
dpf[i][j][k]=-10**5
dpf[i][0][0]=i+1
med=time.time()
#print(med-start)
S=[S[-i-1] for i in range(N)]
Zero=0
One=0
ans=1
check=set([])
one,zero=S.count("1"),S.count("0")
for i in range(N):
Zero+=(S[i]=="1")
One+=(S[i]=="0")
for j in range(zero+1):
for k in range(one+1):
if (dp[N-1-i][j][k]>=0 or dpf[N-1-i][j][k]>=0) and (j,k)!=(0,0):
check.add((j,k))
ncheck=set([])
for j,k in check:
A,B=1,1
if j!=0:
A=cmb(Zero+j-1,j,mod)
if k!=0:
B=cmb(One+k-1,k,mod)
ans+=A*B
ans%=mod
a,b=1-int(S[i]),int(S[i])
if j>=a and k>=b:
ncheck.add((j-a,k-b))
check=ncheck
zero-=1-int(S[i])
one-=int(S[i])
print(ans)
def check():
res=0
for i in range(N):
for j in range(N+1):
for k in range(N+1) :
if data[i][j][k]:
print(i,j,k)
res+=1
return res
#print(time.time()-start)
| p02636 |
N, M = list(map(int, input().split()))
Alist = list(map(int, input().split()))
Alist = sorted(Alist, reverse=True)
for i in range(M):
Alist[0] = Alist[0]//2
Alist = sorted(Alist, reverse=True)
print((sum(Alist))) | import heapq
N, M = list(map(int, input().split()))
Alist = list(map(int, input().split()))
q = []
for a in Alist:
heapq.heappush(q, -a)
for i in range(M):
m = heapq.heappop(q)
heapq.heappush(q, -((-m)//2))
print((-sum(q))) | p02912 |
import bisect
def main():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
for i in range(M):
a = A.pop()
a = a // 2
bisect.insort_right(A, a)
# print(A)
x = sum(A)
print(x)
if __name__ == "__main__":
main() | import heapq
def main():
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A = [-1 * i for i in A]
heapq.heapify(A)
for i in range(M):
a = heapq.heappop(A)
a = -1 * (-1 * a // 2)
heapq.heappush(A, a)
x = -1 * sum(A)
print(x)
if __name__ == "__main__":
main() | p02912 |
n,m=list(map(int,input().split()))
l=list(map(int,input().split()))
for i in range(m):
j= l.index(max(l))
l[j] = l[j]//2
print((sum(l)))
| import heapq
n, m = list(map(int, input().split()))
a = list([-int(x) for x in input().split()])
heapq.heapify(a)
for _ in range(m):
tmp = -heapq.heappop(a)
tmp //= 2
heapq.heappush(a,-tmp)
print((-sum(a)))
| p02912 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort(reverse=True)
for i in range(M):
A[A.index(max(A))] //= 2
print((sum(A))) | import heapq
N, M = list(map(int, input().split()))
A = list([int(x)*(-1) for x in input().split()])
heapq.heapify(A)
for _ in range(M):
mn = heapq.heappop(A)
heapq.heappush(A, -mn//2*(-1))
print((-sum(A))) | p02912 |
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A = sorted(A,reverse=True)
for i in range(M):
maxindex = A.index(max(A))
A[maxindex] = A[maxindex]//2
print((sum(A))) | N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
A = list([x*(-1) for x in A])
import heapq
heapq.heapify(A)
for i in range(M):
maxA = (((heapq.heappop(A))*(-1))//2)*(-1)
heapq.heappush(A,maxA)
print((sum(A)*-1))
| p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
for i in range(M):
A=sorted(A)
A[len(A)-1]=A[len(A)-1]//2
print((sum(A))) | N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
while M>0:
A.sort(reverse=True)
if A[0]==0:
break
judge=A[0]//2
for i in range(len(A)):
if A[i]>judge and M>0:
A[i]=A[i]//2
M-=1
else:
break
print((sum(A))) | p02912 |
import math
def max_index(list, max_index):
r = -1
max = -1
for i in range(max_index + 1):
v = list[i]
if v > max:
max = v
r = i
return r
def use_coupon(a, m):
current_index = 0
for _ in range(m):
index = max_index(a, current_index)
a[index] /= 2
current_index += index + 1
if current_index >= len(a):
current_index = len(a)-1
def sum(a):
s = 0
for v in a:
s += math.floor(v)
return s
n, m = list(map(int, input().split(" ")))
a = list(map(int, input().split(" ")))
a.sort(reverse=True)
use_coupon(a, m)
print((sum(a)))
| import math
from heapq import heappush, heappop
def rint(s):
return -int(s)
def sum(a):
s = 0
for v in a:
s += math.floor(-v)
return s
n, m = list(map(int, input().split(" ")))
a = list(map(rint, input().split(" ")))
a.sort()
for i in range(m):
v = heappop(a)
heappush(a, v/2)
print((sum(a)))
| p02912 |
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
list.sort(A, reverse=True)
#print(A)
for m in range(M):
tmp = A[0] / 2
del A[0]
insindex = N
for i in range(len(A)):
if A[i] < tmp:
insindex = i
break
A.insert(insindex, tmp)
for i in range(len(A)):
A[i] = int(A[i])
print((sum(A))) | import heapq
N,M=list(map(int,input().split()))
A=list(map(int,input().split()))
q = []
for x in A:
heapq.heappush(q, -x)
for m in range(M):
x = heapq.heappop(q)
x /= 2
heapq.heappush(q, x)
ans = 0
for x in q:
ans += int(-x)
print(ans) | p02912 |
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
for i in range(m):
x = a.index(max(a))
a[x] //= 2
print((sum(a)))
| import heapq
n, m = list(map(int, input().split()))
a = [int(i) * (-1) for i in input().split()]
heapq.heapify(a)
for i in range(m):
x = heapq.heappop(a) * (-1) // 2
heapq.heappush(a, x * (-1))
print((-sum(a)))
| p02912 |
n,m=list(map(int, input().split()))
a=list(map(int, input().split()))
for i in range(m):
ma=max(a)
a.remove(ma)
a.append(ma//2)
print((sum(a)))
| import heapq
n,m=list(map(int, input().split()))
a=[-int(j) for j in input().split()]
heapq.heapify(a)
for i in range(m):
v=heapq.heappop(a)
heapq.heappush(a, -(-v//2))
print((-sum(a)))
| p02912 |
import math
n,a=list(map(int,input().split()))
list=list(map(int,input().split()))
list.sort()
x=0
for i in range(a):
x = max(list)/2
x=math.floor(x)
list.pop()
list.append(x)
list.sort()
print((sum(list))) | import heapq
N, M = list(map(int,input().split()))
h = []
for i in input().split():
heapq.heappush(h,-int(i))
for i in range(M):
x = -heapq.heappop(h)
x //=2
heapq.heappush(h,-x)
print((-sum(h))) | p02912 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.