uva11248 最短路增广 Dinic算法

分析：刘汝佳蓝书例题

先求一次最大流，如果流量至少为C，输出possible。否则需要修改的弧一定是最小割里的弧。依次把这些弧的容量增加到C，再求最大流，看最大流量是否为C即可。

还有两个优化，求完最大流后把流量留着，在此基础增广。第二，没必要每次求出最大流，增广到流量大于等于C就可以退出。

代码如下：

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

struct Edge{
    int from,to,cap,flow;
};
const int INF = 2000000000+200;
const int maxn = 105;
vector<int>G[maxn];
int n,E,c,s,t;
int sz;
vector<Edge>edges;
queue<int>que;

bool vis[maxn]; //BFS使用
int d[maxn]; //从起点到i的距离
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});
     sz = edges.size();
     G[from].push_back(sz-2);
     G[to].push_back(sz-1);
}

void init(){
    for (int i=0; i<=n; i++) G[i].clear();
    s = 1; t = n;
    edges.clear();

    int x,y,fp;
    for (int i=1; i<=E; i++) {
        scanf("%d %d %d",&x,&y,&fp);
        AddEdge(x,y,fp);
    }

}

bool BFS(){
    memset(vis,0,sizeof(vis));
    while (!que.empty()) que.pop();
    que.push(s);
    vis[s] = 1;
    d[s] = 0;

    int x;
    while (!que.empty()){
        x = que.front();
        que.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;
                que.push(e.to);
            }
        }
    }

    return vis[t];
}

inline int MIN(int x, int y){return x<y?x:y;}

int DFS(int x, int a){
   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)))>0){
                e.flow += f;
                edges[G[x][i]^1].flow -= f;
                a -= f;
                flow += f;
                if (a==0) break;
       }
   }
   return flow;
}

int MAXflow(int s, int t){
    int flow = 0;
    while (BFS()){
        memset(cur,0,sizeof(cur));
        flow += DFS(s,INF);
    }
    return flow;
}

vector<int>cut;
void Mincut(){
   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 kase = 0;
vector<Edge> ans;

bool cmp(Edge x, Edge y){
    return x.from<y.from || (x.from==y.from && x.to < y.to);
}

void Print(){
    if (ans.empty()) printf("Case %d: not possible\n",kase);
    else {
        sort(ans.begin(),ans.end(),cmp);
        printf("Case %d: possible option:(%d,%d)",kase,ans[0].from,ans[0].to);
        for (int i=1; i<ans.size(); i++) printf(",(%d,%d)",ans[i].from,ans[i].to);
        printf("\n");
    }
}

int main(){
    while (scanf("%d %d %d",&n,&E,&c) && n+E+c){
        init();
        int Flow = MAXflow(s,t);
        ++kase;
        if (Flow>=c) printf("Case %d: possible\n",kase);
        else {
            Mincut();
            for (int i=0; i<edges.size(); i++) edges[i].cap -= edges[i].flow;
            ans.clear();
            for (int i=0; i<cut.size(); i++) {
                Edge &e = edges[cut[i]];
                e.cap = c;
                for (int i=0; i<edges.size(); i++) edges[i].flow = 0;

                if (Flow+MAXflow(s,t)>=c) ans.push_back(e);
                e.cap = 0;
            }
            Print();
        }
    }
    return 0;
}