UVA 11248 Frequency Hopping

UVA 11248 Frequency Hopping

网络流

题意

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

思路

先求一次最大流，如果流量至少为C，则直接输出possible，否则需要修改的弧一定是最小割里的弧。依次把这些弧的容量增加到C，然后再求最大流，看最大流量是否至少为C即可。
很可惜，这样写出来的程序会超时，还需要加两个重要的优化。第一个优化是求完最大流后把流量留着，以后每次在它的基础上增广，第二个优化是每次没必要求出最大流，增广到流量至少为C时就停下来。

代码

#include<bits/stdc++.h>
#define M(a,b) memset(a,b,sizeof(a))
typedef long long LL;
const int MAXN=1007;
const int oo=0x3f3f3f3f;
using namespace std;
struct Dinic
{
    struct Edge
    {
        int from, to;int cap, flow;//cap容量 flow流量
        Edge() {}
        Edge(int u, int v, int c, int f) { from=u;to=v;cap=c;flow=f; }
    };
    vector<Edge> edges;//顺序的插入边
    vector<int> G[MAXN];//保存边号
    bool vis[MAXN];//BFS使用
    int d[MAXN];
    int cur[MAXN];
    void init(int n=MAXN-1)
    {
        memset(d, 0, sizeof(d));
        for(int i=1;i<=n;i++) G[i].clear();
        edges.clear();
    }

    void AddEdge(int from, int to, int cap)
    {
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));//单向边第三个参数写0，双向边写cap
        int t_m=edges.size();
        G[from].push_back(t_m-2);
        G[to].push_back(t_m-1);
    }

    bool BFS(int s, int t)
    {
        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, int s, int t)
    {
        if(x==t||a==0) return a;
        int flow=0, _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), s, t))>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, int c)
    {
        int flow=0;
        while(BFS(s, t))
        {
            memset(cur, 0, sizeof(cur));
            flow+=DFS(s, oo, s, t);
            if(flow>=c) return flow;//优化,流大于等于C就不在增广
        }
        return flow;
    }
    void dfs(int s, bool* vis, int op)
    {
        vis[s]=1;
        for(int i=0;i<G[s].size();i++)
        {
            int e=G[s][i];
            int to=edges[e].to;
            if(!vis[to]&&edges[e^op].flow!=edges[e^op].cap)
                dfs(edges[e].to, vis, op);
        }
    }
    void basic()//保留原始流
    {
        for(auto &e:edges)
        {
            e.cap-=e.flow;
        }
    }
    void set()//清空流
    {
        for(auto &e:edges)
        {
            e.flow=0;
        }
    }
}dinic;
bool vis1[MAXN], vis2[MAXN];
bool cmp(pair<int, int> a, pair<int, int> b)
{
    return a.first==b.first ? a.second<b.second : a.first<b.first;
}
int main()
{
    int n, e;int c;int cas=0;
    while(scanf("%d%d%d", &n, &e, &c)==3&&(n+e+c))
    {
        dinic.init(n);
        for(int i=1;i<=e;i++)
        {
            int u, v, cap;scanf("%d%d%d", &u, &v, &cap);
            dinic.AddEdge(u, v, cap);
        }
        int res=dinic.Maxflow(1, n, c);
        if(res>=c) printf("Case %d: possible\n", ++cas);
        else
        {
            vector<int> vec;
            memset(vis1, 0, sizeof(vis1));memset(vis2, 0, sizeof(vis2));
            dinic.dfs(1, vis1, 0);
            dinic.dfs(n, vis2, 1);
            for(int i=0;i<dinic.edges.size();i+=2)
            {
                int from=dinic.edges[i].from;
                int to=dinic.edges[i].to;
                if(vis1[from]&&vis2[to])
                {
                    if(dinic.edges[i].cap!=0&&dinic.edges[i].flow==dinic.edges[i].cap)
                    {
                        vec.push_back(i);
                    }
                }
            }
            dinic.basic();
            vector<pair<int, int>> ans;
            for(auto u:vec)
            {
                dinic.set();
                dinic.edges[u].cap=c;
                if(dinic.Maxflow(1, n, c)+res>=c)
                    ans.push_back(make_pair(dinic.edges[u].from, dinic.edges[u].to));
                dinic.edges[u].cap=0;
            }
            if(ans.size()==0)
            {
                printf("Case %d: not possible\n", ++cas);
            }
            else
            {
                sort(ans.begin(), ans.end(), cmp);
                printf("Case %d: possible option:(%d,%d)", ++cas, ans[0].first, ans[0].second);
                for(int i=1;i<ans.size();i++)
                {
                    printf(",(%d,%d)", ans[i].first, ans[i].second);
                }
                printf("\n");
            }
        }
    }
    return 0;
}