Maximum Flow

class Edge:
    def __init__(self, to: int, rev: int, residual: int) -> None:
        self.to = to
        self.rev = rev
        self.residual = residual

class ResidualNetwork:
    def __init__(self, n: int) -> None:
        if n < 0:
            raise ValueError("vertex count must be non-negative")
        self.adj = [[] for _ in range(n)]

    def add_edge(self, u: int, v: int, capacity: int) -> None:
        if not (0 <= u < len(self.adj) and 0 <= v < len(self.adj)):
            raise IndexError("vertex out of range")
        if u == v:
            raise ValueError("self-loops are not supported")
        if capacity < 0:
            raise ValueError("capacity must be non-negative")
        forward = Edge(v, len(self.adj[v]), capacity)
        reverse = Edge(u, len(self.adj[u]), 0)
        self.adj[u].append(forward)
        self.adj[v].append(reverse)

    def push(self, u: int, edge_index: int, amount: int) -> None:
        edge = self.adj[u][edge_index]
        if amount < 0 or amount > edge.residual:
            raise ValueError("invalid augmentation")
        edge.residual -= amount
        self.adj[edge.to][edge.rev].residual += amount

network = ResidualNetwork(2)
network.add_edge(0, 1, 7)
network.push(0, 0, 3)
assert network.adj[0][0].residual == 4
assert network.adj[1][0].residual == 3

import java.util.ArrayList;
import java.util.List;

public class ResidualNetwork {
    static final class Edge {
        final int to;
        final int rev;
        long residual;

        Edge(int to, int rev, long residual) {
            this.to = to;
            this.rev = rev;
            this.residual = residual;
        }
    }

    private final List<List<Edge>> adj;

    ResidualNetwork(int n) {
        if (n < 0) throw new IllegalArgumentException("negative vertex count");
        adj = new ArrayList<>(n);
        for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
    }

    void addEdge(int u, int v, long capacity) {
        if (u < 0 || u >= adj.size() || v < 0 || v >= adj.size()) {
            throw new IndexOutOfBoundsException("vertex out of range");
        }
        if (u == v) throw new IllegalArgumentException("self-loop");
        if (capacity < 0) throw new IllegalArgumentException("negative capacity");
        Edge forward = new Edge(v, adj.get(v).size(), capacity);
        Edge reverse = new Edge(u, adj.get(u).size(), 0L);
        adj.get(u).add(forward);
        adj.get(v).add(reverse);
    }

    void push(int u, int edgeIndex, long amount) {
        Edge edge = adj.get(u).get(edgeIndex);
        if (amount < 0 || amount > edge.residual) {
            throw new IllegalArgumentException("invalid augmentation");
        }
        edge.residual -= amount;
        adj.get(edge.to).get(edge.rev).residual += amount;
    }

    public static void main(String[] args) {
        ResidualNetwork network = new ResidualNetwork(2);
        network.addEdge(0, 1, 7L);
        network.push(0, 0, 3L);
        assert network.adj.get(0).get(0).residual == 4L;
        assert network.adj.get(1).get(0).residual == 3L;
    }
}