bzoj 1797: [Ahoi2009]Mincut 最小割

Description

A,B两个国家正在交战，其中A国的物资运输网中有N个中转站，M条单向道路。设其中第i (1≤i≤M)条道路连接了vi,ui两个中转站，那么中转站vi可以通过该道路到达ui中转站，如果切断这条道路，需要代价ci。现在B国想找出一个路径切断方案，使中转站s不能到达中转站t，并且切断路径的代价之和最小。 小可可一眼就看出，这是一个求最小割的问题。但爱思考的小可可并不局限于此。现在他对每条单向道路提出两个问题： 问题一：是否存在一个最小代价路径切断方案，其中该道路被切断？ 问题二：是否对任何一个最小代价路径切断方案，都有该道路被切断？ 现在请你回答这两个问题。

Input

第一行有4个正整数，依次为N,M,s和t。第2行到第(M+1)行每行3个正 整数v,u,c表示v中转站到u中转站之间有单向道路相连，单向道路的起点是v， 终点是u,切断它的代价是c(1≤c≤100000)。 注意:两个中转站之间可能有多条道路直接相连。 同一行相邻两数之间可能有一个或多个空格。

Output

对每条单向边，按输入顺序，依次输出一行，包含两个非0即1的整数，分 别表示对问题一和问题二的回答(其中输出1表示是，输出0表示否)。 同一行相邻两数之间用一个空格隔开，每行开头和末尾没有多余空格。

Sample Input

6 7 1 6
1 2 3
1 3 2
2 4 4
2 5 1
3 5 5
4 6 2
5 6 3

Sample Output

1 0
1 0
0 0
1 0
0 0
1 0
1 0

HINT

设第(i+1)行输入的边为i号边，那么{1,2},{6,7},{2,4,6}是仅有的三个最小代价切割方案。它们的并是{1,2,4,6,7}，交是 。 

【数据规模和约定】 

测试数据规模如下表所示 
数据编号 N M 数据编号 N M 
1 10 50 6 1000 20000 
2 20 200 7 1000 40000 
3 200 2000 8 2000 50000 
4 200 2000 9 3000 60000 
5 1000 20000 10 4000 60000 

这题网上有两种解法，tarjan和bfs。tarjan我觉得好理解一些，所以写的是tarjan。

这是个最小割问题。于是我们首先跑一遍最大流，然后在残留网络上进行tarjan缩点。

对于一条满流边。

1、若两个端点不在一个联通块内，则可能存在于最小割中。

2、若起始点和S在一个联通块内而终点和T在一个联通块内则必然存在于最小割中。

#include<cstdio>
#include<string>
#include<cstring>
using namespace std;
int head[100001];
struct map
{
	 int f;
	 int s,t;
     int next;
}a[400001];
int haedge[400001];
int b[5001];
int edge;
int p;
int q[400001],d[400001];
inline void add1(int s,int t,int f,int xxx)
{
     a[edge].next=head[s];
     head[s]=edge;
     a[edge].s=s;
     a[edge].t=t;
     a[edge].f=f;
     haedge[xxx]=edge;
}
inline void add(int s,int t,int f)
{
     a[edge].next=head[s];
     head[s]=edge;
     a[edge].s=s;
     a[edge].t=t;
     a[edge].f=f;
}
int as;
inline bool bfs()
{
     int l=0,r=0;
     memset(q,0,sizeof(q));
     r++;
     q[r]=as;
     memset(d,-1,sizeof(d));
     d[as]=0;
     int i,k;
     while(l<r)
     {
     	  l++;
          int k=q[l];
          for(i=head[k];i!=0;i=a[i].next)
          {
               if(a[i].f>0&&d[a[i].t]==-1)
               {
                    d[a[i].t]=d[k]+1;
                    r++;
                    q[r]=a[i].t;
               }
          }
     }
     if(d[p]>=0)
          return true;
     return false;
}
inline int dfs(int k,int s)
{
     if(k==p)
          return s;
     int t=s;
     int i;
     for(i=head[k];i!=0;i=a[i].next)
     {
          if(d[a[i].t]==d[k]+1&&a[i].f>0)
          {
               int xx=dfs(a[i].t,min(s,a[i].f));
               a[i].f-=xx;
               if(i%2==0)
                    a[i-1].f+=xx;
               else
                    a[i+1].f+=xx;
               s-=xx;
          }
     }
     return t-s;
}
inline int maxflow()
{
     int s=0;
     while(bfs())
          s+=dfs(as,2100000000);
     return s;
}
int scc,cnt;
bool v[10001];
int s[10001],top;
int dfn[10001],low[10001],belong[10001];
inline void tarjan(int d)
{
     int i,x;
     cnt++;
     dfn[d]=cnt;
     low[d]=cnt;
     top++;
     s[top]=d;
     v[d]=true;
     for(i=head[d];i!=0;i=a[i].next)
     {
     	  if(a[i].f==0)
     	       continue;
     	  x=a[i].t;
          if(dfn[x]==0)
          {
               tarjan(x);
               low[d]=min(low[d],low[x]);
          }
          else if(v[x]&&low[d]>dfn[x])//v在栈中，修改low[u]
               low[d]=dfn[x];
     }
     if(dfn[d]==low[d])//u为该强连通分量中遍历所成树的根
     {
          scc++;
          x=s[top];
          top--;
          while(x!=d)
          {    
			   v[x]=false;
               belong[x]=scc;
               x=s[top];
               top--;
          }
          v[x]=false;
          belong[x]=scc;
     }
}
struct cc
{
     int ss,tt,x;
}ed[1000001];
int main()
{
     int n,m,s,t;
     scanf("%d%d%d%d",&n,&m,&s,&t);
     int i;
     int ss,tt,x;
     for(i=1;i<=m;i++)
     {
          scanf("%d%d%d",&ed[i].ss,&ed[i].tt,&ed[i].x);
          edge++;
          add1(ed[i].ss,ed[i].tt,ed[i].x,i);
          edge++;
          add(ed[i].tt,ed[i].ss,0);
     }
     as=s;
     p=t;
     maxflow();
     for(i=1;i<=n;i++)
          if(belong[i]==0)
               tarjan(i);
     for(i=1;i<=m;i++)
     {
          if(belong[ed[i].ss]==belong[ed[i].tt]||a[haedge[i]].f!=0)
               printf("0 0\n");
          else if(belong[ed[i].ss]==belong[s]&&belong[ed[i].tt]==belong[t])
               printf("1 1\n");
          else
               printf("1 0\n");
     }
     return 0;
}