二分圖的必經邊與可行邊（HDU - 3026 Chinese Chess）

題目鏈接
對於一個二分圖，我們對於滿足最大匹配的多組匹配方案中，對於某些邊：

如果對於每個方案，這個邊都被選擇了，我們稱這條邊爲必經邊
如果一條邊，它在至少一個方案中被選擇了，我們稱這條邊爲可行邊

求必經邊第一種方案，我們易知可以枚舉每個邊，去掉該邊後，跑一邊最大匹配，看看最大匹配數是否減小，若減小，該邊爲必經邊。
顯然我們就算用Dinic跑最大匹配，時間複雜度也會到達$O(E^2*\sqrt V)$在這個題中1e5的級別完全不夠用。。
於是我們用Dinic+tarjan在$O(E* \sqrt V)$時間內處理出必經點與可行點。
方法如下：

第一步

與普通最大匹配一樣，建立超級源匯點，先用Dinic跑出最大匹配數。

第二步

用tarjan算法在跑完Dinic後的殘流圖上跑強連通分量。（殘流圖，如果一個邊的殘流大於0，我們認爲聯通，否則不連通）
在這，我們不難發現：如果一個邊被選擇了，那麼這個邊從左部到右部的殘量就是0，反向邊就是1，等同於一個從右部指向左部的有向邊。未被選中的邊反之。

第三步

我們枚舉每一條邊：有以下結論：：（重點來了）
必經邊：：對於一個邊<x，y>，如果該邊的流量爲1（殘量爲0），且x，y分佈在兩個不同的強連通分量中，則<x，y>爲必經邊。
可行邊：：對於一個邊<x，y>，如果該邊的流量爲1（殘量爲0），或x，y分佈在相同的強連通分量中，則<x，y>爲可行邊。
證明詳細看藍皮書（我也不太懂 ）
下面是ac代碼：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <stack>
#include <map>
#include <queue>
#define ll long long
using namespace std;
const int NN = 7e5+5;
const int INF = 0x3f3f3f3f;
typedef unsigned long long ull;
int he[NN], ne[NN], ver[NN], e[NN], l[NN];
int n, m, idx = 0, k = 1, Bcnt = 0;
int ins[NN], ans = 0, tei;
int dfn[NN], low[NN];
int Belong[NN];
stack<int> s;
int tot;
void init()
{
    memset(he, 0, sizeof(he));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(ins, 0, sizeof(ins));
    while(s.size()) s.pop();
    Bcnt = 0;
    idx = 0;
    tot = 1;
}
void add(int x, int y, int w)
{
    e[++tot] = w;
    ver[tot] = y;
    ne[tot] = he[x];
    he[x] = tot;
    e[++tot] = 0;
    ver[tot] = x;
    ne[tot] = he[y];
    he[y] = tot;
}
bool bfs(int s, int t)
{
    memset(l, 0, sizeof(l));
    queue<int> q;
    q.push(s);
    l[s] = 1;
    while(q.size())
    {
        int x = q.front();
        q.pop();
        if (x == t) return 1;
        for (int i = he[x]; i; i = ne[i])
        {
            int y = ver[i];
            if (!l[y] && e[i])
            {
                l[y] = l[x] + 1;
                q.push(y);
            }
        }
    }
    return 0;
}
int dfs(int x, int MaxFlow, int t)
{
    if (x == t) return MaxFlow;
    int uflow = 0;
    for (int i = he[x]; i; i = ne[i])
    {
        int y = ver[i];
        if (l[y] == l[x] + 1 && e[i])
        {
            int flow = min(e[i], MaxFlow - uflow);
            flow = dfs(y, flow, t);
            e[i] -= flow;
            e[i^1] += flow;
            uflow += flow;
            if (uflow == MaxFlow)
                break;
        }
    }
    if (uflow == 0)
        l[x] = 0;
    return uflow;
}
int Dinic(int s, int t)
{
    int MaxFlow = 0;
    while(bfs(s, t))
        MaxFlow += dfs(s, INF, t);
    return MaxFlow;
}
void tarjan(int u)
{
    int v;
    dfn[u] = low[u] = ++idx;
    s.push(u);
    ins[u] = 1;
    for (int i = he[u]; i; i = ne[i])
    {
        if (e[i] == 0) continue;

        v = ver[i];
        if (!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if (ins[v]) low[u] = min(low[u], dfn[v]);
    }
    if (dfn[u] == low[u])
    {
        Bcnt++;
        int _cnt = 0;
        do
        {
            v = s.top();
            s.pop();
            ins[v] = 0;
            Belong[v] = Bcnt;
            _cnt++;
        }while(u != v);
        if (ans < _cnt)
        {
            tei = Bcnt;
            ans = _cnt;
        }
    }
}
int main()
{
    int k;
    int t0 = 1;
    while(scanf("%d%d%d", &n, &m, &k) != EOF)
    {
        init();
        for (int i =0; i < k; i++)
        {
            int x, y;
            scanf("%d%d", &x, &y);
            add(x, n+y, 1);
        }
        int s = 0, t = n + m + 1;
        for (int i = 1; i <= n; i++)
            add(s, i, 1);
        for (int i = 1; i <= m; i++)
            add(i+n, t, 1);
        //以上爲建圖過程  以下爲求解過程
        int anss = Dinic(s, t);//第一步
        for (int i = s; i <= t; i++)
            if (!dfn[i]) tarjan(i);//第二步
        int cntt = 0;
        for (int i = 1; i <= n; i++)
        {
            for (int j = he[i]; j; j = ne[j])
            {
                if (ver[j]==s) continue;
                if (Belong[i] != Belong[ver[j]] && e[j] == 0)//必經邊定理
                    cntt++;
            }//枚舉每個邊
        }
        printf("Board %d have %d important blanks for %d chessmen.\n",t0++, cntt, anss);
    }
    return 0;
}