SGU 176 (有源汇最小流)

转载:http://blog.csdn.net/dan__ge/article/details/51207951

题意：n个节点，m条路径，接下来m行a,b,c,d,如果d等于1，则a到b的流量必须为c，如果d等于0，流量可以为0到c，问如果有可行流，最小流量和每条边的流量

思路：最小流的解法与其他的不同，我们先将其变成无源汇的做法，建立超级源点和汇点，然后跑最大流，之后在加上汇点到源点的inf边，再跑最大流，如果满流则说明有解，不然无解，而最小的流量就是汇点到源点跑得流量

 #include <queue>
 #include <vector>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <iostream>
 #include <algorithm>
 #include <functional>
 using namespace std;
 typedef long long ll;
 const int inf=0x3f3f3f3f;
 const int maxn=;
 struct edge{
     int to,cap,rev;
     edge(int a,int b,int c){to=a;cap=b;rev=c;}
 };
 vector<edge>G[maxn];
 int level[maxn],iter[maxn];
 void add_edge(int from,int to,int cap){
     G[from].push_back(edge(to,cap,G[to].size()));
     G[to].push_back(edge(from,,G[from].size()-));
 }
 void bfs(int s){
     memset(level,-,sizeof(level));
     queue<int>que;level[s]=;
     que.push(s);
     while(!que.empty()){
         int v=que.front();que.pop();
         for(unsigned int i=;i<G[v].size();i++){
             edge &e=G[v][i];
             if(e.cap>&&level[e.to]<){
                 level[e.to]=level[v]+;
                 que.push(e.to);
             }
         }
     }
 }
 int dfs(int v,int t,int f){
     if(v==t) return f;
     for(int &i=iter[v];i<G[v].size();i++){
         edge &e=G[v][i];
         if(e.cap>&&level[v]<level[e.to]){
             int d=dfs(e.to,t,min(f,e.cap));
             if(d>){
                 e.cap-=d;
                 G[e.to][e.rev].cap+=d;
                 return d;
             }
         }
     }
     return ;
 }
 int max_flow(int s,int t){
     int flow=;
     while(){
         bfs(s);
         if(level[t]<) return flow;
         memset(iter,,sizeof(iter));
         int f;
         while((f=dfs(s,t,inf))>) flow+=f;
     }
 }
 int L[],R[],num[][];
 int main(){
     int n,m,a,b,d,c;
     while(scanf("%d%d",&n,&m)!=-){
         for(int i=;i<maxn;i++) G[i].clear();
         int sum=,S=n+,T=n+;
         for(int i=;i<m;i++){
             scanf("%d%d%d%d",&a,&b,&c,&d);
             if(d==){
                 L[i]=c;R[i]=c;
             }else{
                 L[i]=,R[i]=c;
             }
             add_edge(a,b,R[i]-L[i]);
             sum+=L[i];
             num[i][]=a;num[i][]=G[a].size()-;
             add_edge(S,b,L[i]);add_edge(a,T,L[i]);
         }
         int ans=max_flow(S,T);
         add_edge(n,,inf);
         int kk=G[].size()-;
         int ans1=max_flow(S,T);
         if(ans+ans1!=sum) printf("Impossible\n");
         else{
             printf("%d\n",G[][kk].cap);
             for(int i=;i<m-;i++){
                 printf("%d ",R[i]-G[num[i][]][num[i][]].cap);
             }
             printf("%d\n",R[m-]-G[num[m-][]][num[m-][]].cap);
         }
     }
     return ;
 }