SGU 286 Hall 定理 + 欧拉回路 + 二分图最大匹配

SHOHOKUKU

已于 2022-04-01 16:49:01 修改

阅读量933

点赞数

分类专栏：图论文章标签：算法

于 2022-04-01 11:26:11 首次发布

本文链接：https://blog.csdn.net/neweryyy/article/details/123893089

版权

图论专栏收录该内容

205 篇文章 4 订阅

订阅专栏

题意

传送门 SGU 286 Ancient decoration

题解

所有节点度数都为偶数，则任一个连通分量都存在欧拉回路。求欧拉回路，使无向边确定一个方向。此时任意节点出度入度均为 $k / 2$ 。

原图中每个节点拆为出点 $v$ 与入点 $v^\prime$ ，得到一个二分图。对于每一条有向边 $u\rightarrow v$ ，在新图中建为 $u\rightarrow v^\prime$ 。此时保证每条边仅使用一次。对于出点构成的任意点集 $S$ 的出度，一定不大于与其连边的点集 $A (S)$ 的入度，则 $\lvert S\rvert \times k/2 \leq \lvert A(S)\rvert\times k/2$ 。

由于 $\lvert S\rvert \leq \lvert A(S)\rvert$ ，根据 Hall 定理，新图一定存在完备匹配，原图中每一个节点恰好匹配两条边。

#include <bits/stdc++.h>
using namespace std;
struct edge
{
    int to, rev;
    bool used;
};
vector<vector<edge>> G;
vector<vector<int>> nG;
int N, K;

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> N >> K;
    function<void(int, int)> add_edge = [&](int u, int v)
    {
        G[u].push_back({v, (int)G[v].size(), 0});
        G[v].push_back({u, (int)G[u].size() - 1, 0});
    };
    G.resize(N);
    vector<vector<int>> idx(N, vector<int>(N, -1));
    for (int i = 0; i < N * K / 2; ++i)
    {
        int u, v;
        cin >> u >> v;
        --u, --v;
        add_edge(u, v);
        idx[u][v] = idx[v][u] = i;
    }
    vector<int> iter(N);
    function<void(int)> euler_path = [&](int v)
    {
        for (int &i = iter[v]; i < (int)G[v].size(); ++i)
        {
            while (i < (int)G[v].size() && G[v][i].used)
                ++i;
            if (i == (int)G[v].size())
                break;
            auto &e = G[v][i];
            ++i, G[e.to][e.rev].used = 1;
            euler_path(e.to);
        }
    };
    for (int v = 0; v < N; ++v)
        if (iter[v] == 0)
            euler_path(v);
    nG.resize(N * 2);
    for (int v = 0; v < N; ++v)
        for (auto &e : G[v])
            if (!e.used)
                nG[v].push_back(N + e.to);
    vector<int> match(N * 2, -1);
    vector<bool> used(N * 2);
    function<bool(int)> dfs = [&](int v) -> bool
    {
        used[v] = 1;
        for (int u : nG[v])
        {
            int w = match[u];
            if (w == -1 || (!used[w] && dfs(w)))
            {
                match[v] = u, match[u] = v;
                return 1;
            }
        }
        return 0;
    };
    for (int v = 0; v < N; ++v)
    {
        fill(used.begin(), used.end(), 0);
        dfs(v);
    }
    cout << "YES\n";
    for (int v = 0; v < N; ++v)
        cout << idx[v][match[v] - N] + 1 << '\n';
    return 0;
}