srm537 div13 最小费用最大流

看了很多人讲解的最小费用最大流，但是讲的都太不清楚了，感觉还是这个清楚

http://www.strongczq.com/2012/03/srm537-div1-3-princexdominoes.html

看了一个星期，把其中的各种变量都拆了出来，终于把最小费用最大流的各种细节明白了，

我认为理解这个算法的还是理解剩余网络

#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>
#include <cmath>
#include <map>
#include <algorithm>
#include <list>
#include <ctime>
#include <set>
#include <string.h>
#include <queue>
using namespace std;

int maxData = 0x3fffffff;

int augment(int v, vector<int> pre, int cap, vector<vector<int> > &capacity,
        vector<vector<int> > &residual, vector<vector<int> > cost_graph,
        int& cost) {
    int u = pre[v];
    int r = residual[u][v] > 0 ? 1 : 0;
    int minCap;
    if (r == 0) {
        minCap = min(cap, capacity[u][v]);
    } else {
        minCap = min(cap, residual[u][v]);
    }

    if (u != 0) {
        minCap = augment(u, pre, minCap, capacity, residual, cost_graph, cost);
    }
    if (r == 0) {
        capacity[u][v] -= minCap;
        residual[v][u] += minCap;
    } else {
        capacity[v][u] += minCap;
        residual[u][v] -= minCap;
    }
    cost += (r == 0 ? cost_graph[u][v] : -cost_graph[v][u]) * minCap;
    return minCap;
}

int SPFA(int s, int des, vector<int> &pre, vector<vector<int> > &capacity,
        vector<vector<int> > &residual, vector<vector<int> > cost_graph) {
    int n = capacity.size();
    queue<int> myqueue;
    int i;
    vector<int> d(n, maxData); //将除源点以外的其余点的距离设置为无穷大
    d[s] = 0; //源点的距离为0

    for (i = 0; i < n; ++i) { //初始化前驱
        pre[i] = -1;
    }
    vector<bool> final(n, false); //记录顶点是否在队列中，SPFA算法可以入队列多次

    final[s] = true;
    myqueue.push(s);
    int topint;
    while (!myqueue.empty()) {
        topint = myqueue.front();
        myqueue.pop();
        final[topint] = false;
        for (i = 0; i < n; ++i) {
            if (d[i] > d[topint] + cost_graph[topint][i]
                    && capacity[topint][i] > 0) {
                d[i] = d[topint] + cost_graph[topint][i];
                pre[i] = topint;
                if (!final[i]) { //判断是否在当前的队列中
                    final[i] = true;
                    myqueue.push(i);
                }
            }

            if (d[i] > d[topint] - cost_graph[i][topint]
                    && residual[topint][i] > 0) {
                d[i] = d[topint] - cost_graph[i][topint];
                pre[i] = topint;
                if (!final[i]) { //判断是否在当前的队列中
                    final[i] = true;
                    myqueue.push(i);
                }
            }
        }
    }

    if (pre[des] == -1)
        return -1;
    return 1;
}

int maxFlow(int src, int des, vector<vector<int> > &capacity,
        vector<vector<int> > cost_graph) {

    int increasement = 0; //增广路径的值
    int n = capacity.size();
    vector<vector<int> > residual(n, vector<int>(n, 0)); //剩余网络
    vector<int> pre(n, -1); //标记在这条路径上当前节点的前驱,同时标记该节点是否在队列中
    int cost = 0;
    while ((increasement = SPFA(src, des, pre, capacity, residual, cost_graph))
            != -1) {
        int cap = augment(des, pre, maxData, capacity, residual, cost_graph,cost);
    }

    return cost;
}

class PrinceXDominoes {
public:
    int play(vector<string> dominoes) {
        int n = dominoes.size();
        int total = 0;
        int useless=0;
        vector<vector<int> > path(n + 2, vector<int>(n + 2, 0));
        vector<vector<int> > cost_graph(n + 2, vector<int>(n + 2, 1));
        vector<vector<bool> > connected(n, vector<bool>(n, false));
        vector<int> red_minus_black(n, 0);
        int i, j;
        for (int i = 0; i < n; ++i) {
            connected[i][i] = true;
        }
        for (int i = 0; i < n + 2; ++i) {
            cost_graph[i][i] = 0;
        }
        for (i = 0; i < n; i++) {
            for (j = 0; j < n; j++) {
                if (dominoes[i][j] != '.') {
                    int tmp = dominoes[i][j] - 'A' + 1;
                    path[i + 1][j + 1] = tmp - 1;
                    total = total + tmp;
                    red_minus_black[i] += tmp;
                    red_minus_black[j] -= tmp;
                    connected[i][j] = true;
                }
            }
        }

        for (int k = 0; k < n; ++k)
            for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j) {
                    connected[i][j] = connected[i][j]
                            || (connected[i][k] && connected[k][j]);
                }

        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j)
                if (!connected[i][j]) {
                    return -1;
                }

        for (int i = 0; i < n; ++i) { //初始化src和des点
            if (red_minus_black[i] > 0) {
                path[0][i + 1] = red_minus_black[i];
                useless +=red_minus_black[i];
            } else {
                path[i + 1][n + 1] = -red_minus_black[i];
                useless -=red_minus_black[i];
            }
        }
        int res = maxFlow(0, n + 1, path, cost_graph);
        for(int i=0;i<n+2;i++){
                if(path[0][i]!=0){
                    return -1;
                }
        }

            return total - res+2*useless;
    }

};