【LA11248 训练指南】网络扩容【最大流】

题意：

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

分析：

  先跑一遍最大流，如果最大流大于等于C，则输possible。如果最大流小于C，则表明需要修改边的流量。很显然，需要修改的弧一定是满流的弧。但是如果直接暴力会超时，所以我们可以有两个优化。

 1.第一次求完最大流以后，把每条弧的流量保存下来，每次修改完一条弧的容量以后，都从当前残量网络开始继续增广。

 2.每次不需要增广到最大流，当流量大于等于C的时候就停止增广（不过不加这个优化好像也没事，反正我没加··）

  

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>

using namespace std;
const int maxn=100+10;
const int maxm=20000+10;
const int INF=2147000000;
struct Dinic{
    int head[maxn],Next[maxm],to[maxm],from[maxm],cap[maxm],flow[maxm];
    int n,m,s,t,sz;
    bool vis[maxn];
    int d[maxn],cur[maxn];
    void init(int n){
        this->n=n;
        sz=-1;
        memset(head,-1,sizeof(head));
    }
    void add_edge(int a,int b,int c){
        ++sz;
        to[sz]=b;Next[sz]=head[a];head[a]=sz;
        cap[sz]=c;flow[sz]=0,from[sz]=a;;
        ++sz;
        to[sz]=a;Next[sz]=head[b];head[b]=sz;
        cap[sz]=c;flow[sz]=c,from[sz]=b;
    }
    bool BFS(){
        memset(vis,0,sizeof(vis));
        for(int i=0;i<=n;i++)d[i]=INF;
        queue<int>Q;
        d[s]=0,vis[s]=1;
        Q.push(s);
        while(!Q.empty()){
            int u=Q.front();Q.pop();
            for(int i=head[u];i!=-1;i=Next[i]){
                int v=to[i];
                if(cap[i]>flow[i]&&!vis[v]){
                    vis[v]=1;
                    d[v]=d[u]+1;
                    Q.push(v);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x,int a){
        if(x==t||a==0)return a;
        int Flow=0,f;
        for(int& i=cur[x];i!=-1;i=Next[i]){
            int v=to[i];
            if(d[v]==d[x]+1&&(f=DFS(v,min(a,cap[i]-flow[i])))>0){
                Flow+=f;
                flow[i]+=f;
                flow[i^1]-=f;
                a-=f;
                if(a==0)break;
            }
        }
        return Flow;
    }
    int Maxflow(int s,int t){
        this->s=s;this->t=t;
        int Flow=0;
        while(BFS()){
            for(int i=0;i<=n;i++)cur[i]=head[i];
            Flow+=DFS(s,INF);
        }
        return Flow;
    }
}dinic;
struct Edge{
    int from,to;
    bool operator <(const Edge& rhs)const{
        return from<rhs.from||(from==rhs.from&&to<rhs.to);
    }
};
vector<Edge>ans;
int kase,N,E,C;
int main(){
    kase=0;
    while(scanf("%d%d%d",&N,&E,&C)!=EOF&&(N||E||C)){
        ++kase;
        printf("Case %d: ",kase);
        ans.clear();
        dinic.init(N);
        int u,v,c;
        for(int i=1;i<=E;i++){
            scanf("%d%d%d",&u,&v,&c);
            dinic.add_edge(u,v,c);
        }
        int Maxflow=dinic.Maxflow(1,N);
        if(Maxflow>=C){
            printf("possible
");
        }else{
            int FLOW[maxm];
            for(int i=0;i<=dinic.sz;i++){
                FLOW[i]=dinic.flow[i];
            }
            int CAP,c=C-Maxflow;
            for(int i=0;i<=dinic.sz;i+=2){
                if(dinic.cap[i]==dinic.flow[i]){

                    for(int i=0;i<=dinic.sz;i++)dinic.flow[i]=FLOW[i];
                    CAP=dinic.cap[i];
                    dinic.cap[i]=C;
                    dinic.cap[i^1]=C;
                    Maxflow=dinic.Maxflow(1,N);
                    if(Maxflow>=c){
                        ans.push_back((Edge){dinic.from[i],dinic.to[i]});
                    }
                    dinic.cap[i]=CAP;
                    dinic.cap[i^1]=CAP;
                    for(int i=0;i<=dinic.sz;i++)dinic.flow[i]=FLOW[i];
                }
            }
            if(ans.size()==0){
                printf("not possible
");
            }else{
                sort(ans.begin(),ans.end());
                printf("possible option:");
                for(int i=0;i<ans.size();i++){
                    if(i!=0)printf(",");
                    printf("(%d,%d)",ans[i].from,ans[i].to);
                }
                printf("
");
            }
        }
    }
return 0;
}