P3731 [HAOI2017] Dinic + SCC 分解

题意

传送门 P3731 [HAOI2017]新型城市化

题解

$n$ 座城市可以恰好被划分为不超过两个城市群，那么补图，即没有建立贸易伙伴关系的城市队应的图是一个二分图。求补图中删除任一条边后最大城市群的大小至少相差 $1$，需要注意的是，最大城市群不一定代表左部节点/右部节点，而是指补图中的最大独立集。

二分图中最大独立集规模等于节点数减去最小点覆盖，而后者等于二分图最大匹配。那么问题转化为求解二分图最大匹配的必经边。$Dinic$ 求解最大匹配。在残余网络中，若匹配 $(u,v)$ 删除后仍能找到增广路，那么存在一条 $u\to v$ 的路径，而残余网络中 $u\leftarrow v$，则 $(u,v)$ 在同一个强连通分量中。

那么在残余网络中分解强连通分量，枚举各边，若是匹配边，即满流，且端点位于不同的强连通分量中，则为所求。

#include 
using namespace std;
#define pb push_back
const int MAXN = 1E4 + 5, INF = 0x3f3f3f3f;
int N, M, V, col[MAXN];
struct edge
{
    int to, cap, rev;
};
vector<int> tG[MAXN];
vector<edge> G[MAXN];
int iter[MAXN], level[MAXN];

void add_edge(int from, int to, int cap)
{
    G[from].pb({to, cap, G[to].size()});
    G[to].pb({from, 0, G[from].size() - 1});
}

void color(int v, int c)
{
    col[v] = c;
    for (int u : tG[v])
        if (col[u] == -1)
            color(u, c ^ 1);
}

void bfs(int s)
{
    memset(level, -1, sizeof(level));
    level[s] = 0;
    queue<int> q;
    q.push(s);
    while (q.size())
    {
        int v = q.front();
        q.pop();
        for (auto &e : G[v])
            if (e.cap > 0 && level[e.to] == -1)
                level[e.to] = level[v] + 1, q.push(e.to);
    }
}

int dfs(int v, int t, int f)
{
    if (v == t)
        return f;
    for (int &i = iter[v]; i < G[v].size(); ++i)
    {
        auto &e = G[v][i];
        if (level[e.to] > level[v] && e.cap > 0)
        {
            int d = dfs(e.to, t, min(f, e.cap));
            if (d > 0)
            {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s, int t)
{
    int flow = 0;
    for (;;)
    {
        bfs(s);
        if (level[t] == -1)
            return flow;
        memset(iter, 0, sizeof(iter));
        int f;
        while ((f = dfs(s, t, INF)) > 0)
            flow += f;
    }
}

vector<int> rG[MAXN], vs;
int idx[MAXN];
bool used[MAXN];

void _dfs(int v)
{
    used[v] = 1;
    for (auto &e : G[v])
        if (e.cap > 0 && !used[e.to])
            _dfs(e.to);
    vs.pb(v);
}

void rdfs(int v, int k)
{
    used[v] = 1, idx[v] = k;
    for (int u : rG[v])
        if (!used[u])
            rdfs(u, k);
}

int find_scc()
{
    memset(used, 0, sizeof(used));
    vs.clear();
    for (int v = 0; v < V; ++v)
        if (!used[v])
            _dfs(v);
    memset(used, 0, sizeof(used));
    int k = 0;
    for (int i = (int)vs.size() - 1; i >= 0; --i)
        if (!used[vs[i]])
            rdfs(vs[i], k++);
    return k;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> N >> M;
    for (int i = 0; i < M; ++i)
    {
        int u, v;
        cin >> u >> v;
        --u, --v;
        tG[u].pb(v);
        tG[v].pb(u);
    }
    memset(col, -1, sizeof(col));
    for (int v = 0; v < N; ++v)
        if (col[v] == -1)
            color(v, 0);
    int s = N, t = s + 1;
    V = t + 1;
    for (int i = 0; i < N; ++i)
        col[i] == 0 ? add_edge(s, i, 1) : add_edge(i, t, 1);
    for (int i = 0; i < N; ++i)
        if (col[i] == 0)
        {
            for (int j : tG[i])
                add_edge(i, j, 1);
        }
    max_flow(s, t);
    for (int v = 0; v < V; ++v)
        for (auto &e : G[v])
            if (e.cap > 0)
                rG[e.to].pb(v);
    find_scc();
    vector<pair<int, int>> res;
    for (int i = 0; i < N; ++i)
        if (col[i] == 0)
        {
            int j = -1;
            for (auto &e : G[i])
                if (e.to != s && e.cap == 0)
                {
                    j = e.to;
                    break;
                }
            if (j != -1 && idx[i] != idx[j])
                res.pb({min(i, j), max(i, j)});
        }
    sort(res.begin(), res.end());
    cout << (int)res.size() << '\n';
    for (auto &e : res)
        cout << e.first + 1 << ' ' << e.second + 1 << '\n';
    return 0;
}