HDU - 5727 暴力 + 二分图匹配

题意：

给出n个阳珠子和n个阴珠子，排成一个环，要求相邻的两个珠子不能同阴或同阳。另外给出m个关系(u,v)，如果阳珠子u和阴珠子v相邻就会褪色一次。问最有情况的组合最少褪色几次。

思路：

二分图匹配，暴力枚举所有阴珠子的排列，因为是环形所以又(n-1)!种情况，然后针对每一种排列，往相邻的两个阴珠子中插入阳珠子，插入的位置一共有n个，如果一个阳珠子不会和前一个以及后一个阴珠子产生褪色，那么就将该位置和这个阳珠子连边，然后二分图求最大匹配，得到最大的不会褪色的个数，再拿n一减能得到答案。

代码：

#include 
using namespace std;
const int MAXN = 12;
const int MAXM = 12;
const int INF = 0x3f3f3f3f;

struct BgMaxMatch {

    int nl, nr;
    int l[MAXN];
    bool vis[MAXN];
    vector  G[MAXN];  //这里注意要看是按左右哪边建图，也有可能是MAXM

    void init(int nl, int nr) {
        this -> nl = nl;
        this -> nr = nr;
        for (int i = 1; i <= nl; i++) G[i].clear();
        memset(vis, false, sizeof(vis));
    }

    void AddEdge(int u, int v) {
        G[u].push_back(v);
    }

    bool dfs(int u){
        int cnt = G[u].size();
        for (int i = 0; i < cnt; i++) {
            int v = G[u][i];
            if (!vis[v]) {
                vis[v] = true;
                if(l[v] == -1 || dfs(l[v]))	{
                    l[v] = u;
                    return true;
                }
            }
        }
        return false;
    }

    int MaxMatch() {
        memset(l, -1, sizeof(l));
        int ans = 0;
        for (int i = nl; i >= 1; i--) {
            memset(vis, false, sizeof(vis));
            ans += dfs(i);
        }
        return ans;
    }
} solver;

int yin[MAXN], g[MAXN][MAXN];

int main() {
    //freopen("in.txt", "r", stdin);
    int n, m;
    while (scanf("%d%d", &n, &m) == 2) {
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                g[i][j] = 1;
        for (int i = 1; i <= m; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            g[u][v] = 0;
        }
        if (n == 0 || m == 0) {
            puts("0");
            continue;
        }
        for (int i = 0; i < n; i++) yin[i] = i + 1;
        int ans = INF;
        do {
            solver.init(n, n);
            for (int i = 0; i < n; i++) {
                for (int j = 1; j <= n; j++) {
                    if (g[j][yin[i]] && g[j][yin[(i + 1) % n]])
                        solver.AddEdge(j, i + 1);
                }
            }
            ans = min(ans, n - solver.MaxMatch());
        } while (next_permutation(yin + 1, yin + n));
        printf("%d\n", ans);
    }
    return 0;
}