poj 2438 Children's Dining

http://poj.org/problem?id=2438

题意：

有2*N个人要坐在一张圆桌上吃饭,有的人之间存在敌对关系,安排一个座位次序,使得敌对的人不相邻.

假设每个人最多有N-1个敌人.如果没有输出"No solution!".

如果i和j可以相邻，之间连一条边

每个人最多有N-1个敌人，所以每个人至少会连出去N+1条边

根据狄拉克定理，图一定是哈密顿图

所以本题不存在无解的情况

然后输出一条哈密顿回路就好了

有关哈密顿图与哈密顿回路的问题 参见文章

http://www.cnblogs.com/TheRoadToTheGold/p/8439160.html

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

#define N 401

int n,m;

bool e[N][N];

int cnt,s,t;
bool vis[N];
int ans[N];

void read(int &x)
{
    x=; char c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) { x=x*+c-''; c=getchar(); }
}

void Reverse(int i,int j)
{
    while(i<j) swap(ans[i++],ans[j--]);
}

void expand()
{
    while()
    {
        int i;
        for(i=;i<=n;++i)
            if(e[t][i] && !vis[i])
            {
                ans[++cnt]=t=i;
                vis[i]=true;
                break;
            }
        if(i>n) return;
    }
}

void Hamilton()
{
    memset(vis,false,sizeof(vis));
    cnt=;
    s=;
    for(t=;t<=n;++t)
        if(e[s][t]) break;
    vis[s]=vis[t]=true;
    cnt=;
    ans[]=s;
    ans[]=t;
    while()
    {
        expand();
        Reverse(,cnt);
        swap(s,t);
        expand();
        if(!e[s][t])
        {
            int i;
            for(i=;i<cnt;++i)
                if(e[ans[i]][t] && e[s][ans[i+]]) break;
            t=ans[i+];
            Reverse(i+,cnt);
        }
        if(cnt==n) break;
        int j,i;
        for(j=;j<=n;++j)
            if(!vis[j])
            {
                for(i=;i<cnt;++i)
                    if(e[ans[i]][j]) break;
                if(e[ans[i]][j]) break;
            }
        s=ans[i-];
        t=j;
        Reverse(,i-);
        Reverse(i,cnt);
        ans[++cnt]=j;
        vis[j]=true;
    }
    for(int i=;i<cnt;++i) printf("%d ",ans[i]);
    printf("%d\n",ans[cnt]);
}

int main()
{
    int u,v;
    while()
    {
        read(n); read(m);
        if(!n) return ;
        memset(e,true,sizeof(e));
        n<<=;
        while(m--)
        {
            read(u); read(v);
            e[u][v]=e[v][u]=false;
        }
        for(int i=;i<=n;++i) e[i][i]=false;
        Hamilton();
    }
}

Children's Dining

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 4672		Accepted: 734		Special Judge

Description

Usually children in kindergarten like to quarrel with each other. This situation annoys the child-care women. For instant, when diner time comes, a fierce conflict may break out when a certain couple of children sitting side by side who are hostile with each other. Although there aren't too many children dining at the same round table, but the relationship of "enemy" or "friend" may be very complex. The child-care women do come across a big problem. Now it is time for you to help them to figure out a proper arrangement of sitting, with which no two "enemy" children is adjacent.

Now we assume that there are 2 * n children who sit around a big table, and that none has more than n - 1 "enemies".

Input

The input is consisted of several test blocks. For each block, the first line contains two integers n and m (1 <= n <= 200, 0 <= m <= n (n - 1)). We use positive integers from 1 to 2 * n to label the children dining round table. Then m lines followed. Each contains positive integers i and j ( i is not equal to j, 1 <= i, j <= 2 * n), which indicate that child i and child j consider each other as "enemy". In a input block, a same relationship isn't given more than once, which means that if "i j" has been given, "j i" will not be given.

There will be a blank line between input blocks. And m = n = 0 indicates the end of input and this case shouldn't be processed.

Output

For each test block, if the proper arrangement exist, you should print a line with a proper one; otherwise, print a line with "No solution!".

Sample Input

1 0

2 2
1 2
3 4

3 6
1 2
1 3
2 4
3 5
4 6
5 6

4 12
1 2
1 3
1 4
2 5
2 6
3 7
3 8
4 8
4 7
5 6
5 7
6 8

0 0

Sample Output

1 2
4 2 3 1
1 6 3 2 5 4
1 6 7 2 3 4 5 8