UVA 11248 - Frequency Hopping

代码如下：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;

const int maxn=10005;
const int INF=2100000001;

int C;
struct Edge
{
    int from,to,cap,flow;
};

bool operator < (const Edge &a,const Edge &b)
{
    if(a.from!=b.from)return a.from<b.from;
    return a.to<b.to;
}


struct Dinic
{
    int n,m,s,t;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];

    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()
    {
        memset(vis,0,sizeof(vis));
        queue<int> Q;
        Q.push(s);
        d[s]=0;
        vis[s]=1;
        while(!Q.empty())
        {
            int x=Q.front();
            Q.pop();
            for(int i=0;i<G[x].size();++i)
            {
                Edge& e=edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    vis[e.to]=1;
                    d[e.to]=d[x]+1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

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

int main()
{
 //   freopen("data.txt","r",stdin);
//    ios::sync_with_stdio(false);
//    cin.tie(NULL);
    int N,E;
    Dinic ans;
    Dinic rec;
    int kase=0;
        while(scanf("%d%d%d",&N,&E,&C))
    {

        if(N==0&&E==0&&C==0)break;
         printf("Case %d: ",++kase);

        ans.m=0;
        ans.edges.clear();
       for(int i=0;i<maxn;++i)ans.G[i].clear();
        ans.n=N;
        ans.t=N;
        ans.s=1;
        ans.m=0;
        for(int i=0;i<E;++i)
        {
            int b1,b2,fp;
            scanf("%d%d%d",&b1,&b2,&fp);
            ans.AddEdge(b1,b2,fp);
        }
   
        int tmp=ans.Maxflow(1,N);
        if(tmp>=C)
        {
            cout<<"possible"<<endl;
            continue;
        }
        else
        {
            vector<int> cut;
            ans.Mincut(cut);
        
            rec=ans;
            vector<Edge> p;
            p.clear();
            for(int i=0;i<cut.size();++i)
            {
                ans.edges[cut[i]].cap=C;
                int ttmp=ans.Maxflow(1,N);

                if(tmp+ttmp>=C)
                {
                    p.push_back(ans.edges[cut[i]]);
                }
           
                ans=rec;
            }
            if(p.empty())
            {
                printf("not possible\n");
            }
            else
            {
                sort(p.begin(),p.end());
                printf("possible option:");
                printf("(%d,%d)",p[0].from,p[0].to);
                for(int i=1;i<p.size();++i)
                {
                    printf(",(%d,%d)",p[i].from,p[i].to);
                }
                printf("\n");
            }
        }
    }
    return 0;
}