HDU3549 最大流 裸题

EK算法 时间复杂度o(n*m*m)  因为有反向边每次bfs时间为 n*m 每次删一条边 最多m次

代码

 #include<iostream>
 #include<string.h>
 #include<vector>
 #include<stdio.h>
 #include<queue>
 using namespace std;
 const int maxn=2e5+,inf=0x3f3f3f3f;
 typedef long long ll;
 struct edge
 {
     int from,to,c,f;
     edge(int u,int v,int c,int f):from(u),to(v),c(c),f(f) {}
 };
 int n,m;
 vector<edge> edges;
 vector<int> g[maxn];
 int a[maxn],p[maxn];
 void init()
 {
     for(int i=; i<=n; i++) g[i].clear();
     edges.clear();
 }
 void addedge(int from,int to,int c)
 {
     edges.push_back(edge(from,to,c,));
     edges.push_back(edge(to,from,,));
     int siz=edges.size();
     g[from].push_back(siz-);
     g[to].push_back(siz-);
 }
 ll maxflow(int s,int t)
 {
     ll flow=;
     while()
     {
         memset(a,,sizeof(a));
         queue<int> q;
         q.push(s);
         a[s]=inf;
         while(!q.empty())
         {
             int x=q.front();
             q.pop();
             //  cout<<x<<" "<<g[x].size()<<endl;
             for(int i=; i<g[x].size(); i++)
             {
                 int u=g[x][i];
                 edge &e=edges[u];
                 //cout<<e.from<<" "<<e.to<<endl;
                 if(!a[e.to]&&e.c>e.f)
                 {
                     p[e.to]=u; //存边
                     a[e.to]=min(a[x],e.c-e.f);
                     q.push(e.to);
                 }
             }
             if(a[t])break;
         }
         // cout<<a[t]<<endl;                   //a[t]为一次增广值
         if(!a[t]) break;
         for(int u=t; u!=s; u=edges[p[u]].from)//流量修改
         {
             edges[p[u]].f+=a[t];
             edges[p[u]^].f-=a[t];
         }
         flow+=(ll)a[t];
     }
     return flow;
 }
 int main()
 {
     int t,u,v,c,f,kase=;
     cin>>t;
     while(t--)
     {
         cin>>n>>m;
         init();
         for(int i=; i<m; i++)
         {
             cin>>u>>v>>c;
             addedge(u-,v-,c);
         }
         printf("Case %d: %d\n",kase++,maxflow(,n-));
         //cout<<maxflow(0,n-1)<<endl;
     }
 }

Dinic  时间复杂度o(n*n*m）最多计算n-1次阻塞流 每次n*m  很松的上界

代码

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn=1e3+,mod=1e9+,inf=0x3f3f3f3f;
 typedef long long ll;
 struct edge
 {
     int from,to,c,f;
     edge(int u,int v,int c,int f):from(u),to(v),c(c),f(f) {}
 };
 int n,m;
 vector<edge> edges;
 vector<int> g[maxn];
 int d[maxn];//从起点到i的距离
 int cur[maxn];//当前弧下标
 void init()
 {
     for(int i=; i<=n; i++) g[i].clear();
     edges.clear();
 }
 void addedge(int from,int to,int c) //加边 支持重边
 {
     edges.push_back(edge(from,to,c,));
     edges.push_back(edge(to,from,,));
     int siz=edges.size();
     g[from].push_back(siz-);
     g[to].push_back(siz-);
 }
 int bfs(int s,int t) //构造一次层次图
 {
     memset(d,-,sizeof(d));
     queue<int> q;
     q.push(s);
     d[s]=;
     while(!q.empty())
     {
         int x=q.front();q.pop();
         for(int i=;i<g[x].size();i++)
         {
             edge &e=edges[g[x][i]];
             if(d[e.to]<&&e.f<e.c) //d[e.to]=-1表示没访问过
             {
                 d[e.to]=d[x]+;
                 q.push(e.to);
             }
         }
     }
     return d[t];
 }
 int dfs(int x,int a,int t) // a表示x点能接收的量
 {
     if(x==t||a==)return a;
     int flow=,f;//flow总的增量 f一条增广路的增量
     for(int &i=cur[x];i<g[x].size();i++)//cur[i] &引用修改其值 从上次考虑的弧
     {
         edge &e=edges[g[x][i]];
         if(d[x]+==d[e.to]&&(f=dfs(e.to,min(a,e.c-e.f),t))>)    //按照层次图增广 满足容量限制
         {
             e.f+=f;
             edges[g[x][i]^].f-=f;  //修改流量
             flow+=f;
             a-=f;
             if(a==) break;
         }
     }
     return flow;
 }
 int maxflow(int s,int t)
 {
     int flow=;
     while(bfs(s,t)!=-) //等于-1代表构造层次图失败 结束
     {
         memset(cur,,sizeof(cur));
         flow+=dfs(s,inf,t);
     }
     return flow;
 }
 int main()
 {
     int t,kase=;
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d%d",&n,&m);
         init();
         int u,v,c,f;
         for(int i=;i<m;i++)
         {
             scanf("%d%d%d",&u,&v,&c);
             addedge(u,v,c);
         }
         printf("Case %d: %d\n",kase++,maxflow(,n));
     }
 }

