这道题跟求最大流的时候差不多。
都是先构造可行流，然后判断是否可行，
可行的话，就利用残余流量，构造从汇点t跑到源点s的最大流，
如何求出答案呢。
在第一次求可行流的dinic后，跟求最大流的时候一样，从t到s是可行流的流量；
这个时候t到s的反向边，也就是s到t的流量就是t到s流的量（因为t到s定义权值为inf，要从这条边算出来，得用inf去减到这条边剩下的才是答案，有点麻烦）
所以反向边是个便捷的求法。
所以在第一次dinic之后，t到s的反向便的流量就是可行流的流量；
然后我们再从t到s跑最大流，看最大能跑掉多少，就是最后的答案。 (这里肯定不会影响可行流！，因为已经在第一次dinic的时候保证了可行（即sum==tmpp))
求第二次dinic的时候，要将s跟t之间的边给去掉。
1 #include<cstdio>
2 #include<string.h>
3 #include<algorithm>
4 #include<math.h>
5 #include<queue>
6 using namespace std;
7 typedef long long ll;
8 const ll maxn=51000;
9 const ll inf=0x3f3f3f3f3f3f3f3f;
10 ll vis[maxn];
11 ll head[maxn],level[maxn]; //前者为邻接表必要数据，后者为dinic的层 数据
12 ll in[maxn]; //一条边的初始流量（最低值 也就是定为下界）
13 ll limit[maxn]; //limit为该点的流量 小于0的时候是流出多
14 //ll bh[maxn]; //一条边的反向边的流量（正向边流出了多少，反向边就是多少）
15 //所以用初始的下界流量+上这个方向边的流量就是最终答案；
16 //那么为什么不直接正向呢？？？
17 //废话 正向求比较麻烦嘛。 原本的值是可以流的量，正向边流出去后
18 //那么答案就是可以流的量减去剩余的量就是答案；
19 //所以还不如直接求反向呢
20 ll num; //邻接表
21 void init()
22 {
23 num=-1 ;
24 memset(head,-1,sizeof(head));
25 }
26 struct node
27 {
28 ll v,w,next;
29 }G[maxn*12];
30 ll bfs(ll s,ll t)
31 {
32 queue<ll>q;
33 q.push(s);
34 memset(level,-1,sizeof(level));
35 level[s]=0;
36 while(!q.empty()){
37 ll u=q.front();
38 q.pop();
39 for(ll i=head[u];i!=-1;i=G[i].next){
40 ll v=G[i].v;
41 if(G[i].w>0&&level[v]==-1){
42 level[v]=level[u]+1;
43 q.push(v);
44 }
45 }
46 }
47 return level[t];
48 }
49 ll dfs(ll s,ll t,ll f)
50 {
51 if(s==t) return f;
52 ll ans=0;
53 for(ll i=vis[s];i!=-1;i=G[i].next){
54 vis[s]=i; //当前弧优化
55 ll v=G[i].v;
56 if(G[i].w>0&&level[s]+1==level[v]){
57 ll d=dfs(v,t,min(G[i].w,f-ans));
58 if(d>0){
59 G[i].w-=d;
60 G[i^1].w+=d;
61 ans+=d;
62 if(ans==f) return ans;
63 }
64 }
65 }
66 // if(ans==0) level[s]=0;
67 return ans;
68 }
69 ll dinic(ll s,ll t)
70 {
71 ll ans=0;
72 while(1){
73 ll temp=bfs(s,t);
74 if(temp==-1) break;
75 memcpy(vis,head,sizeof(head));
76 ans+=dfs(s,t,inf);
77 }
78 return ans;
79 }
80 void build(ll u,ll v,ll w)
81 {
82 num++;
83 G[num].v=v;
84 G[num].w=w;
85 G[num].next=head[u];
86 head[u]=num;
87
88 num++;
89 G[num].v=u;
90 G[num].w=0;
91 G[num].next=head[v];
92 head[v]=num;
93 }
94 int main()
95 {
96 init();
97 ll n,m,s,t;
98 scanf("%lld%lld%lld%lld",&n,&m,&s,&t);
99 for(ll i=1;i<=m;i++){
100 ll u,v,w1,w2;
101 scanf("%lld%lld%lld%lld",&u,&v,&w1,&w2);
102 // in[u]=w1;
103 limit[u]-=w1;
104 limit[v]+=w1;
105 build(u,v,w2-w1);
106 }
107 ll S=0;ll T=n+1;
108 ll sum=0;
109 for(ll i=1;i<=n;i++){
110 if(limit[i]<0) build(i,T,-limit[i]);
111 if(limit[i]>0) build(S,i,limit[i]),sum+=limit[i];
112 }
113 build(t,s,inf);
114 //其实这里应该有上面的limit的变化 只是因为这里的w1为0，所以省略不写。
115 ll tmpp=dinic(S,T);
116 if(tmpp!=sum) printf("please go home to sleep\n");
117 else{
118 ll tmp1=G[num].w;
119 G[num].w=G[num-1].w=0;
120 ll tmp2=dinic(t,s);
121 printf("%lld\n",tmp1-tmp2);
122 }
123 return 0;
124 }
原文地址：https://www.cnblogs.com/pangbi/p/11808944.html
时间： 2024-09-29 05:41:29