hdu 5294 Tricks Device（最短路+网络流（最小割））

Tricks Device

题目链接：

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

解题思路：

n个点，m条边，构建有权无向图。
求出删去最少条边数可以使得图没有最短路径，以及删出最多条边使得图仍有最多条路径。

官方题解：

最短路寻找道路边数最少的最短路，总边数减去最少条数为第二个问答案。

根据在最短路上的边构造每条边流量为1的新图，对新图最大流为第一问答案。

最短路处理出最短路径图，做法是使用dis数组，若dis[v]-dis[u] == w(u,v)，则该路在最短路径中。
建出最短路径之后 跑一次网络流，得到第一个答案。
在跑最短路中记录最短路的最少路数：m - minv.

AC代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#define INF 0xfffffff
using namespace std;

const int MAX_V = 2005;
int n,m;
//用于表示边的结构体（终点，容量，反向边）
struct edge{
    int to,cap,rev;
};
struct node{
    int x,l;
};
vector<node> ve[MAX_V];
int dis[MAX_V];
int minv[MAX_V];
vector<edge> G[MAX_V];//图中邻接表表示
bool used[MAX_V];//DFS中用到的访问标记

//向图中增加一条从s到t容量为cap的边
void add_edge(int from,int to,int cap){
    G[from].push_back((edge){to,cap,G[to].size()});
    G[to].push_back((edge){from,0,G[from].size()-1});
}

void build(){
    for(int i = 1; i <= n; i++){
        int l = ve[i].size();
        for(int j = 0; j < l; j++){
            int v = ve[i][j].x,w = ve[i][j].l;
            if(dis[v] - dis[i] == w){
                add_edge(i,v,1);
            }
        }
    }
}

//通过DFS寻到增广路
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++){
        edge &e = G[v][i];
        if(!used[e.to] && e.cap > 0){
            int d = dfs(e.to,t,min(f,e.cap));
            if(d > 0){
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

//求解从s到t的最大流
int max_flow(int s,int t){
    int flow = 0;
    while(1){
        memset(used,false,sizeof(used));
        int f = dfs(s,t,INF);
        if(f == 0)
            return flow;
        flow += f;
    }
}

void SPFA(int st){
    queue<int>  q;
    int i;
    memset(used,false,sizeof(used));
    memset(minv,0,sizeof(minv));
    for(i = 1; i <= n; i++)
        dis[i] = INF;
    dis[st] = 0;
    q.push(st);
    while(!q.empty()){
        int cur = q.front();
        q.pop();
        used[cur] = 1;
        int l = ve[cur].size();
        for(i = 0; i < l; i++){
            int tmp = ve[cur][i].x;
            if(dis[tmp] == dis[cur] + ve[cur][i].l){
                minv[tmp] = min(minv[tmp],minv[cur]+1);
                if(!used[tmp]){
                    q.push(tmp);
                    used[tmp] = 1;
                }
            }
            if(dis[tmp] > dis[cur] + ve[cur][i].l){
                minv[tmp] = minv[cur]+1;
                dis[tmp] = dis[cur] + ve[cur][i].l;
                if(!used[tmp]){
                    q.push(tmp);
                    used[tmp] = 1;
                }
            }
        }
        used[cur] = 0;
    }
}

int main(){
    while(~scanf("%d%d",&n,&m)){
        int u,v,w;
        for(int i = 1; i <= n; i++){
            G[i].clear();
            ve[i].clear();
        }
        for(int i = 0; i < m; i++){
            scanf("%d%d%d",&u,&v,&w);
            ve[u].push_back((node){v,w});
            ve[v].push_back((node){u,w});
        }
        SPFA(1);
        build();
        int ans = max_flow(1,n);
        printf("%d %d\n",ans,m-minv[n]);
    }
    return 0;
}