ISAP  gap优化版  性能比dinic 好一点

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn=1e3+,mod=1e9+,inf=0x3f3f3f3f;
 typedef long long ll;
 struct Edge
 {
     int from,to,cap,flow;
     Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f) {}
 };
 int n,m;
 vector<Edge>edges;
 vector<int>G[maxn];
 int vis[maxn];
 int d[maxn],cur[maxn];
 int p[maxn],num[maxn];//比Dinic算法多了这两个数组，p数组标记父亲结点，num数组标记距离d[i]存在几个
 void init()
 {
     for(int i=; i<=n; i++) G[i].clear();
     edges.clear();
     memset(d,-,sizeof(d));
 }
 void addedge(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-);
 }
 int Augumemt(int s,int t)
 {
     int x=t,a=inf;
     while(x!=s)//找最小的残量值
     {
         Edge&e=edges[p[x]];
         a=min(a,e.cap-e.flow);
         x=edges[p[x]].from;
     }
     x=t;
     while(x!=s)//增广
     {
         edges[p[x]].flow+=a;
         edges[p[x]^].flow-=a;//更新反向边。
         x=edges[p[x]].from;
     }
     return a;
 }
 void bfs(int t)//逆向进行bfs
 {
     memset(vis,,sizeof(vis));
     queue<int>q;
     q.push(t);
     d[t]=;
     vis[t]=;
     while(!q.empty())
     {
         int x=q.front();
         q.pop();
         int len=G[x].size();
         for(int i=; i<len; i++)
         {
             Edge&e=edges[G[x][i]];
             if(!vis[e.from]&&e.cap>e.flow)
             {
                 vis[e.from]=;
                 d[e.from]=d[x]+;
                 q.push(e.from);
             }
         }
     }
 }

 int Maxflow(int s,int t)//根据情况前进或者后退，走到汇点时增广
 {
     int flow=;
     bfs(t);
     memset(num,,sizeof(num));
     for(int i=; i<=n; i++)
         num[d[i]]++;
     int x=s;
     memset(cur,,sizeof(cur));
     while(d[s]<n)
     {
         if(x==t)//走到了汇点，进行增广
         {
             flow+=Augumemt(s,t);
             x=s;//增广后回到源点
         }
         int ok=;
         for(int i=cur[x]; i<G[x].size(); i++)
         {
             Edge& e=edges[G[x][i]];
             if(e.cap>e.flow&&d[x]==d[e.to]+)
             {
                 ok=;
                 p[e.to]=G[x][i];//记录来的时候走的边，即父边
                 cur[x]=i;
                 x=e.to;//前进
                 break;
             }
         }
         if(!ok)//走不动了，撤退
         {
             int m=n-;//如果没有弧，那么m+1就是n，即d[i]=n
             for(int i=; i<G[x].size(); i++)
             {
                 Edge& e=edges[G[x][i]];
                 if(e.cap>e.flow)
                     m=min(m,d[e.to]);
             }
             if(--num[d[x]]==)break;//如果走不动了，且这个距离值原来只有一个，那么s-t不连通，这就是所谓的“gap优化”
             num[d[x]=m+]++;
             cur[x]=;
             if(x!=s)
                 x=edges[p[x]].from;//退一步，沿着父边返回
         }
     }
     return flow;
 }

 int main()
 {
     int t,kase=;
     scanf("%d",&t);
     while(t--)
     {
         init();
         scanf("%d%d",&n,&m);
         for(int i=; i<m; i++)
         {
             int from,to,cap;
             scanf("%d%d%d",&from,&to,&cap);
             addedge(from,to,cap);
         }
         printf("Case %d: %d\n",kase++,Maxflow(,n));
     }
     return ;
 }

ISAP算法 详解及其他版本参见https://blog.csdn.net/guhaiteng/article/details/52433239