最大流模板

这个ISAP模板只能增广一次，在残量网络上跑就会有问题，但是效率不错。

namespace ISAP {
    int tot, n, m, src, tar, qh, qt, cnt;
    ll ans;
    struct edge {
        int vet, next, len;
    } E[LEN * 2];
    int dis[LEN], gap[LEN], head[LEN], cur[LEN], q[LEN], vis[LEN];
    void add(int u, int v, int c) {
        E[++tot] = (edge){v, head[u], c};
        head[u] = tot;
    }
    void join(int u, int v, int c) {
        add(u, v, c);
        add(v, u, 0);
    }
    void bfs(int s) {
        qh = qt = 0; 
        q[++qt] = s;
        dis[s] = 0;
        vis[s] = 1;
        while (qh < qt) {
            int u = q[++qh];
            gap[dis[u]]++;
            for (int e = head[u]; e != -1; e = E[e].next) {
                int v = E[e].vet;
                if (E[e ^ 1].len && !vis[v]) {
                    dis[v] = dis[u] + 1;
                    vis[v] = 1;
                    q[++qt] = v;
                }
            }
        }
    }
    int isap(int u, int aug) {
        if (u == tar) return aug;
        int flow = 0;
        for (int e = head[u]; e != -1; e = E[e].next) {
            int v = E[e].vet;
            if (E[e].len && dis[v] == dis[u] - 1) {
                int tmp = isap(v, min(aug - flow, E[e].len));
                E[e].len -= tmp;
                E[e ^ 1].len += tmp;
                flow += tmp;
                head[u] = e;
                if (flow == aug || dis[src] == cnt) return flow;
            }
        }
        if (!--gap[dis[u]++]) dis[src] = cnt;
        ++gap[dis[u]];
        head[u] = cur[u];
        return flow;
    }
    ll maxflow(int s, int t) {
        ll res = 0;
        src = s, tar = t;
        for (int i = 1; i <= cnt; i++) cur[i] = head[i];
        bfs(tar);
        while (dis[src] < cnt) res += isap(src, oo);
        return res;
    }
    void init() {
        tot = -1, gap[0] = 0;
        for (int i = 1; i <= cnt; i++) {
            vis[i] = gap[i] = dis[i] = 0;
            head[i] = -1;
        }
    }
}

这个DINIC模板可以在残量网络上增广多次。

namespace DINIC {
    int tot, src, tar, n, m, qh, qt, cnt;
    int head[LEN], cur[LEN], dis[LEN], q[LEN];
    struct edge {
        int vet, next, len;
    } E[LEN * 2];
    void add(int u, int v, int c) {
        E[++tot] = (edge){v, head[u], c};
        head[u] = tot;
    }
    void join(int u, int v, int c) {
        add(u, v, c);
        add(v, u, 0);
    }
    void init() {
        tot = -1;
        for (int i = 1; i <= cnt; i++) head[i] = -1;
    }
    bool bfs() {
        for (int i = 1; i <= cnt; i++) dis[i] = 0;
        qh = qt = 0;
        q[++qt] = src;
        dis[src] = 1;
        while (qh < qt) {
            int u = q[++qh];
            for (int e = head[u]; e != -1; e = E[e].next) {
                int v = E[e].vet;
                if (E[e].len && !dis[v]) {
                    dis[v] = dis[u] + 1;
                    if (v == tar) return 1;
                    q[++qt] = v;
                }
            }
        }
        return dis[tar];
    }
    int dfs(int u, int aug) {
        if (u == tar || !aug) return aug;
        int tmp = 0;
        for (int &e = cur[u]; e != -1; e = E[e].next) {
            int v = E[e].vet;
            if (dis[v] == dis[u] + 1) {
                if (tmp = dfs(v, min(aug, E[e].len))) {
                    E[e].len -= tmp;
                    E[e ^ 1].len += tmp;
                    return tmp;
                }
            }
        }
        return 0;
    }
    ll maxflow(int s, int t) {
        src = s, tar = t;
        ll res = 0;
        int flow = 0;
        while (bfs()) {
            for (int i = 1; i <= cnt; i++) cur[i] = head[i];
            while (flow = dfs(src, oo)) res += flow;
        }
        return res;
    }
}