HDU5727 Necklace（全排列+二分图匹配）

HDU5727 Necklace（全排列+二分图匹配）

题面

题意：有 $2\ast N$ 个珠子，其中 $N$ 个是阴性的，$N$ 个是阳性的。现在需要把这些珠子串成一个项链，头尾相接且必须阴阳相间，但是有些阳性的珠子与某些阴性的珠子相邻的时候会让该阳性珠子变得黯淡，问制作出项链后至少有多少个黯淡阳性珠子。

范围：$0\le N\le 9，0\le M\le N\ast N$

分析：一开始看到数据范围这么小，想着直接进行全排列求解的，后面发现题目看错了，还以为顶多 $9!$ 种情况，有 $2\ast N$ 个珠子，如果全排列，则有 $18!$ 种情况，这不血T。

既然不能对所有的珠子进行全排列，不过可以只对其中一种珠子进行全排列，$9!=362880$， 那么我们问题就是如何在剩下的位置中放置阳性珠子才能让黯淡阳性珠子最少。而该问题又容易联系到二分图匹配问题，把每个位置当成一个点，向能够放置在该位置的的非阳性珠子连线，之后跑最大匹配，此时最少黯淡阳性珠子数 = $N$ - 最大匹配数。

这样我们就求出所有情况下的最少黯淡阳性珠子数，取最小值即可。

Code：

#include <bits/stdc++.h>
#define int long long
#define double long double
using namespace std;

const int MAXN = 10 + 10;
const int MAXM = MAXN * MAXN;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double eps = 1e-9;
const double PI = acos(-1.0);

int n, m;

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

struct Edge
{
    int to, next;
} edge[MAXM];

int head[MAXN], tot;

void init()
{
    tot = 0;
    memset(head, -1, sizeof(head));
    return;
}

void addedge(int u, int v)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
    return;
}

int linker[MAXN * 2];
bool used[MAXN * 2];
int uN;

bool dfs(int u)
{
    for (int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if (!used[v])
        {
            used[v] = true;
            if (linker[v] == -1 || dfs(linker[v]))
            {
                linker[v] = u;
                return true;
            }
        }
    }
    return false;
}

int hungary()
{
    int res = 0;
    memset(linker, -1, sizeof(linker));
    for (int u = 1; u <= uN; u++) //  点的编号0~uN-1
    {
        memset(used, false, sizeof(used));
        if (dfs(u))
        {
            res++;
        }
    }
    return res;
}

int g[MAXN][MAXN];
int Yin[MAXN];

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    while (cin >> n >> m)
    {
        if (n == m && n == 0)  // 一定要特判！
        {
            cout << 0 << endl;
            continue;
        }
        // 注意清空数组
        memset(g, 0, sizeof(g));
        uN = n;
        for (int i = 0; i < m; i++)
        {
            int u, v;
            cin >> u >> v;
            g[u][v] = 1;
        }
        // 全排列前进行赋值
        for (int i = 1; i <= n; i++)
        {
            Yin[i] = i;
        }
        int ans = INF;
        do
        {
            // 注意每次全排列都要初始化
            init();
            for (int i = 1; i <= n; i++)
            {
                int a = i, b = i + 1;
                if (a == n)
                    b = 1;
                for (int j = 1; j <= n; j++)
                {
                    // 跟两侧的阴性珠子都不冲突则连线
                    if (g[j][Yin[a]] || g[j][Yin[b]])
                        continue;
                    addedge(i, n + j);
                }
            }
            // 求最小黯淡阳性珠子数
            ans = min(ans, n - hungary());
        } while (next_permutation(Yin + 2, Yin + 1 + n)); // 注意是+2
        cout << ans << endl;
    }
    return 0;
}

【END】感谢观看