Submission details
Task:Download Speed
Sender:aalto26gh_012
Submission time:2026-10-20 16:48:19 +0300
Language:Python3 (PyPy3)
Status:READY
Result:ACCEPTED
Test results
testverdicttime
#1ACCEPTED0.05 sdetails
#2ACCEPTED0.05 sdetails
#3ACCEPTED0.05 sdetails
#4ACCEPTED0.05 sdetails
#5ACCEPTED0.07 sdetails
#6ACCEPTED0.06 sdetails
#7ACCEPTED0.07 sdetails
#8ACCEPTED0.05 sdetails
#9ACCEPTED0.05 sdetails
#10ACCEPTED0.05 sdetails
#11ACCEPTED0.06 sdetails
#12ACCEPTED0.05 sdetails

Code

import sys
from collections import deque, defaultdict, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product, accumulate, groupby
from functools import lru_cache, cmp_to_key, reduce
from math import gcd, isqrt, comb, inf, pi, sqrt, atan2, hypot


def main():
    data = sys.stdin.buffer.read().split(); idx = 0
    # n = int(data[idx]); idx += 1
    n, m = map(int, data[idx:idx + 2]); idx += 2
    # a = list(map(int, data[idx:idx + n])); idx += n
    # s = data[idx].decode(); idx += 1                  # strings


    edges = [[] for _ in range(n+1)]
    to = []
    cap = []
    for _ in range(m):
        a, b, c = map(int, data[idx:idx + 3]); idx += 3
        edges[a].append(len(to));
        to.append(b)
        cap.append(c)
        edges[b].append(len(to));
        to.append(a)
        cap.append(0)




    out = []
    if n <= 1:
        print("0")
        return

    total = 0
    while True:
        # BFS on the residual graph; pe[v] = edge used to reach v
        fromm = [-1] * (n + 1)
        fromm[1] = -2
        dq = deque([1])
        while dq and fromm[n] == -1:
            u = dq.popleft()
            for e in edges[u]:
                v = to[e]
                if cap[e] > 0 and fromm[v] == -1:
                    fromm[v] = e
                    dq.append(v)
        if fromm[n] == -1:
            break

        # bottleneck: walk back from n to 1
        f = inf
        v = n
        while v != 1:
            e = fromm[v]
            if cap[e] < f:
                f = cap[e]
            v = to[e ^ 1]          # tail of edge e

        # push flow
        v = n
        while v != 1:
            e = fromm[v]
            cap[e] -= f
            cap[e ^ 1] += f
            v = to[e ^ 1]

        total += f

    out = [total]




    sys.stdout.write("\n".join(map(str, out)) + "\n")  # one value per line


main()

Test details

Test 1

Verdict: ACCEPTED

input
4 3
1 2 5
2 3 3
3 4 6

correct output
3

user output
3

Test 2

Verdict: ACCEPTED

input
4 5
1 2 1
1 3 1
2 3 1
2 4 1
...

correct output
2

user output
2

Test 3

Verdict: ACCEPTED

input
4 5
1 2 1000000000
1 3 1000000000
2 3 1
2 4 1000000000
...

correct output
2000000000

user output
2000000000

Test 4

Verdict: ACCEPTED

input
2 1
2 1 100

correct output
0

user output
0

Test 5

Verdict: ACCEPTED

input
2 1000
1 2 1000000000
1 2 1000000000
1 2 1000000000
1 2 1000000000
...

correct output
1000000000000

user output
1000000000000

Test 6

Verdict: ACCEPTED

input
500 998
1 2 54
1 3 59
1 4 83
2 5 79
...

correct output
60

user output
60

Test 7

Verdict: ACCEPTED

input
500 998
1 2 530873053
1 3 156306296
1 4 478040476
3 5 303609600
...

correct output
1093765123

user output
1093765123

Test 8

Verdict: ACCEPTED

input
2 1
1 2 1

correct output
1

user output
1

Test 9

Verdict: ACCEPTED

input
4 5
1 2 3
2 4 2
1 3 4
3 4 5
...

correct output
6

user output
6

Test 10

Verdict: ACCEPTED

input
4 5
1 2 1
1 3 2
3 2 1
2 4 2
...

correct output
3

user output
3

Test 11

Verdict: ACCEPTED

input
10 999
1 2 1000000000
1 2 1000000000
1 2 1000000000
1 2 1000000000
...

correct output
111000000000

user output
111000000000

Test 12

Verdict: ACCEPTED

input
7 9
1 2 1
1 3 1
1 4 1
2 5 1
...

correct output
2

user output
2