【最小割】HDU 5294 Tricks Device

通道：http://acm.hdu.edu.cn/showproblem.php?pid=5294

题意：n个点,m条边的无向图，起点1，终点n，求1到n至少删除多少条边使得走不到，和最多删除多少条边使得依然有路（（删不是最短路上边的图后））。

代码：裸--

#include <cstdio>
#include <cstring>
#include <queue>
#include <iostream>
#include <algorithm>

using namespace std;

const int MAX_N = 3007;
const int MAX_M = 200007;
const int INF = 0x3f3f3f3f;

struct Node {
    int u, v, nxt;
    long long cap;
    Node () {}
    Node (int _u, int _v, int _n, long long _c) {
        u = _u;
        v = _v;
        nxt = _n;
        cap = _c;
    }
};

struct Isap {
    int n, s, t;
    int edgecnt;
    int head[MAX_N], d[MAX_N], gap[MAX_M << 2];
    Node G[MAX_M << 2];
    void init(int n, int s, int t) {
        this->n = n, this->s = s, this->t = t;
        edgecnt = 0;
        memset(head, -1, sizeof head);
    }
    void addedge(int u, int v, long long cap) {
        G[edgecnt] = Node(u, v, head[u], cap);
        head[u] = edgecnt++;
        G[edgecnt] = Node(v, u, head[v], 0);
        head[v] = edgecnt++;
    }
    long long dfs(int u, long long tot) {
        if (u == t) return tot;
        int minh = n - 1;
        long long leave = tot;
        for (int i = head[u]; ~i && leave; i = G[i].nxt) {
            int v = G[i].v;
            if (G[i].cap > 0) {
                if (d[v] + 1 == d[u]) {
                    long long c = dfs(v, min(leave, G[i].cap));
                    G[i].cap -= c;
                    G[i ^ 1].cap += c;
                    leave -= c;
                    if (d[s] >= n) 
                        return tot - leave;
                }
                minh = min(minh, d[v]);
            }
        }
        if (leave == tot) {
            --gap[d[u]];
            if (gap[d[u]] == 0) d[s] = n;
            d[u] = minh + 1;
            ++gap[d[u]];
        }
        return tot - leave;
    }
    long long maxFlow() {
        long long ret = 0;
        memset(gap, 0, sizeof gap);
        memset(d, 0, sizeof d);
        gap[0] = n;
        while (d[s] < n) {
            ret += dfs(s, INF);
        }
        return ret;
    }
};

int n, m;
int head[MAX_N], edgecnt1, edgecnt2, head2[MAX_N];
int d1[MAX_N], d2[MAX_N], cnt[MAX_N];
Node G[MAX_M << 2], G2[MAX_M << 2];
bool vis[MAX_N];
queue<int> que;

void Clear() {
    edgecnt1 = 0;
    edgecnt2 = 0;
    memset(d1, 0, sizeof d1);
    memset(d2, 0, sizeof d2);
    memset(head, -1, sizeof head);
    memset(head2, -1, sizeof head2);
}

void add(int u, int v, int w) {
    G[edgecnt1] = Node(u, v, head[u], w);
    head[u] = edgecnt1++;
}

void add2(int u, int v, int w) {
    G2[edgecnt2] = Node(u, v, head2[u], w);
    head2[u] = edgecnt2++;
}

bool spfa(int u, int *d) {
    fill(d, d + n + 3, INF);
    memset(vis, false, sizeof vis);
    memset(cnt, 0, sizeof cnt);
    d[u] = 0; vis[u] = true;
    while (!que.empty()) que.pop();
    que.push(u);
    while (!que.empty()) {
        int u = que.front();vis[u] = false; que.pop();
        for (int e = head[u]; e != -1; e = G[e].nxt) {  
            int v = G[e].v;
            if (d[v] > d[u] + G[e].cap) {
                d[v] = d[u] + G[e].cap;
                if (!vis[v]) {
                    que.push(v); vis[v] = true;
                } 
                if (++cnt[v] > n) return false;
            }
        }
    }
}

int dp[MAX_N];

int cal() {
    fill(dp, dp + n + 3, INF);
    memset(vis, false, sizeof vis);
    memset(cnt, 0, sizeof cnt);
    dp[1] = 0; vis[1] = true;
    while (!que.empty()) que.pop();
    que.push(1);
    while (!que.empty()) {
        int u = que.front();vis[u] = false; que.pop();
        for (int e = head2[u]; e != -1; e = G2[e].nxt) {  
            int v = G2[e].v;
            if (dp[v] > dp[u] + 1) {
                dp[v] = dp[u] + 1;
                if (!vis[v]) {
                    que.push(v); vis[v] = true;
                } 
                if (++cnt[v] > n) return false;
            }
        }
    }
    if (dp[n] == INF) return 0;
    return dp[n];
}

Isap now;
int main() {
    while (2 == scanf("%d%d", &n, &m)) {
        Clear();
        now.init(n, 1, n);
        for (int i = 0; i < m; ++i) {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            add(u, v, w);
            add(v, u, w);
            
        }
        spfa(1, d1), spfa(n, d2);
        int way = 0;
        for (int i = 0; i < edgecnt1; i++) {
            int u = G[i].u, v = G[i].v;
            if (d1[u] + d2[v] + G[i].cap != d1[n]) continue;
            add2(u, v, G[i].cap);
            add2(v, u, G[i].cap);
            now.addedge(u, v, 1);
            now.addedge(v, u, 1);
            ++way;
        }
        int ans1 = now.maxFlow();
        int ans2 = m - cal();
        printf("%d %d\n", ans1, ans2);
    }
    return 0;
}

/*
2 1
1 2 3

8 10
1 2 2
2 3 2
2 4 1
3 5 3
4 5 4
5 8 1
1 6 2
6 7 5
7 8 1
1 8 2

5 6
1 2 2
1 3 1
2 3 1
2 5 2
2 4 1
4 5 1

9 11
1 2 1
2 3 1
2 4 1
1 5 1
5 6 1
5 7 1
3 8 1
4 8 1
6 8 1
7 8 1
8 9 1

*/