hdu 5889 Barricade （最短路+最小割）

        题意：N个点M 条路径，每条路径长度为1，敌人从N节点进攻1节点。敌人只会选择最短路径进攻（所有最短路中的一条）， 要封死所有可能的路径。

路径长度为都为1。

无向图，每条路都有一个封死所需的花费数。

分析：

       1.先找出所有最短路。

    2.根据所有最短路建新图，流量为花费，求最大流，得到最小割，即为最小花费。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<vector>
#include<cctype>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<iomanip>
#include<sstream>
#include<limits>
#define ll long long
#define inf 0x3f3f3f3f
using namespace std;
const int maxn = 1e5+10;
const ll MOD = 1000000007;
const double EPS = 1e-10;
const double Pi = acos(-1.0);
struct edge{int to,cost,w;};
typedef pair<int,int>P; //1 dist 2 u
int V;
vector<edge>g[maxn];
int d[maxn];
void dij(int s)
{
    priority_queue<P,vector<P>,greater<P> >que;
    fill(d,d+V+1,inf);
    d[s] = 0;
    que.push(P(0,s));
    while(!que.empty())
    {
        P p = que.top(); que.pop();
        int v = p.second;
        if (d[v] < p.first) continue;
        for(int i = 0; i < g[v].size();i++)
        {
            edge e = g[v][i];
            if (d[e.to] > d[v] + e.cost)
            {
                d[e.to] = d[v] + e.cost;
                que.push(P(d[e.to],e.to));
            }
        }
    }
}


#define INF 0x7fffffff

struct Edge{
    int to , cap,rev;  // rev反向边
};
vector<Edge>G[maxn];
int level[maxn],iter[maxn];  // 顶点到源点的标号   当前弧
void add_edge(int from,int to,int cap) //cap容量
{
    G[from].push_back((Edge){to,cap,G[to].size()});
    G[to].push_back((Edge){from,0,G[from].size()-1 });
}
void bfs(int s) // 分层
{
    memset(level,-1,sizeof(level));
    queue<int>que;
    level[s] = 0;
    que.push(s);
    while(!que.empty())
    {
        int v = que.front();que.pop();
        for(int i = 0; i < G[v].size(); i++)
        {
            Edge &e = G[v][i];
            if (e.cap>0 && level[e.to] < 0)
            {
                level[e.to] = level[v]+1;
                que.push(e.to);
            }
        }
    }
}
int dfs(int v, int t, int f) //寻增广路
{
    if (v==t) return f;
    for(int &i = iter[v]; i < G[v].size(); i++)
    {
        Edge &e = G[v][i];
        if (e.cap > 0 && level[v] < level[e.to])
        {
            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;
}
int max_flow(int s, int t) // s到t最大流
{
    int flow = 0;
    for(;;)
    {
        bfs(s);
        if (level[t] < 0) return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f = dfs(s,t,INF)) > 0) { flow += f;}
    }
}

int main(){
#ifdef LOCAL
	freopen("C:\\Users\\lanjiaming\\Desktop\\acm\\in.txt","r",stdin);
	//freopen("output.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0);
    int T,n,m;
    cin>>T;
    while(T--)
    {
        cin>>n>>m;
        V = n;
        for(int  i = 0; i <= n; i++) g[i].clear();
        for(int i = 0; i < m; i++)
        {
            int u,v,w;
            cin>>u>>v>>w;
            g[u].push_back({v,1,w});
            g[v].push_back({u,1,w});
        }
        dij(1);
        for(int i= 0; i <= n; i++) G[i].clear();
        for(int i = 1;i <= n; i++)            //枚举出最短路径。建图。
            for(int j = 0;j < g[i].size(); j++)
                {
                    edge e = g[i][j];
                    if(d[i] + e.cost == d[e.to])
                    {
                         add_edge(i,e.to,e.w);
                        // add_edge(e.to,i,e.w);   //没注意，边加多了，WA了一发。
                    }
                }
        cout<<max_flow(1,n)<<endl;
    }

    return 0;
}