【BZOJ-1797】Mincut 最小割最大流 + Tarjan + 缩点

1797: [Ahoi2009]Mincut 最小割

Time Limit: 10 Sec Memory Limit: 162 MB
Submit: 1685 Solved: 724
[Submit][Status][Discuss]

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 M1 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

2015.4.16新加数据一组，可能会卡掉从前可以过的程序。

Source

Day1

Solution

首先，最小割-最大流定理，很显然想到最大流

那么问题在于对于各个边是否选择的情况的判断

考虑在求完最小割（最大流）的残余网络上进行处理，那么想到Tarjan+缩点

讨论后发现，如下判断即可：

对于问题1：

如果一条边的左右端点不在同一SCC中，那么为1，否则为0

对于问题2：

满足一条边的左右端点必须一个端点与s同SCC，另一个端点与t同SCC，此时为1，否则为0

当然还有一个特例，那就是这个边从未被割，那么很显然对于问题1和问题2同时为0

Code

#include<iostream>

#include<cstdio>

#include<algorithm>

#include<cmath>

using namespace std;

int read()

{

    int x=,f=; char ch=getchar();

    while (ch<'' || ch>'') {if (ch=='-') f=-; ch=getchar();}

    while (ch>='' && ch<='') {x=x*+ch-''; ch=getchar();}

    return x*f;

}

//quick read

#define maxn 4000+100

#define maxm (60000+100)*2

struct data{int from,to,next,cap;}edge[maxm];

int head[maxn],cnt=,cur[maxn];

void add(int u,int v,int w)

{cnt++;edge[cnt].to=v;edge[cnt].from=u;

edge[cnt].next=head[u];head[u]=cnt;edge[cnt].cap=w;}

void insert(int u,int v,int w){add(u,v,w);add(v,u,);}

//add edge

int n,m,s,t;int dis[maxn],q[maxn];

bool bfs()

{

    for (int i=; i<=n; i++) dis[i]=-;

    int he=,ta=; q[]=s; dis[s]=;

    while (he<ta)

        {

            int now=q[he++];

            for (int i=head[now]; i; i=edge[i].next)

                if (dis[edge[i].to]==- && edge[i].cap)

                    dis[edge[i].to]=dis[now]+,q[ta++]=edge[i].to;

        }

    return dis[t]!=-;

}

int dfs(int loc,int low)

{

    if (loc==t) return low;

    int w,used=;

    for (int i=cur[loc]; i; i=edge[i].next)

        if (dis[edge[i].to]==dis[loc]+)

            {

                w=dfs(edge[i].to,min(low-used,edge[i].cap));

                edge[i].cap-=w;edge[i^].cap+=w;

                if (edge[i].cap) cur[loc]=i;

                used+=w; if (used==low) return low;

            }

    if (!used) dis[loc]=-;

    return used;

}

#define inf 0x7fffffff

int dinic()

{

    int tmp=;

    while (bfs())

        {

            for (int i=; i<=n; i++) cur[i]=head[i];

            tmp+=dfs(s,inf);

        }

    return tmp;

}

//MaxFlow Dinic

int stack[maxn],st,qcnt,tot;

int dfn[maxn],loww[maxn],belong[maxn],num[maxn];bool visit[maxn];

void Tarjan(int x)

{

    dfn[x]=loww[x]=++tot; stack[++st]=x; visit[x]=;

    for (int i=head[x]; i; i=edge[i].next)

        if (edge[i].cap)//根据题意，在Tarjan的时候需要进行此判断，否则会出问题

            {

                if (!dfn[edge[i].to])

                       {

                        Tarjan(edge[i].to);

                        if (loww[edge[i].to]<loww[x]) loww[x]=loww[edge[i].to];

                    }

                else if(visit[edge[i].to] && dfn[edge[i].to]<loww[x])

                        loww[x]=dfn[edge[i].to];

            }

    if (dfn[x]==loww[x])

        {

            qcnt++;int u;

            while (x!=u)

                u=stack[st--],num[qcnt]++,

                visit[u]=,belong[u]=qcnt;

        }

}

//Tarjan SCC

int main()

{

    n=read(),m=read(),s=read(),t=read();

    for (int u,v,c,i=; i<=m; i++)

        u=read(),v=read(),c=read(),insert(u,v,c);

    int maxflow=dinic();

    for (int i=; i<=n; i++)

        if (!dfn[i]) Tarjan(i);

    for (int ans1,ans2,u,v,i=; i<=cnt; i+=)

        {

            u=edge[i].from,v=edge[i].to;

            if (edge[i].cap) ans1=,ans2=;

                else

                    {

                        if (belong[u]!=belong[v])

                            ans1=; else ans1=;

                        if (belong[u]==belong[s] && belong[v]==belong[t])

                            ans2=; else ans2=;

                    }

            printf("%d %d\n",ans1,ans2);

        }

    return ;

}

本来应该做的飞快，然而...自己脑残打错两个变量...坑了好久....SB错误毁一生啊！！