P4126 [AHOI2009]最小割 【最小割+tarjan(SCC)】

 P4126 [AHOI2009]最小割

---

题意

• 给一个有向图。两问

1. 某条边是不是一定是最小割边
2. 某条边是不是有可能是最小割边

---

思路

跑完最大流的残量图中

• 如果某条正向边<u, v>的剩余流量为0，并且uv不在一个强连通分量中，那么这个边可能是最小割边。

• 在可能是最小割的条件下，如果u和源点s在同一个强连通分量中，且v和汇点t在同一个强连通分量中，那么这个边一定是最小割边。【言外之意就是，每一个最小割都必包含这条边】

---

关于最小割

• 最小割=最大流 

如何求最小割？

在残量网络中，从源点s出发，能够到达的点构成点集S{}, 其余点构成点集T{}. 连接两个点集的正向满流边就是最小割边。

最小割理解参考博客，找了n年才找到一个

---

 CODE

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

inline int read()
{
    int x = 0, f = 1; char c = getchar();
    while(c < '0' || c > '9') { if(c == '-') f = -f; c = getchar(); }
    while(c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}

const int maxN = 4003;
const int maxM = 60004;

int n, m, s, t;
struct EDGE{
    int adj, from, to, w;
    EDGE(int a = -1, int b = 0, int c = 0, int d = 0): adj(a), from(b), to(c), w(d) {}
}edge[maxM << 1];
int head[maxN], cur[maxN], cnt;
void add_edge(int u, int v, int w)
{
    edge[cnt] = EDGE(head[u], u, v, w);
    head[u] = cnt ++ ;
}

int deep[maxN];

bool bfs()
{
    for(int i = 0; i <= n; ++ i ) deep[i] = 0, cur[i] = head[i];
    queue<int>q;
    q.push(s); deep[s] = 1;
    while(!q.empty())
    {
        int u = q.front(); q.pop();
        for(int i = head[u]; ~i; i = edge[i].adj)
        {
            int v = edge[i].to;
            if(!deep[v] && edge[i].w)
            {
                deep[v] = deep[u] + 1;
                q.push(v);
                if(v == t) return true;
            }
        }
    }
    return false;
}

ll dfs(int u, int flow)
{
    if(u == t || !flow) return flow;
    for(int& i = cur[u]; ~i; i = edge[i].adj)
    {
        int v = edge[i].to;
        if(deep[u] + 1 == deep[v] && edge[i].w)
        {
            if(ll nowFlow = dfs(v, min(flow, edge[i].w)))
            {
                edge[i].w -= nowFlow;
                edge[i ^ 1].w += nowFlow;
                return nowFlow;
            }
        }
    }
    return 0;
}

void dinic()
{
    while(bfs()) while(dfs(s, INF));
}

int dfn[maxN], low[maxN], tot;
int belong[maxN], cnnct;
int Stack[maxN], top;
bool InSta[maxN];

void tarjan(int u)
{
    dfn[u] = low[u] = ++ tot;
    Stack[++ top] = u; InSta[u] = true;
    for(int i = head[u]; ~i; i = edge[i].adj)
    {
        int v = edge[i].to;
        if(edge[i].w == 0) continue;
        if(!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if(InSta[v])
        {
            low[u] = min(low[u], dfn[v]);
        }
    }
    if(low[u] == dfn[u])
    {
        ++cnnct;
        int now;
        do{
            now = Stack[top -- ];
            InSta[now] = false;
            belong[now] = cnnct;
        }while(now != u);
    }
}

int main()
{
    memset(head, -1, sizeof(head));
    n = read(); m = read(); s = read(); t = read();
    for(int i = 0; i < m; ++ i )
    {
        int u, v, w;
        u = read(); v = read(); w = read();
        add_edge(u, v, w);
        add_edge(v, u, 0);
    }
    dinic();
    for(int i = 1; i <= n; ++ i ) if(!dfn[i]) tarjan(i);
    for(int i = 0; i < cnt; i += 2)
    {
        int u = edge[i].from, v = edge[i].to;
        if(belong[u] != belong[v] && edge[i].w == 0)
        {
            putchar('1');
            putchar(' ');
            if(belong[u] == belong[s] && belong[v] == belong[t])
                putchar('1');
            else putchar('0');
        }
        else printf("0 0");
        putchar('\n');
    }
    return 0;
}