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 = ;
 const int INF = ( << ) - ;

 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, , sizeof(visited));
     queue<int> Q;
     Q.push(sink);
     visited[sink] = ;
     d[sink] = ;
     while (!Q.empty()) {
         int u = Q.front();
         Q.pop();
         for ( int i = ;i < G[u].size();i++) {
             Edge &e = edges[G[u][i]^];
             if (!visited[e.from] && e.cap> e.flow) {
                 visited[e.from] = true;
                 d[e.from] = d[u] + ;
                 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]^].flow -= df;
         u = edges[p[u]].from;
     }
     return df;
 }

 int max_flow()
 {
     int flow = ;
     bfs();
     memset(num, , sizeof(num));
     for (int i = ; i < num_nodes; i++) num[d[i]]++;
     int u = source;
     memset(cur, , 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] + ) {
                 advanced = true;
                 p[e.to] = G[u][i];
                 cur[u] = i;
                 u = e.to;
                 break;
             }
         }
         if (!advanced) { // retreat
             int m = num_nodes - ;
             for ( int i = ;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]] == ) break; // gap 优化
             num[d[u] = m+]++;
             cur[u] = ;
             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,});
     edges.push_back((Edge){to,from,,});
     int m = edges.size();
     G[from].push_back(m-);
     G[to].push_back(m-);
 }

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

 int main(){
     int m;
     while(scanf("%d %d ",&m,&num_nodes) != EOF){
         init();
         source = ; sink = num_nodes-;
         for(int i = ;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\n",res);
     }
     return ;
 }

再存一个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 =  << ;
 const int maxn = ;

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

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

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

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

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