HDU6582 最短路+最小割

HDU6582 最短路+最小割

给我们一个有向图，现在破坏一条边的花费就是这个边的边长。
现在要求让我们破坏一些边然后使得1到n的距离变大而且要花费最小。当然把1–n弄的不连通也是合理的。

被队友误导了，写了两发次短路，后来一想跟次短路有屁关系
实际上我们想让1–n 的路径长度增加，就必须阻断所有最短路。
那么问题转化为了一个最短路径网络，要我们删一些边
使得S / T 不连通 OK 很显然的最大流最小割定理的应用
直接跑一次最短路 然后重新建图 用Dinic即可

const int N=1e5+3,M=5*1e6+3;
int x,y,z,o=1,n,m,h,t,st,ed,Q[N],cur[N],dis[N],head[N];long long maxflow;
struct QAQ{int to,next,flow;}a[M<<1];
inline void in(Re &x){
    int f=0;x=0;char c=getchar();
    while(c<'0'||c>'9')f|=c=='-',c=getchar();
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();
    x=f?-x:x;
}
inline void add(Re x,Re y,Re z){a[++o].flow=z,a[o].to=y,a[o].next=head[x],head[x]=o;}
inline int bfs(Re st,Re ed){//bfs求源点到所有点的最短路
    for(Re i=0;i<=n;++i)cur[i]=head[i],dis[i]=0;//当前弧优化cur=head
    h=1,t=0,dis[st]=1,Q[++t]=st;
    while(h<=t){
        Re x=Q[h++],to;
        for(Re i=head[x];i;i=a[i].next)
            if(a[i].flow&&!dis[to=a[i].to]){
                dis[to]=dis[x]+1,Q[++t]=to;
                if(to==ed)return 1;
            }
    }
    return 0;
}
inline int dfs(Re x,Re flow){//flow为剩下可用的流量
    if(!flow||x==ed)return flow;//发现没有流了或者到达终点即可返回
    Re tmp=0,to,f;
    for(Re i=cur[x];i;i=a[i].next){
        cur[x]=i;//当前弧优化cur=i
        if(dis[to=a[i].to]==dis[x]+1&&(f=dfs(to,min(flow-tmp,a[i].flow)))){
//若边权为0，不满足增广路性质，或者跑下去无法到达汇点，dfs返回值f都为0，不必执行下面了
            a[i].flow-=f,a[i^1].flow+=f;
            tmp+=f;//记录终点已经从x这里获得了多少流
            if(!(flow-tmp))break;
//1. 从st出来流到x的所有流被榨干。后面的边都不用管了，break掉。
//而此时边i很可能还没有被榨干，所以cur[x]即为i。
//2. 下面儿子的容量先被榨干。不会break，但边i成了废边。
//于是开始榨x的下一条边i'，同时cur[x]被更新成下一条边i'
//直至榨干从x上面送下来的水流结束（即情况1）。
        }
    }
    return tmp;
}
inline void Dinic(Re st,Re ed){
    Re flow=0;
    while(bfs(st,ed))maxflow+=dfs(st,inf);
}


const int manx=1e5+500;
const int mamx=1e6+500;
ll headp[manx],d[manx];
bool vis[manx];
ll k=0,s;
struct node{
    ll v,next,w,u;
}ap[mamx];
void adddij(ll u,ll v,ll w)
{
    ap[++k].next=headp[u];
    ap[k].w=w;
    ap[k].u=u;
    ap[k].v=v;
    headp[u]=k;
}
void dij()
{
    memset(d,inf,sizeof(d));
    memset(vis,0,sizeof(vis));
    //for(int i=1;i<=10010;i++){
    //    d[i]=inf;
    //    vis[i]=0;
   // }
    d[s]=0;
    priority_queue<pair<ll,ll> >q;
    q.push(mp(0,s));
    while(q.size()){
        ll u=q.top().se;
        q.pop();
        if(vis[u]) continue;
        vis[u]=1;
        for(int i=headp[u];i;i=ap[i].next){
            ll v=ap[i].v,w=ap[i].w;
           if(d[v]>d[u]+w){
          //printf("qwq %lld\n",d[v]);      //松弛操作，更新距离
            d[v]=d[u]+w;
           // printf("sad %lld %lld %lld %lld\n",d[u],u,res,d[v]);
            q.push(mp(-d[v],v)); //把更新的距离和点入队，这里距离取负变成小根堆
            }

}
}

}
int main(){
ll t;
read(t);
while(t--){
 for(int i=1;i<=100100;i++){
    headp[i]=0;
    head[i]=0;
}
 k=0;
 maxflow=0;
 o=1;
ll sb,sp;
read(n);
read(m);
 for(int i=1;i<=m;i++){
    ll u,v,w;
    read(u);
    read(v);
    read(w);
 adddij(u,v,w);
 }
 st=1;
 ed=n;
 //read(st);
 //read(ed);
 s=st;
 dij();
if(d[ed]==inf){
    printf("0\n");
    continue;
}
for(int i=1;i<=m;i++){
  ll x=ap[i].u;
  ll y=ap[i].v;
  ll z=ap[i].w;
  if(d[y]==d[x]+z){
 add(x,y,z);
 add(y,x,0);
   continue;
   }
}
  Dinic(st,ed);
printf("%lld\n",maxflow);
}
return  0;
}