UVA 11248 网络扩容 最小割

割：有容量网络G   E'是G中的一些边的集合  如果删去E'后G不再连通  则E'就是G的割

最小割： 容量网络中容量最小的割

UVA 11248 

本题的题意就是给定一个有向网络  每条边都有一个容量  问是否存在一个从点1到点N  流量为C的流

如果不存在 是否可以恰好修改一条弧的容量（可以有多种修改方案） 使得存在这样的流

思路：

先求最大流  流量大于等于C就是存在的  

否则 需要修改的弧一定是最小割里的弧 依次把这些弧的容量增加到C  然后再求最大流 看最大流量是否至少为C

这题的建图不需要技巧 直接建图就可以

主要的模版还是求最大流的  这题还要求出最小割 需要保存最小割中的边 然后对这条边的容量进行修改！！

代码如下：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <string>
#include <vector>
#include <queue>

#define eps 1e-8
#define op operator
#define MOD  10009
#define MAXN  10010
#define INF 0x7fffffff

#define FOR(i,a,b)  for(int i=a;i<=b;i++)
#define FOV(i,a,b)  for(int i=a;i>=b;i--)
#define REP(i,a,b)  for(int i=a;i<b;i++)
#define REV(i,a,b)  for(int i=a-1;i>=b;i--)
#define MEM(a,x)    memset(a,x,sizeof a)
#define ll __int64

using namespace std;

struct Edge
{
    int from,to,cap,flow;
    bool operator <(const Edge e) const
    {
        if(e.from!=from)  return from<e.from;
        else return to<e.to;
    }
    Edge() {}
    Edge(int from,int to,int cap,int flow):from(from),to(to),cap(cap),flow(flow) {}
};

struct Dinic
{
    vector<Edge> edges;
    vector<int> G[MAXN];
    bool vis[MAXN];//BFS使用
    int d[MAXN];   //从起点到i的距离
    int cur[MAXN]; //当前弧下标
    int n,m,s,t,maxflow;   //节点数 边数（包括反向弧） 源点编号和弧点编号

    void init(int n)
    {
        this->n=n;
        for(int i=0;i<=n;i++)
            G[i].clear();
        edges.clear();
    }

    void clearflow()
    {
        for(int i=0;i<edges.size();i++)
            edges[i].flow=0;
    }

    void addedge(int from,int to,int cap)
    {
        edges.push_back(Edge(from,to,cap,0));
        edges.push_back(Edge(to,from,0,0));
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    bool bfs()
    {
        MEM(vis,0);
        MEM(d,-1);
        queue<int> q;
        q.push(s);
        d[s]=maxflow=0;
        vis[s]=1;
        while(!q.empty())
        {
            int u=q.front(); q.pop();
            int sz=G[u].size();
            for(int i=0;i<sz;i++)
            {
                Edge e=edges[G[u][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    d[e.to]=d[u]+1;
                    vis[e.to]=1;
                    q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    int dfs(int u,int a)
    {
        if(u==t||a==0)  return a;
        int sz=G[u].size();
        int flow=0,f;
        for(int &i=cur[u];i<sz;i++)
        {
            Edge &e=edges[G[u][i]];
            if(d[u]+1==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>0)
            {
                e.flow+=f;
                edges[G[u][i]^1].flow-=f;
                flow+=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())
        {
            MEM(cur,0);
            flow+=dfs(s,INF);
        }
        return flow;
    }

    void reduce()
    {
        for(int i=0;i<edges.size();i++)
            edges[i].cap-=edges[i].flow;
    }

    void mincut(vector<int> &cut )
    {
        cut.clear();
        for(int i=0;i<edges.size();i++)
        {
            Edge &e=edges[i];
            if(vis[e.from]&&!vis[e.to]&&e.cap>0)
                cut.push_back(i);
        }
    }

}Dic;

vector<int> cut;
vector<Edge> ans;

int main()
{
//freopen("ceshi.txt","r",stdin);
    int n,m,c;
    int cs=1;
    while(scanf("%d%d%d",&n,&m,&c)!=EOF)
    {
        if(n==0&&m==0&&c==0)  break;
        Dic.init(n+10);
        int s=1,t=n;
        while(m--)
        {
            int u,v,x;
            scanf("%d%d%d",&u,&v,&x);
            Dic.addedge(u,v,x);
        }
        printf("Case %d: ",cs++);
        int flow=Dic.Maxflow(s,t);
        if(flow>=c)
        {
            printf("possible\n");
            continue;
        }
        else
        {
            Dic.mincut(cut);
            ans.clear();
            Dic.reduce();
            for(int i=0;i<cut.size();i++)
            {
                Edge &e=Dic.edges[cut[i]];
                e.cap=c;
                Dic.clearflow();
                if(flow+Dic.Maxflow(s,t)>=c)
                    ans.push_back(e);
                e.cap=0;
            }
        }
        if(ans.empty())
        {
            printf("not possible\n");
            continue;
        }
        sort(ans.begin(),ans.end());
        int first=1;
        for(int i=0;i<ans.size();i++)
        {
            Edge& e=ans[i];
            if(first)
            {
                printf("possible option:(%d,%d)",e.from,e.to);
                first=0;
            }
            else
                printf(",(%d,%d)",e.from,e.to);
        }
        puts("");
    }
    return 0;
}