[AHOI2009]最小割 最小割可行边&必须边

~~~题面~~~

题解：

做这题的时候才知道有最小割可行边和必须边这种东西。。。。。

1，最小割可行边,

意思就是最小割中可能出现的边。

充要条件：

　　1，满流

　　2，在残余网络中找不到x ---> y的路径

解释：

如果在残余网络中还找得到x ---> y的路径的话，要割掉这条边就还需要割掉另一条路径，这显然是不够优的。

如果是满流的话显然不是割掉了这条边

2，最小割必须边

　　1，满流

　　2，在残余网络中s 可以到 x， y 可以到 t。

解释：

满流的原因和上面原因，同时必须边肯定也是可行边（显然可行边的范围就要大一些嘛）。

如果满流但s不能到x or y 不能到 t，因为这样的话说明在s 到 x（y 到 t）的路上就已经被割掉了，而不是在这里割的。

但是因为满流了，所以这是可行的，但是由于割在别的地方，说明不是必须的。

因此s 必须可以到 x， y 必须可以到s才能保证是必须边，而不是可行边 

至于实现方法就比较妙了。

如果两个点在一个scc中则表示可以到。

因此可行边需要保证x和y不在一个scc中。

而必须边则还需要额外保证s 和 x 属于一个scc， y 和 t属于一个scc

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define getchar() *o++
#define inf 2139062143
#define AC 5000
#define ac 150000
#define D printf("line in %d
", __LINE__);
char READ[7000100], *o = READ;
int n, m, s, t, ans, x, cnt, addflow;
int last[AC], c[AC], have[AC], good[AC];
int date[ac], Next[ac], belong[ac], haveflow[ac], Head[AC], tot = 1;//前向星
int low[AC], dfn[AC], scc[AC], timer;//tarjan
int q[AC], head, tail;//队列
int Stack[AC], top;
bool z[AC];//用于tarjan

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

inline void upmin(int &a, int b)
{
    if(a > b) a = b;
}

inline void add(int f, int w, int S)
{
    date[++tot] = w, Next[tot] = Head[f], Head[f] = tot, haveflow[tot] = S, belong[tot] = f;
    date[++tot] = f, Next[tot] = Head[w], Head[w] = tot;
}

void pre()
{
    int u, v, e;
    n = read(), m = read(), s = read(), t = read();
    for(R i = 1; i <= m; i++)
    {
        u = read(), v = read(), e = read();
        add(u, v, e);
    }
}

void bfs()
{
    int x, now;
    c[t] = 1, have[1] = 1, q[++tail] = t;
    while(head < tail)
    {
        x = q[++head]; 
        for(R i = Head[x]; i ; i = Next[i])
        {
            now = date[i];
            if(haveflow[i ^ 1] && !c[now])
            {
                c[now] = c[x] + 1;
                ++have[c[now]];
                q[++tail] = now;
            }
        }
    }
    memcpy(good, Head, sizeof(good));
}

void aru()
{
    while(x != s)
    {
        haveflow[last[x]] -= addflow;
        haveflow[last[x] ^ 1] += addflow;
        x = date[last[x] ^ 1];
    }
    ans += addflow;
}

void isap()
{
    int now; bool done;
    x = s, addflow = inf;
    while(c[s] != 4801)
    {
        if(x == t) aru(), addflow = inf;
        done = false;
        for(R i = good[x]; i ; i = Next[i])
        {
            now = date[i];
            if(haveflow[i] && c[now] == c[x] - 1)
            {
                done = true;
                upmin(addflow, haveflow[i]);
                good[x] = last[now] = i;
                x = now;
                break;
            }
        }
        if(!done)
        {
            int go = 4800;
            for(R i = Head[x]; i ; i = Next[i])
            {
                now = date[i];
                if(haveflow[i] && c[now]) upmin(go, c[now]);
            }
            good[x] = Head[x];//error！！！不要忘了重置
            if(!(--have[c[x]])) break;
            ++have[c[x] = go + 1];
            if(x != s) x = date[last[x] ^ 1];
        }
    }
}

void tarjan(int x)
{
    int now;
    dfn[x] = low[x] = ++timer;
    z[x] = true;
    Stack[++top] = x;
    for(R i = Head[x]; i ; i = Next[i])
    {
        if(!haveflow[i]) continue;//流满表示不联通
        now = date[i];
        if(!dfn[now]) 
        {
            tarjan(now);
            upmin(low[x], low[now]);
        }
        else if(z[now]) upmin(low[x], low[now]);
    }
    if(dfn[x] == low[x])
    {
        ++cnt;
        while(Stack[top] != x)
        {
            now = Stack[top--];
            scc[now] = cnt;
            z[now] = false;
        }
        now = Stack[top--];
        scc[now] = cnt;
        z[now] = false;
    }
}

void work()
{
    int x, y;
    for(R i = 2; i <= tot; i += 2)
    {
        x = belong[i], y = date[i];
    //    printf("%d %d
", x, y);
        if(!haveflow[i] && scc[x] != scc[y])
        {
            printf("1 ");
            if(scc[x] == scc[s] && scc[y] == scc[t]) printf("1
");
            else printf("0
");
        }
        else printf("0 0
");
    }
}

int main()
{
//    freopen("in.in", "r", stdin);
    fread(READ, 1, 7000000, stdin);
    pre();
    bfs();
    isap();
    for(R i=1;i<=n;i++) 
        if(!dfn[i]) tarjan(i);
//    for(R i=1;i<=n;i++) printf("%d ", scc[i]);
//    printf("
");
//    for(R i=2;i<=tot;i++) printf("%d ", haveflow[i]);
    work();
//    fclose(stdin);
    return 0;
}