HDU - 5889 Barricade 网络流最大流-最小割+最短路

题目链接

题意：有n个城市，长度相同的m条路，上将位于1号城，敌人军队位于n号城，现在可以得知军队只会走从n到1的最短路径，所以上将决定在这些路径上放置障碍(在相应的道路上放置障碍需要消耗相应的w)，要求让军队至少碰到一次障碍的同时花费最小。

思路：由于只会走最短路，那先跑一遍最短路把会走的边都挑出来，然后就是求最小割的模板题了。

最小割：求完最大流之后，按照bfs源点是否能到达分为两个点集，连接两个点集的正向边的容量和即为最小割且大小=最大流。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<string>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define PI acos(-1)
#define INF 0x3f3f3f3f
#define NUM 10100
#define debug true
#define lowbit(x) ((-x)&x)
#define ffor(i,d,u) for(int i=d;i<=u;++i)
#define _ffor(i,u,d) for(int i=u;i>=d;--i)
#define mst(array,Num) memset(array,Num,sizeof(array))
const int p = 1e9+7;
int n,m,maxflow;
int head[NUM/10],d[NUM/10]={},num[NUM/10]={},ednum,dist[NUM/10];
struct edge
{
    int next,to,w;
}e[NUM<<1];
struct Vertex
{
    int id,dis;
    operator>(const Vertex &x)const
    {
        return dis > x.dis ;
    }
};
void read(int &x){
    char ch = getchar();x = 0;
    for (; ch < '0' || ch > '9'; ch = getchar());
    for (; ch >='0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
}
template <typename T>
void write(T x)
{
    int len=0;char c[21];
    if(x<0)putchar('-'),x*=(-1);
    do{++len;c[len]=(x%10)+'0';}while(x/=10);
    _ffor(i,len,1)putchar(c[i]);
}
inline void bfs()
{
    int x,y;
    ffor(i,1,n)d[i]=INF;
    queue < int > q;
    q.push(n),++num[d[n]=1];
    while(!q.empty())
    {
        x=q.front();q.pop();
        for(int i=head[x];i!=-1;i=e[i].next)
        {
            y=e[i].to;
            if(d[y]!=INF||e[i].w!=0)continue;
            ++num[d[y]=d[x]+1];
            q.push(y);
        }
    }
}
int dfs(int vertex,int minx)
{
    if(!minx||vertex==n)return minx;
    int f,x,flow=0;
    for(int i=head[vertex];i!=-1;i=e[i].next)
    {
        x=e[i].to;
        if(fabs(dist[vertex]-dist[x])==1&&d[vertex]==d[x]+1&&(f=dfs(x,min(minx,e[i].w))))//只计算最短路上的边
        {
            minx-=f,flow+=f,e[i].w-=f,e[i^1].w+=f;
            if(!minx)return flow;
        }
    }
    if(!(--num[d[vertex]]))d[1]=n+1;
    ++num[++d[vertex]];
    return flow;
}
inline void ISAP()
{
    bfs();
    while(d[1]<=n)maxflow+=dfs(1,INF);
    write(maxflow);
}
inline void Dij()
{
    priority_queue < Vertex , vector < Vertex > , greater < Vertex > > q;
    Vertex x,y;
    x.id=1,dist[1]=x.dis=0;
    q.push(x);
    while(!q.empty())
    {
        x=q.top(),q.pop();
        if(x.dis>dist[x.id])continue;
        for(int i=head[x.id] ; i!=-1 ; i=e[i].next)
        {
            y.id = e[i].to;
            if(dist[y.id] > dist[x.id] + 1)
            {
                y.dis = dist[y.id] = dist[x.id] + 1;
                q.push(y);
            }
        }
    }
}
inline void AC()
{
    int x,y,wei,t;
    read(t);
    while(t--)
    {
        read(n),read(m);
        maxflow=0,ednum=-1,mst(head,-1),mst(dist,INF);
        ffor(i,1,m)
        {
            read(x),read(y),read(wei);
            e[++ednum].to=y,e[ednum].w=wei,e[ednum].next=head[x],head[x]=ednum;
            e[++ednum].to=x,e[ednum].w=0,e[ednum].next=head[y],head[y]=ednum;
        }
        Dij();
        ffor(i,1,n)
            for(int j = head[i] ; j != -1 ; j = e[j].next)//根据挑出的边重新设置正向边和反向边
                if(dist[i] > dist[e[j].to])
                    e[j^1].w += e[j].w , e[j].w = 0 ;
        ISAP();
        putchar('\n');
    }
}
int main()
{
    AC();
    return 0;
}