[最短路,最大流最小割定理] 2019 Multi-University Training Contest 1 Path

题目:http://acm.hdu.edu.cn/showproblem.php?pid=6582

Path

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 3747    Accepted Submission(s): 1075

Problem Description

Years later, Jerry fell in love with a girl, and he often walks for a long time to pay visits to her. But, because he spends too much time with his girlfriend, Tom feels neglected and wants to prevent him from visiting her.
After doing some research on the neighbourhood, Tom found that the neighbourhood consists of exactly n houses, and some of them are connected with directed road. To visit his girlfriend, Jerry needs to start from his house indexed 1 and go along the shortest path to hers, indexed n. 
Now Tom wants to block some of the roads so that Jerry has to walk longer to reach his girl's home, and he found that the cost of blocking a road equals to its length. Now he wants to know the minimum total cost to make Jerry walk longer.
Note, if Jerry can't reach his girl's house in the very beginning, the answer is obviously zero. And you don't need to guarantee that there still exists a way from Jerry's house to his girl's after blocking some edges.

 

Input

The input begins with a line containing one integer T(1≤T≤10), the number of test cases.
Each test case starts with a line containing two numbers n,m(1≤n,m≤10000), the number of houses and the number of one-way roads in the neighbourhood.
m lines follow, each of which consists of three integers x,y,c(1≤x,y≤n,1≤c≤109), denoting that there exists a one-way road from the house indexed x to y of length c.

 

Output

Print T lines, each line containing a integer, the answer.

 

Sample Input

1
3 4
1 2 1
2 3 1
1 3 2
1 3 3

 

Sample Output

3

 

Source

2019 Multi-University Training Contest 1

 

Recommend

We have carefully selected several similar problems for you:  6718 6717 6716 6715 6714 

题意:

给n个节点m条有向边,现在可以删去一些边,代价为边权,问最小代价删去一些边使得现在节点1到节点n的最短路不成立(如果1不可达n则答案为0)

思路:

可能有多条1到n的最短路,这些最短路组成图,以最小代价使图不连通就是求最小割,由最大流最小割定理可知,最小割等于最大流,所以我们先找出图中1到n的最短路新建一个图,在这个图上从1到n跑一边最大流就可求出答案
现在就是建图的问题,我们先得到1到n的最短路径dis[i],再得到n到1的最短路径dis1[i],再把原图中符合dis[u]+e[i].w+dis1[v]==dis[n](令e[i].w为节点u到v的边权)的边建一个新图,
在这个新图上从1到n跑一边dinic就可得到答案

注意:

