最大流是图论问题中比较具有抽象性和技巧性的题目，一般需要根据题中要求设计出一张符合题中所有约束条件的图，然后直接应用算法模板加以解决。模板可以当黑箱来使用，最关键的是要学会如何找到逻辑关系，找准图像特征，以不变应万变。
模板
一般来说， $\text{Dinic}$ 算法可以解决大部分的问题，如果对时间复杂度有较高要求，则需要使用 $\text{ISAP}$ 算法。
下面是 $\text{Dinic}$ 算法的模板：
1 const int INF=0x3f3f3f3f; 2 const int MAXN=1e5+10; 3 const int MAXM=1e5+10; 4 struct Edge{ 5 int to,next,cap; 6 }edge[MAXM]; 7 int tot,head[MAXN]; 8 inline void init(){ 9 tot=0; 10 memset(head,-1,sizeof(head)); 11 } 12 inline void add_edge(int u,int v,int w){ 13 edge[tot]=(Edge){v,head[u],w}; 14 head[u]=tot++; 15 edge[tot]=(Edge){u,head[v],0}; 16 head[v]=tot++; 17 } 18 int dep[MAXN]; 19 bool bfs(int s,int t){ 20 memset(dep,-1,sizeof(dep)); 21 dep[s]=0; 22 queue<int> Q; 23 Q.push(s); 24 while (!Q.empty()){ 25 int u=Q.front(); 26 Q.pop(); 27 for (int i=head[u];~i;i=edge[i].next){ 28 int v=edge[i].to; 29 if (dep[v]==-1&&edge[i].cap){ 30 dep[v]=dep[u]+1; 31 Q.push(v); 32 } 33 } 34 } 35 return ~dep[t]; 36 } 37 int cur[MAXN]; 38 int dfs(int u,int t,int r){ 39 if (u==t||r==0) return r; 40 int flow(0),f; 41 for (int &i=cur[u];~i;i=edge[i].next){ 42 int v=edge[i].to; 43 if (dep[v]==dep[u]+1&&(f=dfs(v,t,min(r,edge[i].cap)))>0){ 44 edge[i].cap-=f; 45 edge[i^1].cap+=f; 46 flow+=f; 47 if (!(r-=f)) break; 48 } 49 } 50 return flow; 51 } 52 int dinic(int s,int t){ 53 int maxflow(0); 54 while (bfs(s,t)){ 55 memcpy(cur,head,sizeof(head)); 56 maxflow+=dfs(s,t,INF); 57 } 58 return maxflow; 59 }
这是 $\text{ISAP}$ 算法的模板：
1 const int MAXN = 100010; 2 const int MAXM = 400010; 3 const int INF = 0x3f3f3f3f; 4 struct Edge{ 5 int to,next,cap,flow; 6 }edge[MAXM]; 7 int tol; 8 int head[MAXN]; 9 int gap[MAXN],dep[MAXN],cur[MAXN]; 10 void init(){ 11 tol = 0; 12 memset(head,−1,sizeof(head)); 13 } 14 void addedge(int u,int v,int w,int rw = 0){ 15 edge[tol].to = v; edge[tol].cap = w; edge[tol].flow = 0; 16 edge[tol].next = head[u]; head[u] = tol++; 17 edge[tol].to = u; edge[tol].cap = rw; edge[tol].flow = 0; 18 edge[tol].next = head[v]; head[v] = tol++; 19 } 20 int Q[MAXN]; 21 void BFS(int start,int end){ 22 memset(dep,−1,sizeof(dep)); 23 memset(gap,0,sizeof(gap)); 24 gap[0] = 1; 25 int front = 0, rear = 0; 26 dep[end] = 0; 27 Q[rear++] = end; 28 while(front != rear){ 29 int u = Q[front++]; 30 for(int i = head[u]; i != −1; i = edge[i].next){ 31 int v = edge[i].to; 32 if(dep[v] != −1)continue; 33 Q[rear++] = v; 34 dep[v] = dep[u] + 1; 35 gap[dep[v]]++; 36 } 37 } 38 } 39 int S[MAXN]; 40 int sap(int start,int end,int N){ 41 BFS(start,end); 42 memcpy(cur,head,sizeof(head)); 43 int top = 0; 44 int u = start; 45 int ans = 0; 46 while(dep[start] < N){ 47 if(u == end){ 48 int Min = INF; 49 int inser; 50 for(int i = 0;i < top;i++) 51 if(Min > edge[S[i]].cap − edge[S[i]].flow){ 52 Min = edge[S[i]].cap − edge[S[i]].flow; 53 inser = i; 54 } 55 for(int i = 0;i < top;i++){ 56 edge[S[i]].flow += Min; 57 edge[S[i]^1].flow −= Min; 58 } 59 ans += Min; 60 top = inser; 61 u = edge[S[top]^1].to; 62 continue; 63 } 64 bool flag = false; 65 int v; 66 for(int i = cur[u]; i != −1; i = edge[i].next){ 67 v = edge[i].to; 68 if(edge[i].cap − edge[i].flow && dep[v]+1 == dep[u]){ 69 flag = true; 70 cur[u] = i; 71 break; 72 } 73 } 74 if(flag){ 75 S[top++] = cur[u]; 76 u = v; 77 continue; 78 } 79 int Min = N; 80 for(int i = head[u]; i != −1; i = edge[i].next) 81 if(edge[i].cap − edge[i].flow && dep[edge[i].to] < Min){ 82 Min = dep[edge[i].to]; 83 cur[u] = i; 84 } 85 gap[dep[u]]−−; 86 if(!gap[dep[u]])return ans; 87 dep[u] = Min + 1; 88 gap[dep[u]]++; 89 if(u != start)u = edge[S[−−top]^1].to; 90 } 91 return ans; 92 }
例题
下面给出一些例题的讲解，由于做题的时间不同，用到的模板也略有变化，可以先忽略模板的内容，重点关注如何建图。
POJ - 3436 ACM Computer Factory
题意：
有 $N$ 台机器，每个机器可以加工 $P$ 个部分，它们对输入有一定的要求， $0$ 代表这一个部分必须未被加工， $1$ 代表这一部分必须已经被加工， $2$ 代表无所谓。它们的输出也用类似的方式给出， $1$ 代表这一部分已被加工好， $0$ 代表这一部分未被加工或已被拆卸。每台机器每小时处理的工件数量事先给出，请你安排一个连接这些机器的方式，使得每小时总产量最大，输出最大产量和连接的方式。
题解：
本题在建图方面设置的难点在于，如何确定哪些点之间的连接。首先来说，源结点一定要连向且只连向输入中不要求任何一部分已被加工好的机器，容量由这些机器的工时决定，而连向汇点的全部结点一定是那些所有部分在输出时都已被加工好的机器，容量同上。接着考虑机器和机器之间的连接，不难发现，只要一个机器的输出和下一个机器的输入之间满足相同或者输入是 $2$ 的关系，即可将它们相连，而容量由它们较慢的那个决定。至此，图已建立完毕。跑完最大流以后，再去遍历结点，找出流非 $0$ 的边并输出即可。
1 #include <cstdio> 2 #include <cstring> 3 #include <queue> 4 #include <algorithm> 5 using namespace std; 6 //模板部分省略 7 int P,N,M,s,t,res; 8 bool flag; 9 struct Mac{ 10 int in[10]; 11 int out[10]; 12 int Q; 13 bool operator<(const Mac &oth)const{ 14 for (int i=0;i<P;++i){ 15 if (oth.in[i]!=2&&out[i]!=oth.in[i]) 16 return false; 17 } 18 return true; 19 } 20 }mac[MAXN]; 21 int output[MAXM][3]; 22 int main(){ 23 while (~scanf("%d%d",&P,&N)){ 24 init(); 25 for (int i=1;i<=N;++i){ 26 scanf("%d",&mac[i].Q); 27 for (int j=0;j<P;++j) 28 scanf("%d",&mac[i].in[j]); 29 for (int j=0;j<P;++j) 30 scanf("%d",&mac[i].out[j]); 31 } 32 s=0,t=N+1; 33 for (int i=1;i<=N;++i){ 34 flag=true; 35 for (int k=0;k<P;++k){ 36 if (mac[i].in[k]==1){ 37 flag=false; 38 break; 39 } 40 } 41 if (flag) add_edge(s,i,mac[i].Q); 42 flag=true; 43 for (int k=0;k<P;++k){ 44 if (mac[i].out[k]!=1){ 45 flag=false; 46 break; 47 } 48 } 49 if (flag) add_edge(i,t,mac[i].Q); 50 for (int j=1;j<=N;++j){ 51 if (i==j) continue; 52 if (mac[i]<mac[j]) add_edge(i,j,min(mac[i].Q,mac[j].Q)); 53 } 54 } 55 res=dinic(s,t); 56 M=0; 57 for (int u=1;u<=N;++u){ 58 for (int i=head[u];~i;i=edge[i].next){ 59 if (edge[i].flow>0&&edge[i].to!=N+1){ 60 output[M][0]=u; 61 output[M][1]=edge[i].to; 62 output[M][2]=edge[i].flow; 63 ++M; 64 } 65 } 66 } 67 printf("%d %d\n",res,M); 68 for (int i=0;i<M;++i) 69 printf("%d %d %d\n",output[i][0],output[i][1],output[i][2]); 70 } 71 return 0; 72 }
POJ - 3281 Dining
题意：
有 $N$ 头牛， $F$ 种食物， $D$ 种饮料，每头牛只吃自己喜欢的食物或饮料（可能不唯一），每头牛只能最多得到一种食物和一种饮料，每种食物或饮料只能提供给最多一头牛。现在请你安排一种喂牛的方式，使得同时能得到自己想要的食物和饮料的牛最多。输出牛的数量即可。
题解：
本题的难点在于，牛需要同时得到食物或饮料，才能算作一头，且食物、饮料和牛之间的关系是一对一的。为了防止出现有的牛只得到了食物而得不到饮料，却因此占用了其他本可以同时得到食物与饮料的牛的食物的情况，我们需要给牛一个返还食物的机会。因此，我们需要把牛分成两部分（因此这一方法通常也被称为“拆点法”），食物的部分和饮料的部分。源结点连向所有的食物，然后每头牛喜欢的食物连向它们对应的食物部分，各自的食物部分连向各自的饮料部分，再由各自的饮料部分连向各自喜欢的饮料，最终，每个饮料再连向汇点。上述每条边的容量都是 $1$ 。这样一来，当流走到食物部分的时候发现后面已经不通了，算法会把这个流反推回去，减少浪费。因此这样跑出来的数据一定是使得牛最多的。
1 #include <cstdio> 2 #include <cstring> 3 #include <queue> 4 #include <algorithm> 5 using namespace std; 6 //模板部分省略 7 int N,F,D; 8 int f,d,s,t,x; 9 int main(){ 10 init(); 11 scanf("%d%d%d",&N,&F,&D); 12 s=0,t=N+N+F+D+1; 13 for (int i=1;i<=F;++i) 14 add_edge(s,N+N+i,1); 15 for (int i=1;i<=D;++i) 16 add_edge(N+N+F+i,t,1); 17 for (int i=1;i<=N;++i){ 18 scanf("%d%d",&f,&d); 19 add_edge(i,N+i,1); 20 for (int j=0;j<f;++j){ 21 scanf("%d",&x); 22 add_edge(N+N+x,i,1); 23 } 24 for (int j=0;j<d;++j){ 25 scanf("%d",&x); 26 add_edge(N+i,N+N+F+x,1); 27 } 28 } 29 printf("%d\n",dinic(s,t)); 30 return 0; 31 }
CodeForces - 976F Minimal k-covering
题意：
给你一个二部图 $G = (U, V, E)$ ，请你对于从 $0$ 到 $\text{minDegree}$ （最小度）的所有 $k$ ，给出最小 $k$ 覆盖，即，每个结点的度都至少为 $k$ 的子图，且这样的子图是满足条件的子图中所需边数最少的那个。要求输出所需的边数和边。边会事先按序给出，输出序号即可。
题解：
这一题的难点在于，它给的是一个下限，让求最小子图。因此我们不难想到最后的答案和最大流跑完后的补图有关。我们可以这么建图：源结点连左边的结点，容量为 $\deg(u)-k$ ，右边的点连向汇点，容量为 $\deg(v)-k$ ，左结点连右结点，容量为 $1$ 。跑完算法以后选择那些流为 $0$ 边的即可。
然而，此题需要做一些必要的优化，否则会 $\text{TLE}$。我们不可能对于每一个 $k$ 都重新建立一个新图的，这样太费时间。我们可以让 $k$ 从 $\text{minDegree}$ 开始，跑完最大流以后，找流为 $0$ 的边，然后每个连接源结点或汇点的边的 $\text{cap}$ 加 $1$ 即可。模板中需要在边结构体中添加一个 id 变量用来保存边的序号。
1 #include <bits/stdc++.h> 2 using namespace std; 3 const int INF=0x3f3f3f3f; 4 const int MAXN=1e5+10; 5 const int MAXM=1e5+10; 6 struct Edge{ 7 int to,next,cap; 8 int id; 9 }edge[MAXM]; 10 int tot,head[MAXN]; 11 inline void init(){ 12 tot=0; 13 memset(head,-1,sizeof(head)); 14 } 15 inline void add_edge(int u,int v,int w,int id=-1){ 16 edge[tot]=(Edge){v,head[u],w,id}; 17 head[u]=tot++; 18 edge[tot]=(Edge){u,head[v],0,-1}; 19 head[v]=tot++; 20 } 21 int dep[MAXN]; 22 bool bfs(int s,int t){ 23 memset(dep,-1,sizeof(dep)); 24 dep[s]=0; 25 queue<int> Q; 26 Q.push(s); 27 while (!Q.empty()){ 28 int u=Q.front(); 29 Q.pop(); 30 for (int i=head[u];~i;i=edge[i].next){ 31 int v=edge[i].to; 32 if (dep[v]==-1&&edge[i].cap){ 33 dep[v]=dep[u]+1; 34 Q.push(v); 35 } 36 } 37 } 38 return ~dep[t]; 39 } 40 int cur[MAXN]; 41 int dfs(int u,int t,int r){ 42 if (u==t||r==0) return r; 43 int flow(0),f; 44 for (int &i=cur[u];~i;i=edge[i].next){ 45 int v=edge[i].to; 46 if (dep[v]==dep[u]+1&&(f=dfs(v,t,min(r,edge[i].cap)))>0){ 47 edge[i].cap-=f; 48 edge[i^1].cap+=f; 49 flow+=f; 50 if (!(r-=f)) break; 51 } 52 } 53 return flow; 54 } 55 int dinic(int s,int t){ 56 int maxflow(0); 57 while (bfs(s,t)){ 58 memcpy(cur,head,sizeof(head)); 59 maxflow+=dfs(s,t,INF); 60 } 61 return maxflow; 62 } 63 int n1,n2,m,u,v; 64 int deg[MAXN]; 65 vector<int> output[MAXN]; 66 int main(){ 67 init(); 68 memset(deg,0,sizeof(deg)); 69 scanf("%d%d%d",&n1,&n2,&m); 70 for (int i=1;i<=m;++i){ 71 scanf("%d%d",&u,&v); 72 ++deg[u]; 73 ++deg[v+n1]; 74 add_edge(u,v+n1,1,i); 75 } 76 int minD=INF; 77 for (int i=1;i<=n1+n2;++i) 78 minD=min(minD,deg[i]); 79 int s=0,t=n1+n2+1; 80 for (int i=1;i<=n1;++i) 81 add_edge(s,i,deg[i]-minD); 82 for (int i=n1+1;i<=n1+n2;++i) 83 add_edge(i,t,deg[i]-minD); 84 for (int k=minD;k>=0;--k){ 85 dinic(s,t); 86 for (int u=1;u<=n1;++u){ 87 for (int i=head[u];~i;i=edge[i].next){ 88 if (edge[i].id!=-1&&edge[i].cap) 89 output[k].push_back(edge[i].id); 90 } 91 } 92 for (int i=head[s];~i;i=edge[i].next) 93 ++edge[i].cap; 94 for (int i=head[t];~i;i=edge[i].next) 95 ++edge[i^1].cap; 96 } 97 for (int i=0;i<=minD;++i){ 98 int cnt=output[i].size(); 99 printf("%d",cnt); 100 for (int j=0;j<cnt;++j){ 101 printf(" %d",output[i][j]); 102 } 103 puts(""); 104 } 105 return 0; 106 }
HDU - 6582 Path
题意：
给定一个带权有向图，请你选择一些边，删去它们，使得最短路长度变长。删边的代价等于删去边的边权之和，你要选择代价最小的方案。输出最小代价，如果原本就不存在最短路，输出 $0$ 。
题解：
本题看似与最大流无关，其实运用了最大流的一个相关定理，即最大流最小割定理。定理指出，一个有向图的最大流的值等于它的最小切割的容量。而，题中所求的删边最小代价，恰好是使得最短路径构成的子图不连通所需要删去的边的边权和，这正是最短路径子图的最小割。因此我们只需在最短路径子图上跑一遍最大流即可得出答案。最后，考虑到本题边权数据较大，建议开 long long 。模板中还需要在边结构体中添加一个 flag 变量用来表示边是否在最短路径子图中。
1 #include <bits/stdc++.h> 2 using namespace std; 3 typedef long long ll; 4 typedef pair<ll,int> qnode; 5 const ll INF=0x3f3f3f3f3f; 6 const int MAXN=1e5+10; 7 const int MAXM=1e5+10; 8 struct Edge{ 9 int to,next; 10 ll cap; 11 bool flag; 12 }edge[MAXM]; 13 int tot,head[MAXN]; 14 void init(){ 15 tot=0; 16 memset(head,-1,sizeof(head)); 17 } 18 void add_edge(int u,int v,int w){ 19 edge[tot]=(Edge){v,head[u],w,false}; 20 head[u]=tot++; 21 edge[tot]=(Edge){u,head[v],0,false}; 22 head[v]=tot++; 23 } 24 ll dist[MAXN]; 25 bool vis[MAXN]; 26 void dijkstra(int s){ 27 for (int i=0;i<MAXN;++i) 28 dist[i]=INF; 29 priority_queue<qnode,vector<qnode>,greater<qnode> > pq; 30 dist[s]=0; 31 pq.push((qnode){0,s}); 32 qnode now; 33 while (!pq.empty()){ 34 now=pq.top(); 35 pq.pop(); 36 int u=now.second; 37 if (dist[u]<now.first) continue; 38 for (int i=head[u];~i;i=edge[i].next){ 39 int v=edge[i].to; 40 if (edge[i].cap&&dist[v]>dist[u]+edge[i].cap){ 41 dist[v]=dist[u]+edge[i].cap; 42 pq.push((qnode){dist[v],v}); 43 } 44 } 45 } 46 memset(vis,0,sizeof(vis)); 47 queue<int> Q; 48 Q.push(1); 49 while (!Q.empty()){ 50 int u=Q.front(); 51 Q.pop(); 52 if (vis[u]) continue; 53 vis[u]=true; 54 for (int i=head[u];~i;i=edge[i].next){ 55 int v=edge[i].to; 56 if (edge[i].cap&&dist[v]==dist[u]+edge[i].cap){ 57 edge[i].flag=edge[i^1].flag=true; 58 Q.push(v); 59 } 60 } 61 } 62 } 63 int dep[MAXN]; 64 bool bfs(int s,int t){ 65 memset(dep,-1,sizeof(dep)); 66 dep[s]=0; 67 queue<int> Q; 68 Q.push(s); 69 while (!Q.empty()){ 70 int u=Q.front(); 71 Q.pop(); 72 for (int i=head[u];~i;i=edge[i].next){ 73 //只对最短路径子图进行操作 74 if (!edge[i].flag) continue; 75 int v=edge[i].to; 76 if (dep[v]==-1&&edge[i].cap){ 77 dep[v]=dep[u]+1; 78 Q.push(v); 79 } 80 } 81 } 82 return ~dep[t]; 83 } 84 int cur[MAXN]; 85 ll dfs(int u,int t,ll r){ 86 if (u==t||r==0) return r; 87 ll flow(0),f; 88 for (int &i=cur[u];~i;i=edge[i].next){ 89 int v=edge[i].to; 90 //只对最短路径子图进行操作 91 if (!edge[i].flag) continue; 92 if (dep[v]==dep[u]+1&&(f=dfs(v,t,min(r,edge[i].cap)))>0){ 93 edge[i].cap-=f; 94 edge[i^1].cap+=f; 95 flow+=f; 96 if (!(r-=f)) break; 97 } 98 } 99 return flow; 100 } 101 ll dinic(int s,int t){ 102 ll maxflow(0); 103 while (bfs(s,t)){ 104 memcpy(cur,head,sizeof(head)); 105 maxflow+=dfs(s,t,INF); 106 } 107 return maxflow; 108 } 109 int T,n,m; 110 int u,v,w; 111 int main(){ 112 scanf("%d",&T); 113 while (T--){ 114 init(); 115 scanf("%d%d",&n,&m); 116 for (int i=0;i<m;++i){ 117 scanf("%d%d%d",&u,&v,&w); 118 add_edge(u,v,w); 119 } 120 dijkstra(1); 121 printf("%lld\n",dinic(1,n)); 122 } 123 return 0; 124 }
HDU - 6598 Harmonious Army
题意：
现有 $n$ 个士兵和两个阵营（分别叫 Mage 和 Warrior ），每个士兵属于且仅属于一个阵营。题目给出 $m$ 种组合方式，每种方式指出， $u$ 和 $v$ 两个士兵结成一对（pair）能产生的收益。如果两个士兵都属于 Warrior 阵营，则有收益 $a$ ；若都是 Mage ，则有收益 $c$ ；如果分属两个阵营，则有收益 $b=a/4+c/3$ （保证 $4\mid a$ 和 $3\mid c$）。请你现在对这 $n$ 个士兵的阵营进行指派，使得总收益最大。
题解：
本题需考虑的关系很多，建图也很巧。解法为：源结点向每一个士兵连一条边，代表士兵属于 Mage 阵营；每个士兵向汇点连一条边，代表士兵隶属 Warrior 阵营；对于每一个组合方式中的 $u$ 和 $v$ ，它们之间连一条双向边。为了方便叙述，我们设源结点到 $u$ 结点的边权为 $w_{su}$ ， $u$ 到 $v$ 的边权为 $w_{uv}$ ，其他依此类推。则解下列方程组 $$
\begin{aligned}
w_{su}+w_{sv}&=a+b\\
w_{ut}+w_{vt}&=b+c\\
w_{su}+w_{uv}+w_{vt}&=a+c\\
w_{sv}+w_{vu}+w_{ut}&=a+c
\end{aligned}
$$
得出其中一组解为（方程组有多解） $$
\begin{aligned}
w_{su}=w_{sv}&=(a+b)/2\\
w_{ut}=w_{vt}&=(b+c)/2\\
w_{uv}=w_{vu}&=(a+c)/2-b
\end{aligned}
$$
如此建图，跑出最大流后，再用所有的 $a,b,c$ 之和减去最大流即为答案。
那么，这么做为什么是正确的呢？此题依然应用了最小割的思想。若仅考虑 $u$ 和 $v$ 两个结点，从 $s$ 到 $t$ 的割无非就是四种，第一，切割 $\langle s,u \rangle$ 和 $\langle s,v \rangle$ ；第二，切割 $\langle u,t \rangle$ 和 $\langle v,t \rangle$ ；第三，切割 $\langle s,u \rangle$ 、 $\langle u,v \rangle$ 和 $\langle v,t \rangle$ ；第四，切割 $\langle s,v \rangle$ 、 $\langle v,u \rangle$ 和 $\langle u,t \rangle$ 。这四种切割都分别表示了 $u$ 和 $v$ 的一种阵营指派所得收益相对于总和的补。当割的值最小时，补最小，则原值最大，也就是收益最大。
刚才是仅有两个结点的状况，推广到多个结点原理也都相同。事实上，分属两个割集的非源非汇结点就相当于分属两个阵营，因此一个割就确定出一种合法的阵营指派。我们不去关注割集内部的流是怎么流的，总之我们看的是最小割，而最小割能确定出合法的阵营指派，而且还是最小，那么它就一定是答案。
1 #include <bits/stdc++.h> 2 using namespace std; 3 typedef long long ll; 4 const int INF=0x3f3f3f3f; 5 const int MAXN=1e5+10; 6 const int MAXM=1e5+10; 7 template<class T> 8 struct Edge{ 9 int to,next; 10 double cap; 11 }; 12 Edge<double> edge[MAXM]; 13 int tot,head[MAXN]; 14 inline void init(){ 15 tot=0; 16 memset(head,-1,sizeof(head)); 17 } 18 template<class T> 19 inline void add_edge(int u,int v,T w){ 20 edge[tot]=(Edge<T>){v,head[u],w}; 21 head[u]=tot++; 22 edge[tot]=(Edge<T>){u,head[v],0}; 23 head[v]=tot++; 24 } 25 int dep[MAXN]; 26 bool bfs(int s,int t){ 27 memset(dep,-1,sizeof(dep)); 28 dep[s]=0; 29 queue<int> Q; 30 Q.push(s); 31 while (!Q.empty()){ 32 int u=Q.front(); 33 Q.pop(); 34 for (int i=head[u];~i;i=edge[i].next){ 35 int v=edge[i].to; 36 if (dep[v]==-1&&edge[i].cap){ 37 dep[v]=dep[u]+1; 38 Q.push(v); 39 } 40 } 41 } 42 return ~dep[t]; 43 } 44 int cur[MAXN]; 45 double dfs(int u,int t,double r){ 46 if (u==t||r==0) return r; 47 double flow(0),f; 48 for (int &i=cur[u];~i;i=edge[i].next){ 49 int v=edge[i].to; 50 if (dep[v]==dep[u]+1&&(f=dfs(v,t,min((double)r,edge[i].cap)))>0){ 51 edge[i].cap-=f; 52 edge[i^1].cap+=f; 53 flow+=f; 54 if (!(r-=f)) break; 55 } 56 } 57 return flow; 58 } 59 double dinic(int s,int t){ 60 double maxflow(0); 61 while (bfs(s,t)){ 62 memcpy(cur,head,sizeof(head)); 63 maxflow+=dfs(s,t,INF); 64 } 65 return maxflow; 66 } 67 int n,m,u,v,a,b,c; 68 int M[MAXN],W[MAXN]; 69 int main(){ 70 while (~scanf("%d%d",&n,&m)){ 71 memset(M,0,sizeof(M)); 72 memset(W,0,sizeof(W)); 73 init(); 74 ll sum=0; 75 for (int i=0;i<m;++i){ 76 scanf("%d%d%d%d%d",&u,&v,&a,&b,&c); 77 M[u]+=a+b; 78 M[v]+=a+b; 79 W[u]+=b+c; 80 W[v]+=b+c; 81 add_edge(u,v,-b+a/2.0+c/2.0); 82 add_edge(v,u,-b+a/2.0+c/2.0); 83 sum+=a+b+c; 84 } 85 int s=0,t=n+1; 86 for (int i=1;i<=n;++i){ 87 add_edge(s,i,M[i]/2.0); 88 add_edge(i,t,W[i]/2.0); 89 } 90 ll res=(ll)round(sum-dinic(s,t)); 91 printf("%lld\n",res); 92 } 93 return 0; 94 }
最大流算法大致就是如此，关键是要找准逻辑关系，并巧妙地利用它，同时可能还要在最大流和最小割之间来回转化。
315
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
