HDU 5294 - Tricks Device(最短路+最小割)

题目：

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

题意：

n个点，m条边，构建有权无向图。

求出删去最少条边数可以使得图没有最短路径，以及删出最多条边使得图仍有最多条路径。

思路：

最短路处理出最短路径图，做法是使用dis数组，若若dis[v]-dis[u] = w(u,v)，则该路在最短路径中。

建出最短路径之后 跑一次网络流，得到第一个答案。

在跑最短路中记录最短路的最少路数，ans2 = m - minb.

AC.

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

using namespace std;
const int INF = 0x7f7f7f;
const int MAXM = 12e4+5;
const int MAXN = 2e3+5;

int n, m;
struct Edge {
    int to, w, next;
}edge[MAXM];
int tot, head[MAXN];
void addedge(int u, int v, int w)
{
    edge[tot].to = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;

    edge[tot].to = u;
    edge[tot].w = w;
    edge[tot].next = head[v];
    head[v] = tot++;

}

int dis[MAXN], vis[MAXN];
int minb[MAXN];
int spfa(int s)
{
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    memset(minb, 0x3f, sizeof(minb));

    queue<int> q;
    dis[s] = 0;
    minb[s] = 0;
    vis[s] = 1;
    q.push(s);

    while(!q.empty()) {
        int u = q.front(); q.pop();
        vis[u] = 0;

        for(int i = head[u]; ~i; i = edge[i].next) {
            int v = edge[i].to, w = edge[i].w;
            if(dis[v] == dis[u] + w) {
                minb[v] = min(minb[v], minb[u] + 1);
                if(!vis[v]) {
                    vis[v] = 1;
                    q.push(v);
                }
            }
            if(dis[v] > dis[u] + w) {
                dis[v] = dis[u] + w;
                minb[v] = minb[u] + 1;
                if(!vis[v]) {
                    vis[v] = 1;
                    q.push(v);
                }
            }
        }
    }
}
struct Eg {
    int u, cap, rev;
    Eg(int uu, int cc, int rr) {
        u = uu; cap = cc; rev = rr;
    }
};
vector<Eg> G[MAXN];
bool used[MAXN];
void add(int u, int v, int cap)
{
    G[u].push_back(Eg(v, cap, G[v].size()));
    G[v].push_back(Eg(u, 0, G[u].size()-1));
}
void build()
{
    for(int i = 1; i <= n; ++i) {
        for(int j = head[i]; ~j; j = edge[j].next) {
            int v = edge[j].to, w = edge[j].w;
            if(dis[v] - dis[i] == w) {
                add(i, v, 1);
            }
        }
    }
}
int dfs(int v, int t, int f)
{
    if(v == t) return f;
    used[v] = true;
    for(int i = 0; i < G[v].size(); ++i) {
        Eg &e = G[v][i];
        if(!used[e.u] && e.cap > 0) {
            int d = dfs(e.u, t, min(f, e.cap));
            if(d > 0) {
                e.cap -= d;
                G[e.u][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s, int t)
{
    int flow = 0;
    while(1) {
        memset(used, 0, sizeof(used));
        int f = dfs(s, t, INF);
        if(f == 0) return flow;
        flow += f;
    }
}
void init()
{
    tot = 0;
    memset(head, -1, sizeof(head));
    for(int i = 0; i <= n; ++i) {
        G[i].clear();
    }

}
int main()
{
    //freopen("in", "r", stdin);
    while(~scanf("%d %d", &n, &m)) {
        init();
        for(int i = 0; i < m; ++i) {
            int u, v, w;
            scanf("%d %d %d", &u, &v, &w);
            addedge(u, v, w);
        }

        spfa(1);
        build();
        int ans = max_flow(1, n);

        printf("%d %d\n", ans, m-minb[n]);
    }
    return 0;
}