hdu 4067(最小费用最大流）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4067

思路：很神奇的建图，参考大牛的：

如果人为添加t->s的边，那么图中所有顶点要满足的条件都是一样的了，我们以此为目的来建图。

对于每条边，我们只有两种操作，要么保留要么删除，那么先假设两种操作都能满足条件，我们就可以选择花费小的操作来执行，最后再根据实际情况调整。
首先不加入任何边，在添加或删除(不加入)边的过程中，对每个顶点v记录in[v]为其当前入度，out[v]为其出度，sum为当前的总花费。
那么对于每条边，如果a<=b，那么保留这条边，in[v]++,out[u]++,sum+=a,然后连边v->u，流量1，费用为b-a（如果删除这条边的费用)
如果b<a，那么删去这条边,sum+=b,然后连边u->v，流量1，费用为a-b(如果保留这条边的费用）。
然后我们人为的加入一条t->s，直接in[s]++,out[t]++,使得图中所有点处于相同的状况。
设立超级源汇S、T，对于原图的每个点i，如果in[i]>out[i]，则连边S->i，流量为in[i]-out[i]， 费用为0，否则连边i->T，流量为out[i]-in[i]，费用为0。至此，建图完成。

现在求S到T的费用流mincost，然后检查从S发出的边，如果全部满流则有解，答案就是sum+mincost，否则无解。
这样建图的意义：例如对点i，in[i]>out[i]，说明当前该点入度大于出度，那么我们把之前删除的以i为起点的边添加回来 或者把之前保留的以i为终点的边删除，现在边的费用其实是改变边状态所需要额外付的费用，而最小费用流所求的就是全部调整的总费用了，于是答案就是sum(初始操作的费用)+mincost(额外付出的费用)。

  1 #include<iostream>

  2 #include<cstdio>

  3 #include<cstring>

  4 #include<algorithm>

  5 #include<queue>

  6 using namespace std;

  7 #define MAXN 222

  8 #define MAXM 2222222

  9 #define inf 1<<30

 10 

 11 struct Edge{

 12     int v,cap,cost,next;

 13 }edge[MAXM];

 14 

 15 int n,m,vs,vt,NE;

 16 int head[MAXN];

 17 

 18 void Insert(int u,int v,int cap,int cost)

 19 {

 20     edge[NE].v=v;

 21     edge[NE].cap=cap;

 22     edge[NE].cost=cost;

 23     edge[NE].next=head[u];

 24     head[u]=NE++;

 25 

 26     edge[NE].v=u;

 27     edge[NE].cap=0;

 28     edge[NE].cost=-cost;

 29     edge[NE].next=head[v];

 30     head[v]=NE++;

 31 }

 32 

 33 int dist[MAXN],pre[MAXN],cur[MAXN];

 34 bool mark[MAXN];

 35 bool spfa(int vs,int vt)

 36 {

 37     memset(mark,false,sizeof(mark));

 38     fill(dist,dist+MAXN-1,inf);

 39     dist[vs]=0;

 40     queue<int>que;

 41     que.push(vs);

 42     while(!que.empty()){

 43         int u=que.front();

 44         que.pop();

 45         mark[u]=false;

 46         for(int i=head[u];i!=-1;i=edge[i].next){

 47             int v=edge[i].v,cost=edge[i].cost;

 48             if(edge[i].cap>0&&dist[u]+cost<dist[v]){

 49                 dist[v]=cost+dist[u];

 50                 pre[v]=u;

 51                 cur[v]=i;

 52                 if(!mark[v]){

 53                     mark[v]=true;

 54                     que.push(v);

 55                 }

 56             }

 57         }

 58     }

 59     return dist[vt]<inf;

 60 }

 61 

 62 int MinCostFlow(int vs,int vt)

 63 {

 64     int flow=0,cost=0;

 65     while(spfa(vs,vt)){

 66         int aug=inf;

 67         for(int u=vt;u!=vs;u=pre[u]){

 68             aug=min(aug,edge[cur[u]].cap);

 69         }

 70         flow+=aug;cost+=dist[vt]*aug;

 71         for(int u=vt;u!=vs;u=pre[u]){

 72             edge[cur[u]].cap-=aug;

 73             edge[cur[u]^1].cap+=aug;

 74         }

 75     }

 76     return cost;

 77 }

 78 

 79 int In[MAXN],Out[MAXN];

 80 bool Judge()

 81 {

 82     for(int i=head[vs];i!=-1;i=edge[i].next){

 83         int cap=edge[i].cap;

 84         if(cap>0)return false;

 85     }

 86     return true;

 87 }

 88 

 89 int main()

 90 {

 91     int s,t,u,v,a,b,sum,cost,T=1,_case;

 92     scanf("%d",&_case);

 93     while(_case--){

 94         scanf("%d%d%d%d",&n,&m,&s,&t);

 95         NE=0;

 96         memset(head,-1,sizeof(head));

 97         memset(In,0,sizeof(In));

 98         memset(Out,0,sizeof(Out));

 99         sum=0;

100         while(m--){

101             scanf("%d%d%d%d",&u,&v,&a,&b);

102             if(a<=b){

103                 Insert(v,u,1,b-a);

104                 In[v]++,Out[u]++;

105                 sum+=a;

106             }else {

107                 Insert(u,v,1,a-b);

108                 sum+=b;

109             }

110         }

111         In[s]++;

112         Out[t]++;

113         vs=0,vt=n+1;

114         for(int i=1;i<=n;i++){

115             if(In[i]>Out[i])Insert(vs,i,(In[i]-Out[i]),0);

116             else if(In[i]<Out[i])Insert(i,vt,(Out[i]-In[i]),0);

117         }

118         cost=MinCostFlow(vs,vt);

119         printf("Case %d: ",T++);

120         if(Judge()){

121             printf("%d\n",sum+cost);

122         }else 

123             puts("impossible");

124     }

125     return 0;

126 }

127 

128 

129 

130         

131             

132 

133 

134 

135 

136         

137         

138     

View Code