UVa11248 - Frequency Hopping

        题意：给定一个有向网络，每条边均有一个容量。问是否存在一个从点1到点N，流量为C的流。如果不存在，是否可以恰好修改一条弧的容量，使得存在这样的流？

        思路：白书训练指南第一道网络流例题。。先求一次最大流，如果流量至少为C，输出possible，否则需要修改的弧一定是最小割里的弧。依次把这些弧的容量增加到C，然后求最大流，看最大流是否至少为C。不过这样做会超时，需要两个重要优化。第一个优化是秋晚最大流后把流量留着，以后每次在这基础上增广，第二个优化是每次不求最大流，增广到流量至少为C时就停下来。

        这道题绝对是坑题。。。通过这题，我学会了一个单词"unidirectional"，它竟然是"undirectional"的反义词。而且这题的"in ascending order"也可以有不同的理解。。正确的理解是，先按出发顶点排序，相同的按到达顶点排序。

#include<iostream>  
#include<cmath>  
#include<cstring>  
#include<queue>  
#include<vector>  
#include<algorithm>  
#include<string.h>  
#include<cstdio>  
#define maxn 210  
  
using namespace std;  
  
#define INF 2000000010  
  
int n,e,c;  
  
struct Edge{  
    int u; int v;  
    int cap; int flow;  
    Edge(int u,int v,int c):u(u),v(v),cap(c),flow(0){}    
    Edge(){};  
};  
  
Edge edges[maxn*maxn];  
  
int ne;  
int head[maxn];  
int next[maxn*maxn];  
  
void init(){  
    memset(head,-1,sizeof(head));  
    ne=0;  
}  
  
int lv[maxn];  
bool bfs(int s,int t){  
    memset(lv,-1,sizeof(lv)); lv[s]=0;  
    queue<int> que; que.push(s);   
    while(!que.empty()){  
        int cur=que.front(); que.pop();  
        for(int i=head[cur];i!=-1;i=next[i]){  
            Edge& e=edges[i];  
            if(lv[e.v]!=-1)continue;  
            if(e.flow<e.cap){  
                lv[e.v]=lv[cur]+1;  
                que.push(e.v);  
            }  
        }  
        if(lv[t]!=-1)return 1;  
    }  
    return 0;  
}  
  
int cur[maxn];  
int dfs(int x,int a){  
    if(x==n||a==0)return a;  
    int re=0;  
    for(int& i=cur[x];i!=-1;i=next[i]){  
        Edge& e=edges[i];  
        int t;  
        if(lv[e.v]==(lv[x]+1)&& (t=dfs( e.v , min(a,e.cap-e.flow))) ){  
            edges[i].flow+=t;  
            edges[i^1].flow-=t;  
            re+=t;  
            a-=t;  
            if(a==0)break;  
        }  
    }  
    return re;  
}  

bool cmp(int a,int b){
	if(edges[a].u==edges[b].u){
		return edges[a].v<edges[b].v;
	}
	return edges[a].u<edges[b].u;
}
  
int maxflow(int s,int t,int _m){  
    int flow=0;  
    while(bfs(1,n)){  
        memcpy(cur,head,sizeof(head));  
        flow+=dfs(s,INF);  
        if(flow>=_m)return flow;  
    }  
    return flow;  
}  
  
void addedge(int u,int v,int c){  
    edges[ne]=Edge(u,v,c);    
    next[ne]=head[u];  
    head[u]=ne;  
    ne++;  
    edges[ne]=Edge(v,u,0);  
    next[ne]=head[v];  
    head[v]=ne;  
    ne++;  
}  
  
int flows[maxn*maxn];  
//还原流量 
void initflow(){  
    for(int i=0;i<e*2;i++){  
        edges[i].flow=flows[i];  
    }  
}  
  
int optionu[maxn*maxn];  
int optionv[maxn*maxn];  
  
int main(){  
    int cas=0;  
    while(cin>>n>>e>>c){  
        if(n==0&&e==0&&c==0)break;  
          
        cas++;  
        init();  
          
        for(int i=1;i<=e;++i){  
            int u,v,c;  
            scanf("%d%d%d",&u,&v,&c);  
            addedge(u,v,c);  
        }  
        int ans=maxflow(1,n,INF);  
          
        printf("Case %d: ",cas);  
        if(ans>=c){  
            printf("possible\n");  
        }else{  
            for(int i=0;i<2*e;i++){  
                flows[i]=edges[i].flow;  
            }  
              
            bfs(1,n);  
            vector<int>cuts;  
            for(int i=0;i<2*e;i+=2){  
                if( (lv[edges[i].u]!=-1) && (lv[edges[i].v]==-1) ){  
                    cuts.push_back(i);  
                }  
            }  
          
        	sort(cuts.begin(),cuts.end(),cmp);//升序 
            int cnt=0;  
            int siz=cuts.size();  
            for(int i=0;i<siz;i++){  
                int tmp=edges[cuts[i]].cap;  
                edges[cuts[i]].cap=c;  
                int d=maxflow(1,n,c-ans);//d是扩容后得到的额外流量   
                edges[cuts[i]].cap=tmp;  
                initflow();  
                if(ans+d>=c){//扩容成功   
                    optionu[cnt]=edges[cuts[i]].u;  
                    optionv[cnt]=edges[cuts[i]].v;  
                    cnt++;  
                }  
            }  
              
            if(cnt){  
                printf("possible option:");  
                for(int i=0;i<cnt;i++){  
                    printf("(%d,%d)",optionu[i],optionv[i]);  
                    if(i!=cnt-1)printf(",");  
                }  
                printf("\n");  
            }else{  
                printf("not possible\n");  
            }  
        }  
    }  
    return 0;  
}