Uva 11248 Frequency Hopping（最大流）

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

思路：先跑一次最大流，如果结果 >= C那么结果是可行的，否则，如果存在某条边满足条件，那么那条边一定是割边，再对求完最大流后的割边枚举，看条件是否满足，

再次求最大流的时候需要保存第一次求完最大流后的结果

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
const int maxn = 1e2 + 10;
const int INF = 2 * 1e9 + 1e2;
using namespace std;

struct P {
    int to, cap, rev;
    P() {}
    P(int t, int c, int r) : to(t), cap(c), rev(r) {}
};

struct E {
    int from, to;
    E() {}
    E(int f, int t) : from(f), to(t) {}
    bool operator < (E p) const {
        if(from != p.from) return from < p.from;
        return to < p.to;
    }
    bool operator == (E p) const {
        return to == p.to && from == p.from;
    }
};
int n, m, C, u, v, tt = 1;
int have, num, maxf, limit;
int nec[maxn][maxn];
int lv[maxn], it[maxn];
int Cap[maxn][maxn];
E ed[maxn * maxn];
vector<P> G[maxn];
map<int, int> cap[maxn];

void init() {
    have = num = limit = maxf = 0;
    memset(nec, 0, sizeof(nec));
    memset(Cap, 0, sizeof(Cap));
    for(int i = 0; i < maxn; i++) {
        G[i].clear();
        cap[i].clear();
    }
}

void add(int f, int t, int c) {
    G[f].push_back(P(t, c, G[t].size()));
    G[t].push_back(P(f, 0, G[f].size() - 1));
}

bool bfs(int s, int t) {
    memset(lv, -1, sizeof(lv));
    queue<int> q; q.push(s);
    lv[s] = 0;
    while(!q.empty()) {
        int u = q.front(); q.pop();
        for(int i = 0; i < G[u].size(); i++) {
            P &e = G[u][i];
            if(lv[e.to] < 0 && e.cap > 0) {
                lv[e.to] = lv[u] + 1;
                q.push(e.to);
            }
        }
    }
    return lv[t] != -1;
}

int dfs(int v, int t, int f) {
    if(v == t) return f;
    for(int &i = it[v]; i < G[v].size(); i++) {
        P &e = G[v][i];
        if(lv[e.to] <= lv[v] || !e.cap) continue;
        int c = dfs(e.to, t, min(e.cap, f));
        if(!c) continue;
        e.cap -= c;
        G[e.to][e.rev].cap += c;
        return c;
    }
    return 0;
}

int maxflow(int s, int t) {
    int f = 0;
    while(1) {
        if(!bfs(s, t)) return f;
        memset(it, 0, sizeof(it));
        int fl;
        while((fl = dfs(s, t, INF)) > 0)  {
            f += fl;
            if(maxf + f >= C) return f;
        }
    }
}

int main() {
    while(scanf("%d %d %d", &n, &m, &C) && n) {
        init();
        for(int i = 0; i < m; i++) {
            int c;
            scanf("%d %d %d", &u, &v, &c);
            nec[u][v] = 1;
            Cap[u][v] += c;
        }
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= n; j++) {
                if(!Cap[i][j] || i == j) continue;
                add(i, j, Cap[i][j]);
            }
        }
        int maxf = maxflow(1, n);
        if(maxf >= C) have = 1;
        printf("Case %d: ", tt++);
        if(have) { printf("possible\n"); continue; }

        for(int i = 1; i <= n; i++)
            for(int j = 0; j < G[i].size(); j++)
                cap[i][j] = G[i][j].cap;

        for(int i = 1; i <= n; i++) {
            for(int j = 0; j < G[i].size(); j++) {
                P &e = G[i][j];
                if(e.cap || !nec[i][e.to]) continue;
                e.cap = INF;
                int res = maxflow(1, n);
                for(int ii = 1; ii <= n; ii++) {
                    for(int jj = 0; jj < G[ii].size(); jj++) {
                        P &st = G[ii][jj];
                        st.cap = cap[ii][jj];
                    }
                }
                if(res + maxf < C) continue;
                have = 1;
                ed[num++] = E(i, e.to);
            }
        }
        if(!have) printf("not possible\n");
        else {
            sort(ed, ed + num);
            num = unique(ed, ed + num) - ed;
            printf("possible option:");
            for(int i = 0; i < num; i++) {
                printf("(%d,%d)", ed[i].from, ed[i].to);
                if(i < num - 1) printf(",");
                else printf("\n");
            }
        }
    }
    return 0;
}