B - Internship （网络流关键割边）

题目链接：https://cn.vjudge.net/contest/281961#problem/B

题目大意：给你n个城市，中间有一些中转站，然后给你终点，再给你l条轨道以及流量，问你增加哪几条轨道的流量可以使得流到终点的流量增加。

具体思路：首先分析一波，一开始想的是找割边，但是只是找出割边是不可以的。举个例子 ： s->u->t，这样的话，假设这两条边都是满流，都可以当做割边，但是如果只是增加割边的流量的话，会受到其他边的流量的限制，最终流量还是不会增加的，所以，换一个思路，我们先跑一遍最大流，然后观察残余网络的情况，如果一条边的起点和终点对应的起点作为另一条边的终点以及终点对应另一条边的起点的话，依旧是如果增加当前这条边的流量的话，还是可以增加流量的，这样关键割边就找出来了。

AC代码：

 #include<iostream>
 #include<stack>
 #include<queue>
 #include<iomanip>
 #include<stdio.h>
 #include<cstring>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #include<map>
 #include<vector>
 using namespace std;
 # define ll long long
 const int maxn = 4e3+;
 # define inf 0x3f3f3f3f
 int st,ed;
 int prev[maxn];
 int head[maxn];
 int line[maxn];
 int vis1[maxn],vis2[maxn];
 struct node
 {
     int fr;
     int to;
     int flow;
     int nex;
 } edge[maxn];
 int num;
 void init()
 {
     memset(head,-,sizeof(head));
     memset(vis1,,sizeof(vis1));
     memset(vis2,,sizeof(vis2));
     num=;
 }
 void addedge(int fr,int to,int flow)
 {
     edge[num].to=to;
     edge[num].fr=fr;
     edge[num].flow=flow;
     edge[num].nex=head[fr];
     head[fr]=num++;
     edge[num].to=fr;
     edge[num].fr=to;
     edge[num].flow=;
     edge[num].nex=head[to];
     head[to]=num++;
 }
 bool bfs()
 {
     memset(prev,-,sizeof(prev));
     prev[st]=;
     queue<int>q;
     q.push(st);
     while(!q.empty())
     {
         int top=q.front();
         q.pop();
         for(int i=head[top]; i!=-; i=edge[i].nex)
         {
             int temp=edge[i].to;
             if(prev[temp]==-&&edge[i].flow>)
             {
                 prev[temp]=prev[top]+;
                 q.push(temp);
             }
         }
     }
     return prev[ed]!=-;
 }
 int dfs(int u,int flow)
 {
     if(u==ed)
         return flow;
     int res=;
     for(int i=head[u]; i!=-; i=edge[i].nex)
     {
         int t=edge[i].to;
         if(prev[t]==(prev[u]+)&&edge[i].flow>)
         {
             int temp=dfs(t,min(flow,edge[i].flow));
             edge[i].flow-=temp;
             edge[i^].flow+=temp;
             res+=temp;
             flow-=temp;
             if(flow==)
                 break;
         }
     }
     if(res==)
         prev[u]=-;
     return res;
 }
 void  dinic()
 {
     int ans=;
     while(bfs())
     {
         ans+=dfs(st,inf);
     }
 }
 void dfs1(int u)
 {
     vis1[u]=;
     for(int i=head[u]; i!=-; i=edge[i].nex)
     {
         int v=edge[i].to;
         if(!vis1[v]&&edge[i].flow)
             dfs1(v);
     }
 }
 void dfs2(int u)
 {
     vis2[u]=;
     for(int i=head[u]; i!=-; i=edge[i].nex)
     {
         int v=edge[i].to;
         if(!vis2[v]&&edge[i^].flow)
         {
             dfs2(v);
         }
     }
 }
 int main()
 {
     int n,m,l;
     while(~scanf("%d",&n))
     {
         if(n==)
             break;
         init();
         scanf("%d %d",&m,&l);
         st=n+m+;
         ed=;
         int t1,t2,t3;
         for(int i=; i<l; i++)
         {
             scanf("%d %d %d",&t1,&t2,&t3);
             line[i]=num;
             addedge(t1,t2,t3);
         }
         for(int i=; i<=n; i++)
         {
             addedge(st,i,inf);
         }
         dinic();
         dfs1(st);
         dfs2(ed);
        // cout<<1<<endl;
         int flag=;
         for(int i=; i<l; i++)
         {
       //  cout<<i<<endl;
             if(edge[line[i]].flow==&&vis1[edge[line[i]].fr]&&vis2[edge[line[i]].to])
             {
            //     cout<<i<<endl;
                 if(flag)
                 {
                     printf("%d",i+);
                     flag=;
                 }
                 else
                 {
                     printf(" %d",i+);
                 }
             }
         }
         printf("\n");
     }
     return ;
 }