（HDU 5727）Necklace <二部图匹配，匈牙利算法> 多校训练1

Necklace

Time Limit: 3000/1500 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 2705 Accepted Submission(s): 846

Problem Description
SJX has 2*N magic gems. N of them have Yin energy inside while others have Yang energy. SJX wants to make a necklace with these magic gems for his beloved BHB. To avoid making the necklace too Yin or too Yang, he must place these magic gems Yin after Yang and Yang after Yin, which means two adjacent gems must have different kind of energy. But he finds that some gems with Yang energy will become somber adjacent with some of the Yin gems and impact the value of the neckless. After trying multiple times, he finds out M rules of the gems. He wants to have a most valuable neckless which means the somber gems must be as less as possible. So he wonders how many gems with Yang energy will become somber if he make the necklace in the best way.

Input
Multiple test cases.

For each test case, the first line contains two integers N(0≤N≤9),M(0≤M≤N∗N), descripted as above.

Then M lines followed, every line contains two integers X,Y, indicates that magic gem X with Yang energy will become somber adjacent with the magic gem Y with Yin energy.

Output
One line per case, an integer indicates that how many gem will become somber at least.

Sample Input
2 1
1 1
3 4
1 1
1 2
1 3
2 1

Sample Output
1
1

Author
HIT

Source
2016 Multi-University Training Contest 1

题意：
有n个阴珠子和阳珠子，把他们排成一个环，要求阴珠子，阳珠子交错放置。并且有些阳珠子若和某些阴珠子相邻会受到影响，问你怎么放才能使受影响的阳珠子数目最少，输出最小值。

分析：
原先脑袋秀逗了，让位可以直接DFS出来（。。。。）结果超时
思路：
对于这一题由于n很小，所以我们可以先枚举出所有阴珠子的排列，然后对于每一种排列，我们向里面每个位置插入所有的阳珠子，若不受影响则说明是一种可行的方法，不多了，每个位置有多个阳珠子满足，所以我们只要利用匈牙利算法求出每种情况的最大匹配，即为每种排列下的阳珠子不受影响的数目tmp，n-tmp则为受影响最少的数目。

AC代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <cmath>
using namespace std;

const int maxn = 11;

int a[maxn];
int n,m,ans;
int g[maxn][maxn];
int pre[maxn],vis[maxn];

struct node
{
    int v,next;
}edge[maxn*maxn];
int head[maxn],e;

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

bool dfs(int u)
{
    for(int i =head[u];i!=-1;i=edge[i].next)
    {
        int v = edge[i].v;
        if(!vis[v])
        {
            vis[v] = 1;
            if(pre[v] == -1 || dfs(pre[v]))
            {
                pre[v] = u;
                return 1;
            }
        }
    }
    return 0;
}

int MaxMatch()//最大匹配
{
    int tmp = 0;
    memset(pre,-1,sizeof(pre));
    for(int i=1;i<=n;i++)
    {
        memset(vis,0,sizeof(vis));
        if(dfs(i)) tmp++;
    }
    return n - tmp;
}

void solve()
{
    memset(head,-1,sizeof(head));
    e = 0;
    for(int i=1;i<=n;i++)//枚举位置
    {
        for(int j=1;j<=n;j++)//枚举阳珠子
        {
            int next = i, pre = i-1;//前，后位置
            if(pre == 0) pre = n;
            if(!g[j][a[next]] && !g[j][a[pre]])//不影响则建边
                addedge(j,i);
        }
    }
    ans = min(ans,MaxMatch());
}

int main()
{
    int u,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n == 0 || m == 0)
        {
            printf("0\n");
            continue;
        }
        memset(g,0,sizeof(g));
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&u,&v);
            g[u][v] = 1;
        }
        for(int i=1;i<=n;i++) a[i] = i;
        ans = 15;
        do{
          solve();
        }while(next_permutation(a+1,a+n));
        printf("%d\n",ans);
    }
    return 0;
}

附上直接DFS超时的代码，个人觉得写的还是蛮好看的

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <cmath>
using namespace std;

const int maxn = 10;
int g[maxn][maxn];
int n,m,ans;
int vis[2][maxn];
int vsomber[maxn];
int neck[maxn];

void dfs(int d,int somber)
{
    if(somber >= ans) return;
    if(d == 2*n)
    {
        if(!vsomber[neck[2*n-1]] && g[neck[2*n-1]][neck[0]]) somber++;
        if(ans > somber) ans = somber;
        return;
    }
    if(d&1)
    {
        for(int i=1;i<=n;i++)
        {
            if(!vis[0][i])
            {
                neck[d] = i;
                vis[0][i]=1;
                if(g[neck[d]][neck[d-1]])
                {
                    vsomber[i]=1;
                    dfs(d+1,somber+1);
                    vsomber[i]=0;
                }
                else dfs(d+1,somber);
                vis[0][i]=0;
            }
        }
    }
    else
    {
        for(int i=1;i<=n;i++)
        {
            if(!vis[1][i])
            {
                neck[d] = i;
                vis[1][i]=1;
                if(d && g[neck[d-1]][neck[d]] && !vsomber[neck[d-1]])
                {
                    vsomber[neck[d-1]] = 1;
                    dfs(d+1,somber+1);
                    vsomber[neck[d-1]]=0;
                }
                else dfs(d+1,somber);
                vis[1][i]=0;
            }
        }
    }
}

int main()
{
    int u,v;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0)
        {
            printf("0\n");
            continue;
        }
        memset(g,0,sizeof(g));
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&u,&v);
            g[u][v] = 1;
        }
        memset(vis,0,sizeof(vis));
        memset(vsomber,0,sizeof(vsomber));
        ans = 10;
        dfs(0,0);
        printf("%d\n",ans);
    }
    return 0;
}