POJ 1459 Power Network（最大流入门）

题意：

有一个电力网络，有发电厂，有变压器，又用户，图的意思是容量，以及流量，还有边，以及边的容量，流量。求解用户的最大使用量。

思路：

最大流入门，采用 SAP + GAP优化，模板是采用刘汝佳算法入门经典：训练指南上面的。

 

#include <iostream>

#include <algorithm>

#include <vector>

using namespace std;



structedge {

    int from, to, cap, flow;

    edge(int _from, int _to, int _cap, int _flow)

        : from(_from), to(_to), cap(_cap), flow(_flow) {}

};



const int MAXN = 110;

const int INFS = 0x3fffffff;



vector<edge> edges;

vector<int> G[MAXN];

int p[MAXN], gap[MAXN], dist[MAXN], cur[MAXN];



int augment(int s, int t) {

    int x = t, aug = INFS;

    while (x != s) {

        edge& e = edges[p[x]];

        aug = min(aug, e.cap - e.flow);

        x = edges[p[x]].from;

    }

    x = t;

    while (x != s) {

        edges[p[x]].flow += aug;

        edges[p[x]^1].flow -= aug;

        x = edges[p[x]].from;

    }

    return aug;

}



int sap(int s, int t, int n) {

    int maxflow = 0;



    memset(gap, 0, sizeof(int)*(n+1));

    memset(cur, 0, sizeof(int)*(n+1));

    memset(dist, 0, sizeof(int)*(n+1));



    gap[0] = n;

    int x = s;

    while (dist[s] < n) {

        if (x == t) {

            maxflow += augment(s, t);

            x = s;

        }

        bool flag = false;

        for (int i = cur[x]; i < G[x].size(); i++) {

            edge& e = edges[G[x][i]];

            if (e.cap > e.flow && dist[x] == dist[e.to] + 1) {

                flag = true;

                p[e.to] = G[x][i];

                cur[x] = i;

                x = e.to;

                break;

            }

        }

        if (!flag) {

            int m = n - 1;

            for (int i = 0; i < G[x].size(); i++) {

                edge& e = edges[G[x][i]];

                if (e.cap > e.flow) 

                    m = min(m, dist[e.to]);

            }

            if (--gap[dist[x]] == 0)  break;

            gap[dist[x] = m+1] += 1;

            cur[x] = 0;

            if (x != s) x = edges[p[x]].from;

        }

    }

    return maxflow;

}



void addedge(int u, int v, int cap) {

    edges.push_back(edge(u, v, cap, 0));

    edges.push_back(edge(v, u, 0, 0));

    int m = edges.size();

    G[u].push_back(m - 2);

    G[v].push_back(m - 1);

}



int main() {

    int n, np, nc, m;

    while (scanf("%d", &n) != EOF) {

        scanf("%d%d%d", &np, &nc, &m);

        

        edges.clear();

        for (int i = 0; i <= n+2; i++)

            G[i].clear();



        int u, v, cap;

        for (int i = 0; i < m; i++) {

            scanf(" (%d,%d)%d ", &u, &v, &cap);

            addedge(u + 2, v + 2, cap);

        }

        for (int i = 0; i < np; i++) {

            scanf(" (%d)%d ", &v, &cap);

            addedge(1, v + 2, cap);

        }

        for (int i = 0; i < nc; i++) {

            scanf(" (%d)%d ", &u, &cap);

            addedge(u + 2, n + 2, cap);

        }

        printf("%d\n", sap(1, n + 2, n + 2));

    }

    return 0;

}