hdu 5296，15年多校1-7

题意：

　　给定一个无向带权图G（n， m），一个人要沿着最短路从1走到n，现在可以任意从图上删边。求，最少删多少边可以使之无法到达终点  和   最多删多少边其仍可以到达终点

想法：

　　比赛时的想法：直接跑最小费用最大流，spfa的时候维护一个最短路的值（min_dist），如果当前求得增广路径的最短路的值大于min_dist，肯定后面的最短路就都大于min_dist了，此时就已经求出最大流即第一问的答案了。在求增广路径的过程中维护所有最短路的最小边数，总边数减去最小边数就是即为第二问的答案。（没有觉得思路有什么问题，赛后对着数据，总是有两组跑的特别慢并且答案也是错的）。

　　后来按照标程写了一个，先一遍spfa求出所有最短录，并且得到最少边数。然后遍历所有边将最短路建图（这个图是根据最短路中dist值建的有向图），在新图上跑一遍最大流。结果两组数据还是过不去。

现记下来，回头补上。

武大训练第10场又挂了这个题，比赛时候补上了。

这是题解说的先最短路，重新建图再跑网络流的做法

2015-9-12 补充，费用流没法做，因为在求增广路的时候会改变图中最短路上边的数量。对网络流还是不够熟悉

#include <bits/stdc++.h>

const int MAXN = 2000+100;
const int MAXM = 200000+100;
const int INF = 0x3f3f3f3f;

typedef std::pair<int, int> pii;

struct Edge{
    int u, v, cap, next;
    Edge(){}
    Edge(int u, int v, int cap, int next)
    {
        this->u = u;
        this->v = v;
        this->cap = cap;
        this->next = next;
    }
}edge[MAXM];
int head[MAXN];
int tot;
std::vector<pii> ve[MAXN];
int dep[MAXN];
int n, m;
int dist[MAXN];
bool vis[MAXN];
int road[MAXN];

void addEdge(int u, int v, int cap)
{
    edge[++tot] = Edge(u, v, cap, head[u]);
    head[u] = tot;
}

int dfs(int u, int sink, int min_flow) 
{
    if (u == sink) {
        return min_flow;
    }
    int res = 0;
    for (int i = head[u]; i > 0 && min_flow > 0; i = edge[i].next) {
        if (dep[edge[i].v] == dep[u] + 1) {
            int dd = dfs(edge[i].v, sink, std::min(min_flow, edge[i].cap));
            edge[i].cap -= dd;
            edge[i^1].cap += dd;
            res += dd;
            min_flow -= dd;
        }
    }
    return res;
}

void bfs(int src, int sink)
{
    memset(dep, 0, sizeof dep);
    std::queue<int> que;
    que.push(src);
    dep[src] = 1;
    while (que.empty() == false) {
        int u = que.front();
        que.pop();
        for (int i = head[u]; i > 0; i = edge[i].next) {
            int v = edge[i].v;
            int cap = edge[i].cap;
            if (dep[v] == 0 && cap > 0) {
                dep[v] = dep[u] + 1;
                if (v == n) {
                    return;
                }
                que.push(v);
            }
        }
    }
}

int dinic(int src, int sink)
{
    int res = 0;
    while (true) {
        bfs(src, sink);
        if (dep[sink] == 0) {
            return res;
        }
        res += dfs(src, sink, INF);
    }
}

void init()
{
    tot = 1;
    memset(head, 0, sizeof head);
    for (int i = 1; i <= n; ++ i) {
        ve[i].clear();
    }
}

int main()
{
    while (~scanf("%d%d" , &n, &m)) {
        init();
        for (int i = 1; i <= m; ++ i) {
            int u, v, cost;
            scanf("%d%d%d", &u, &v, &cost);
            if (u == v) 
                continue;
            ve[u].push_back(std::make_pair(v, cost));
            ve[v].push_back(std::make_pair(u, cost));
        }
        memset(vis, false, sizeof vis);
        for (int i = 1; i <= n; ++ i) {
            dist[i] = INF;
            road[i] = INF;
        }
        dist[1] = 0;
        road[1] = 0;
        std::queue<int> que;
        que.push(1);
        vis[1] = true;
        while (que.empty() == false) {
            int u = que.front();
            que.pop();
            vis[u] = false;
            for (int i = 0; i < (int)ve[u].size(); ++ i) {
                int v = ve[u][i].first;
                if (dist[v] > dist[u] + ve[u][i].second) {
                    dist[v] = dist[u] + ve[u][i].second;
                    if (vis[v] == false ) {
                        vis[v] = true;
                        que.push(v);
                    }
                }
            }
        }

        que.push(1);
        memset(vis, false, sizeof vis);
        memset(road, 0x3f3f3f3f, sizeof road);
        road[1] = 0;
        vis[1] = true;
        while (que.empty() == false) {
            int u = que.front();
            que.pop();
            for (int i = 0; i < (int)ve[u].size(); ++ i) {
                int v = ve[u][i].first;
                int w = ve[u][i].second;
                if (dist[v] == dist[u] + w) {
                    addEdge(u, v, 1);
                    addEdge(v, u, 0);

                    vis[v] = true;
                    que.push(v);
                    road[v] = std::min(road[v], road[u] + 1);
                }
            }
        }
        int res2 =  m - road[n];
        int res1 = dinic(1, n);
        printf("%d %d
", res1, res2);    
    }
}