hdu 1532 Drainage Ditches 【ISAP 】

还是不是很懂算法

先存一个模板先吧～～～

看的这篇学的--

http://www.renfei.org/blog/isap.html

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;

const int maxn = 1005;
const int INF = (1 << 30) - 1;

struct Edge{
    int from,to,cap,flow;
};

vector<Edge> edges;

int source;         // 源点
int sink;           // 汇点
int p[maxn];   // 可增广路上的上一条弧的编号
int num[maxn]; // 和 t 的最短距离等于 i 的节点数量
int cur[maxn]; // 当前弧下标
int d[maxn];   // 残量网络中节点 i 到汇点 t 的最短距离
bool visited[maxn];

int num_nodes;

vector<int> G[maxn];

// 预处理, 反向 BFS 构造 d 数组
bool bfs()
{
    memset(visited, 0, sizeof(visited));
    queue<int> Q;
    Q.push(sink);
    visited[sink] = 1;
    d[sink] = 0;
    while (!Q.empty()) {
        int u = Q.front();
        Q.pop();
        for ( int i = 0;i < G[u].size();i++) {
            Edge &e = edges[G[u][i]^1];
            if (!visited[e.from] && e.cap> e.flow) {
                visited[e.from] = true;
                d[e.from] = d[u] + 1;
                Q.push(e.from);
            }
        }
    }
    return visited[source];
}

// 增广
int augment()
{
    int u = sink, df = INF;
    // 从汇点到源点通过 p 追踪增广路径, df 为一路上最小的残量
    while (u != source) {
        Edge &e = edges[p[u]];
        df = min(df, e.cap - e.flow);
        u = edges[p[u]].from;
    }
    u = sink;
    // 从汇点到源点更新流量
    while (u != source) {
        edges[p[u]].flow += df;
        edges[p[u]^1].flow -= df;
        u = edges[p[u]].from;
    }
    return df;
}

int max_flow()
{
    int flow = 0;
    bfs();
    memset(num, 0, sizeof(num));
    for (int i = 0; i < num_nodes; i++) num[d[i]]++;
    int u = source;
    memset(cur, 0, sizeof(cur));
    while (d[source] < num_nodes) {
        if (u == sink) {
            flow += augment();
            u = source;
        }
        bool advanced = false;
        for (int i = cur[u]; i < G[u].size(); i++) { 
            Edge& e = edges[G[u][i]];
            if (e.cap > e.flow && d[u] == d[e.to] + 1) {
                advanced = true;
                p[e.to] = G[u][i];
                cur[u] = i;
                u = e.to;
                break;
            }
        }
        if (!advanced) { // retreat
            int m = num_nodes - 1;
            for ( int i = 0;i < G[u].size();i++)
                if (edges[G[u][i]].cap > edges[G[u][i]].flow)
                    m = min(m, d[edges[G[u][i]].to]);
            if (--num[d[u]] == 0) break; // gap 优化
            num[d[u] = m+1]++;
            cur[u] = 0;
            if (u != source)
                u = edges[p[u]].from;
        }
    }
    return flow;
}

void addedges(int from,int to,int cap){
    edges.push_back((Edge){from,to,cap,0});
    edges.push_back((Edge){to,from,0,0});
    int m = edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}

void init(){
    edges.clear();
    for(int i = 0;i < num_nodes;i++) G[i].clear();
}

int main(){
    int m;
    while(scanf("%d %d ",&m,&num_nodes) != EOF){
        init();
        source = 0; sink = num_nodes-1;
        for(int i = 0;i < m;i++){
            int u,v,c;
            scanf("%d %d %d",&u,&v,&c);u--;v--;
            addedges(u,v,c);
        }
        int res = max_flow();
        printf("%d
",res);
    }
    return 0;
}

再存一个dinic的吧～～～

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
#define lp (p << 1)
#define rp (p << 1|1)
#define getmid(l,r) (l + (r - l) / 2)
#define MP(a,b) make_pair(a,b)
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1 << 30;
const int maxn = 210;

int c[maxn][maxn],n,m,lev[maxn];
int st,ed;

void Bfs(){
    memset(lev,-1,sizeof(lev));
    queue<int> Q;
    while(!Q.empty()) Q.pop();
    Q.push(st);
    lev[st] = 0;
    while(!Q.empty()){
        int x = Q.front();Q.pop();
        for(int i = 1; i <= ed; ++i) if(lev[i] < 0 && c[x][i] > 0){
            lev[i] = lev[x] + 1;
            Q.push(i);
        }
    }
}

int Dfs(int p,int minc){
    if(p == ed) return minc;
    for(int i = 1; i <= ed; ++i) if(lev[i] > lev[p] && c[p][i] > 0){
        int d = Dfs(i,min(c[p][i],minc));
        if(d > 0){
            c[p][i] -= d;
            c[i][p] += d;
            return d;
        }
    }
    return 0;
}
        

int Dinic(){
    int max_flow = 0,plus;
    while(1){
        Bfs();
        if(lev[ed] < 0) break;
        while((plus = Dfs(1,INF)) > 0) max_flow += plus;
    }
    return max_flow;
}

int main(){
    while(scanf("%d %d",&m,&n) != EOF){
        st = 1;ed = n;
        memset(c,0,sizeof(c));
        for(int i = 1;i <= m;i++){
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            c[u][v] += w;
        }
        printf("%d
",Dinic());
    }
    return 0;
}