调了一个下午,在bool operator(const node &a)const{return a.w<w;}中原来是要a.w<w才能让优先队列中w小的优先,如果是a.w>w则是w大的优先

 #include<bits/stdc++.h>
 typedef long long ll;
 using namespace std;
 const int amn=1e4+;
 const ll inf=1e18;
 struct edge{
     int from,to,nex;ll w;
 }eg[amn],eg1[amn],e[amn<<|];
 struct node{
     int p;
     ll w;
     node(int pp,ll ww){p=pp;w=ww;}
     bool operator<(const node &a)const{return a.w<w;}   ///调了一个下午,原来是要a.w<w才行,这样优先队列中才会w小的优先,如果是a.w>w则是w大的优先
 };
 ll head[amn],egn,head1[amn],egn1,n,m,dis[amn],dis1[amn],vis[amn],head2[amn],egn2;
 void init(int n){
     egn=,egn1=,egn2=;    ///egn2是跑最大流的,初始为1,这样就可以从2开始加边,这样正向边和反向边相邻储存,因为2^1=3,3^1=2...所以可以异或得到正向边反向边
     for(int i=;i<=n;i++)head2[i]=head1[i]=head[i]=;
 }
 void add(int u,int v,ll w){     ///正向图加边
     eg[++egn].nex=head[u];
     head[u]=egn;
     eg[egn].from=u;
     eg[egn].to=v;
     eg[egn].w=w;
 }
 void add1(int u,int v,ll w){    ///反向图加边
         eg1[++egn1].nex=head1[u];
         head1[u]=egn1;
         eg1[egn1].from=u;
         eg1[egn1].to=v;
         eg1[egn1].w=w;
     }
 void add2(int u,int v,ll w){    ///跑最大流的新图加边
         e[++egn2].nex=head2[u];
         head2[u]=egn2;
         e[egn2].from=u;
         e[egn2].to=v;
         e[egn2].w=w;
     }

 ///以1为起点跑最短路
 void dijkstra(int s){
     memset(vis,,sizeof vis);
     for(int i=;i<=n;i++)dis[i]=inf;
     dis[s]=;
     priority_queue<node> q;
     q.push(node(s,dis[s]));
     while(q.size()){
         int u=q.top().p;
         ll w=q.top().w;q.pop();
         if(w>dis[u])continue;
         vis[u]=;
         for(int i=head[u];i;i=eg[i].nex){
             int v=eg[i].to;
             if(!vis[v]&&((dis[v])>(eg[i].w)+(dis[u]))){
                 dis[v]=(eg[i].w)+dis[u];
                 q.push(node(v,(dis[v])));
             }
         }
     }
 }
 ///以n为起点跑最短路
 void dijkstra1(int s){
     memset(vis,,sizeof vis);
     for(int i=;i<=n;i++)dis1[i]=inf;
     dis1[s]=;
     priority_queue<node> q;
     q.push(node(s,dis1[s]));
     while(q.size()){
         int u=q.top().p;
         ll w=q.top().w;q.pop();
         if(w>dis1[u])continue;
         vis[u]=;
         for(int i=head1[u];i;i=eg1[i].nex){
             int v=eg1[i].to;
             if(!vis[v]&&((dis1[v])>(eg1[i].w)+(dis1[u]))){
                 dis1[v]=(eg1[i].w)+dis1[u];
                 q.push(node(v,(dis1[v])));
             }
         }
     }
 }
 ///dinic最大流
 queue<int> que;
 ll dist[amn],src=,sink=n;
 void bfs(){
     memset(dist,,sizeof dist);
     while(que.size())que.pop();
     vis[src]=;
     que.push(src);
     while(que.size()){
         int u=que.front();que.pop();
         for(int i=head2[u];i;i=e[i].nex){
             int v=e[i].to;//cout<<'>'<<e[i].w<<' '<<v<<endl;
             if(e[i].w&&!vis[v]){
                 que.push(v);
                 dist[v]=dist[u]+;
                 vis[v]=;
             }
         }
     }
 }
 int dfs(int u,ll delta){
     if(u==sink)return delta;
     int ret=;
     for(int i=head2[u];delta&&i;i=e[i].nex)
     if(e[i].w&&(dist[e[i].to]==dist[u]+)){
         ll dd=dfs(e[i].to,min(e[i].w,delta));
         e[i].w-=dd;
         e[i^].w+=dd;
         delta-=dd;
         ret+=dd;
     }
     return ret;
 }
 ll maxflow(){
     ll ret=;
     while(){
         memset(vis,,sizeof vis);
         bfs();
         if(!vis[sink])return ret;//cout<<'<'<<ret<<endl;
         ret+=dfs(src,inf);
     }
 }
 int main(){
     int T,x,y;ll c;
     scanf("%d",&T);
     while(T--){
         scanf("%lld%lld",&n,&m);
         init(n);            ///初始化
         src=,sink=n;       ///设置1为源点,n为汇点
         for(int i=;i<=m;i++){
             scanf("%d%d%lld",&x,&y,&c);
             add(x,y,c);     ///正向图,为了以1为起点跑最短路
             add1(y,x,c);    ///反向图,为了以n为起点跑最短路
         }
         dijkstra();        ///以1为起点的最短路
         if(dis[n]==inf){printf("0\n");continue;}    ///如果1到n不可达则输出0
         dijkstra1(n);       ///以n为起点的最短路
         for(int i=;i<=egn;i++){
 //            cout<<eg[i].from<<' '<<eg[i].to<<' '<<eg[i].w<<endl;
 //            cout<<dis[eg[i].from]<<' '<<eg[i].w<<' '<<dis1[eg[i].to]<<' '<<dis[n]<<endl<<endl;
             if(dis[eg[i].from]+eg[i].w+dis1[eg[i].to]==dis[n]){     ///如果1到现在这个点u的最短路径+u到v的边权+v到n的最短路径==1到n的最短路径则u到v这条边是最短路中的一条边
                 add2(eg[i].from,eg[i].to,eg[i].w);  ///建新图,加正向边
                 add2(eg[i].to,eg[i].from,);        ///边权为0的反向边
             }
         }
         printf("%lld\n",maxflow());     ///最大流等于最小割
     }
 }
 /**
 给n个节点m条有向边,现在可以删去一些边,代价为边权,问最小代价删去一些边使得现在节点1到节点n的最短路不成立(如果1不可达n则答案为0)
 可能有多条1到n的最短路,这些最短路组成图,以最小代价使图不连通就是求最小割,由最大流最小割定理可知,最小割等于最大流,所以我们先找出图中1到n的最短路新建一个图,在这个图上从1到n跑一边最大流就可求出答案
 现在就是建图的问题,我们先得到1到n的最短路径dis[i],再得到n到1的最短路径dis1[i],再把原图中符合dis[u]+e[i].w+dis1[v]==dis[n](令e[i].w为节点u到v的边权)的边建一个新图,
 在这个新图上从1到n跑一边dinic就可得到答案
 调了一个下午,在bool operator(const node &a)const{return a.w<w;}中原来是要a.w<w才能让优先队列中w小的优先,如果是a.w>w则是w大的优先
 **/