【bzoj1797】[Ahoi2009]Mincut 最小割

1797: [Ahoi2009]Mincut 最小割

Time Limit: 10 Sec   Memory Limit: 162 MB
Submit: 2357   Solved: 1023
[ 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 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

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

Source

Day1

[ Submit][ Status][ Discuss]



最小割的唯一性判定

用最大流+tarjan解决

具体方法是：

先用跑一遍最大流

然后在残量网络的基础上做tarjan找出所有的强连通分量缩点（这里的SCC有包含考虑反向边）

这样在整个图中就只有SCC和满流的边

然后对每个满流的边原图的边进行分类讨论：

如果说当前边Scc_id[from] == Scc_id[to]，那么即使说最小割集中不包含这一条边也必定有其他路径使from与to相连，故第一问与第二问为0

如果说当前边Scc_id[from] != Scc_id[to]，那么该边连接的是from和to所属于的两个SCC，那么该边一定属于某个最小割集

如果说当前边Scc_id[from] == Scc_id[s] && Scc_id[to] == Scc_id[t]，那么该边连接的是S和T所属于的两个SCC，那么该边一定是所有最小割集中所共同包含的

代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
 
const int INF = 2147483647;
const int max_m = 300000;
const int max_n = 5000;
 
struct data{
    int from,to,cap,flow;
}e[max_m];
 
queue<int> q;
vector<int> G[max_n];
int ans[max_m][3];
int scc_id[max_n],stk[max_n],low[max_n],time[max_n],tot_scc,top;
bool vis[max_n],exist[max_n];
int cur[max_n],dis[max_n];
int from[max_m],to[max_m],cap[max_m],tot_e = -1,n,m,s,t;
 
inline int getint()
{
    int ret = 0;
    char c = getchar();
    while (c < '0' || c > '9') c = getchar();
    while (c >= '0' && c <= '9')
        ret = ret * 10 + c - '0',c = getchar();
    return ret;
}
 
inline int dinic(int o,int a)
{
    if (o == t || a == 0) return a;
    int flow = 0;
    for (int& i = cur[o]; i < G[o].size(); i++)
    {
        data& edge = e[G[o][i]];
        int v = edge.to;
        if (dis[v] != dis[o] + 1 || edge.cap == edge.flow) continue;
        int f = dinic(v,min(a,edge.cap - edge.flow));
        if (f)
        {
            edge.flow += f;
            e[G[o][i] ^ 1].flow -= f;
            flow += f;
            a -= f;
            if (a == 0) break;
        }
    }
    return flow;
}
 
inline bool bfs()
{
    memset(dis,0,sizeof(dis));
    memset(vis,0,sizeof(vis));
    q.push(s);
    vis[s] = 1;
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        for (int i = 0; i < G[u].size(); i++)
        {
            data edge = e[G[u][i]];
            int v = edge.to;
            if (vis[v] || edge.flow == edge.cap) continue;
            dis[v] = dis[u] + 1;
            vis[v] = 1;
            q.push(v);
        }
    }
    return vis[t];
}
 
inline void add(int u,int v,int w)
{
    e[++tot_e] = (data){u,v,w,0};
    G[u].push_back(tot_e);
    e[++tot_e] = (data){v,u,w,w};
    G[v].push_back(tot_e);
}
 
inline void tarjan(int o,int t)
{
    low[o] = time[o] = t;
    exist[o] = 1;
    stk[++top] = o;
    for (int i = 0; i < G[o].size(); i++)
    {
        data edge = e[G[o][i]];
        int v = edge.to;
        if (vis[v] || edge.flow == edge.cap) continue;
        if (!exist[v])
            tarjan(v,t + 1);
        low[o] = min(low[v],low[o]);
    }
    if (low[o] == time[o])
    {
        tot_scc++;
        while (stk[top] != o) 
        {
            scc_id[stk[top]] = tot_scc;
            vis[stk[top]] = 1;
            top--;
        }
        scc_id[stk[top]] = tot_scc;
        vis[stk[top]] = 1;
        top--;
    }
}
 
int main()
{
    n = getint(); m = getint(); s = getint(); t = getint();
    for (int i = 1; i <= m; i++)
    {
        from[i] = getint(); to[i] = getint(); cap[i] = getint();
        add(from[i],to[i],cap[i]);
    }
    while (bfs())
    {
        memset(cur,0,sizeof(cur));
        dinic(s,INF);
    }
    memset(vis,0,sizeof(vis));
    memset(exist,0,sizeof(exist));
    for (int i = 1; i <= n; i++)
        if (!vis[i])
            tarjan(i,1);
    for (int i = 1; i <= m; i++)
    {
        if (e[(i - 1) * 2].flow != e[(i - 1) * 2].cap) continue;
        if (scc_id[from[i]] == scc_id[to[i]]) continue;
        if (scc_id[s] == scc_id[from[i]] && scc_id[t] == scc_id[to[i]]) 
            ans[i][2] = 1;
        if (scc_id[from[i]] != scc_id[to[i]]) 
            ans[i][1] = 1;
    }
    for (int i = 1; i <= m; i++)
        printf("%d %d\n",ans[i][1],ans[i][2]);
    return 0;
}