最大流可以输出流量版

struct Dinic {
    using ll = long long;
    static constexpr ll INF = (1LL << 60);

    struct Edge {
        int to, rev;
        ll cap;
    };

    struct OriginalEdge {
        int from, index;
        ll capacity;
    };

    int n;
    vector<vector<Edge>> graph;
    vector<OriginalEdge> edges;
    vector<int> level, cur;

    Dinic(int n)
        : n(n),
          graph(n + 1),
          level(n + 1),
          cur(n + 1) {}

    // 返回这条边的编号
    int addEdge(int from, int to, ll cap) {
        int id = edges.size();

        int index = graph[from].size();
        int revIndex = graph[to].size();

        graph[from].push_back({to, revIndex, cap});
        graph[to].push_back({from, index, 0});

        edges.push_back({from, index, cap});
        return id;
    }

    ll getFlow(int id) const {
        const auto &e = edges[id];
        return e.capacity - graph[e.from][e.index].cap;
    }

    ll getCapacity(int id) const {
        return edges[id].capacity;
    }

    bool bfs(int s, int t) {
        fill(level.begin(), level.end(), -1);

        queue<int> q;
        level[s] = 0;
        q.push(s);

        while (!q.empty()) {
            int u = q.front();
            q.pop();

            for (const auto &e : graph[u]) {
                if (e.cap > 0 && level[e.to] == -1) {
                    level[e.to] = level[u] + 1;
                    q.push(e.to);
                }
            }
        }

        return level[t] != -1;
    }

    ll dfs(int u, int t, ll flow) {
        if (u == t) return flow;

        for (int &i = cur[u]; i < (int)graph[u].size(); ++i) {
            Edge &e = graph[u][i];

            if (e.cap <= 0 || level[e.to] != level[u] + 1) {
                continue;
            }

            ll pushed = dfs(e.to, t, min(flow, e.cap));

            if (pushed == 0) continue;

            e.cap -= pushed;
            graph[e.to][e.rev].cap += pushed;
            return pushed;
        }

        return 0;
    }
    ll maxFlow(int s, int t) {
        ll flow = 0;

        while (bfs(s, t)) {
            fill(cur.begin(), cur.end(), 0);

            while (ll pushed = dfs(s, t, INF)) {
                flow += pushed;
            }
        }

        return flow;
    }
};

    // dinic.addEdge(1, 2, 3);
    // dinic.addEdge(1, 3, 2);
    // dinic.addEdge(2, 3, 1);
    // dinic.addEdge(2, 4, 2);
    // dinic.addEdge(3, 4, 3);
// 
    // int id1 = dinic.addEdge(1, 2, 10);
	// int id2 = dinic.addEdge(1, 3, 5);
// 
	// ll maxflow = dinic.maxFlow(1, 4);
	// cout << "edge 1 flow = " << dinic.getFlow(id1) << '\n';
	// cout << "edge 2 flow = " << dinic.getFlow(id2) << '\n';
//