[最小割唯一性 Tarjan] BZOJ 1797 [Ahoi2009]Mincut 最小割

%%%dyh

对于一条边(u,v)，如果在最小割中，首先要求满流。

并且要求u在S集中，v在T集中，也就是在残量网络上u不能到达v。

然而v能到达u，也就是判断u,v是否在同一个强连通分量中。

如果一定在最小割中，那么有u一定在S集，v一定在T集。

也就是u和S在同一个强连通分量，v和T在同一个强连通分量。

 

 

jcvb:

 

在残余网络上跑tarjan求出所有SCC，记id[u]为点u所在SCC的编号。显然有id[s]!=id[t]（否则s到t有通路，能继续增广）。

 

①对于任意一条满流边(u,v)，(u,v)能够出现在某个最小割集中，当且仅当id[u]!=id[v]；
②对于任意一条满流边(u,v)，(u,v)必定出现在最小割集中，当且仅当id[u]==id[s]且id[v]==id[t]。

 

①

 

<==将每个SCC缩成一个点，得到的新图就只含有满流边了。那么新图的任一s-t割都对应原图的某个最小割，从中任取一个把id[u]和id[v]割开的割即可证明。

 

②
<==：假设将(u,v)的边权增大，那么残余网络中会出现s->u->v->t的通路，从而能继续增广，于是最大流流量（也就是最小割容量）会增大。这即说明(u,v)是最小割集中必须出现的边。

 

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define cl(x) memset(x,0,sizeof(x))
using namespace std;
typedef long long ll;

inline char nc()
{
	static char buf[100000],*p1=buf,*p2=buf;
	if (p1==p2) { p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }
	return *p1++;
} 

inline void read(int &x)
{
	char c=nc(),b=1;
	for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
	for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}

#define U G[p].u
#define V G[p].v
namespace DINIC{  
    const int N=4005;  
    const int M=120005;  
    struct edge{  
        int u,v,f;  
        int next;  
    }G[M];  
    int head[N],inum=1;  
    inline void add(int u,int v,int f,int p){  
        G[p].u=u; G[p].v=v; G[p].f=f; G[p].next=head[u]; head[u]=p;  
    }  
    inline void link(int u,int v,int f){  
        add(u,v,f,++inum); add(v,u,0,++inum);  
    }  
    int S,T;  
    int dis[N];  
    int Q[N],l,r;  
    inline bool bfs(){  
        memset(dis,-1,sizeof(dis)); l=r=-1;  
        Q[++r]=S; dis[S]=1;  
        while (l<r){  
            int u=Q[++l];  
            for (int p=head[u];p;p=G[p].next)  
                if (G[p].f && dis[V]==-1){  
                    dis[V]=dis[u]+1; Q[++r]=V;  
                    if (V==T) return 1;  
                }  
        }  
        return 0;  
    }  
    int cur[N];  
    ll dfs(int u,ll flow){  
        if (u==T) return flow;  
        ll used=0,now;  
        for (int p=cur[u];p;p=G[p].next)  
        {  
            cur[u]=p;  
            if (G[p].f && dis[V]==dis[u]+1)  
            {  
                now=dfs(V,min(flow-used,(ll)G[p].f));  
                G[p].f-=now,G[p^1].f+=now;  
                used+=now; if (flow==used) break;  
            }  
        }  
        if (!used) dis[u]=-1;  
        return used;  
    }  
    ll Dinic(){  
        ll ret=0;  
        while (bfs())  
            memcpy(cur,head,sizeof(cur)),ret+=dfs(S,1LL<<60);  
        return ret;  
    }
}

using namespace DINIC;

int clk,pre[N],low[N];
int scc[N],cnt;
int Stk[N],pnt;

inline void Tarjan(int u)
{
	pre[u]=low[u]=++clk; Stk[++pnt]=u;
	for (int p=head[u];p;p=G[p].next)
	{
		if (!G[p].f) continue;
		if (!pre[V])
		{
			Tarjan(V);
			low[u]=min(low[u],low[V]);
		}
		else if (!scc[V])
			low[u]=min(low[u],pre[V]);
	}
	if (low[u]==pre[u])
	{
		int v; ++cnt;
		for (int v;v!=u;)
			v=Stk[pnt--],scc[v]=cnt;
	}
}

int n,m;

int main()
{
	int iu,iv,iw;
	read(n); read(m); read(S); read(T);
	for (int i=1;i<=m;i++)
		read(iu),read(iv),read(iw),link(iu,iv,iw);
	Dinic();
	for (int i=1;i<=n;i++)
		if (!pre[i])
			Tarjan(i);
	for (int i=1;i<=m;i++)
	{
		int p=i<<1;
		if (G[p].f) { printf("0 0\n"); continue; }
		if (scc[U]==scc[V]) printf("0 "); else printf("1 ");
		if (scc[U]==scc[S] && scc[V]==scc[T]) printf("1\n"); else printf("0\n");
	}
	return 0;
}