POJ 2438 哈密顿回路

Children's Dining

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 4730		Accepted: 754		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

解析 题目说保证 每个点的度数等于n所以 一定存在哈密顿回路 然后在他给出的图的补图上求一个哈密顿回路就可以了 套一个O(n*n)的板子。

哈密顿图：存在哈密顿回路的图

哈密顿图的判定:

一:Dirac定理(充分条件)

　　设一个无向图中有N个顶点,若所有顶点的度数大于等于N/2,则哈密顿回路一定存在.(N/2指的是⌈N/2⌉,向上取整)

二:基本的必要条件

　　设图G=<V, E>是哈密顿图,则对于v的任意一个非空子集S,若以|S|表示S中元素的数目,G-S表示G中删除了S中的点以及这些点所关联的边后得到的子图,则W(G-S)<=|S|成立.其中W(G-S)是G-S中联通分支数.

三:竞赛图(哈密顿通路)

　　N(N>=2)阶竞赛图一点存在哈密顿通路.

AC代码

 #include <stdio.h>
 #include <string.h>
 using namespace std;
 const int maxn = +;
 bool visit[maxn];
 int mapp[maxn][maxn],ans[maxn];
 int n,m;
 inline void _reverse(int s, int t) //将数组anv从下标s到t的部分的顺序反向
 {
     int temp;
     while(s  < t)
     {
         temp = ans[s];
         ans[s] = ans[t];
         ans[t] = temp;
         s++;
         t--;
     }
 }
 void Hamilton(int n)
 {
     memset(visit,false,sizeof(visit));
     int s = , t;//初始化取s为1号点
     int ansi = ;
     int i, j;
     int w;
     int temp;
     for(i = ; i <= n; i++) if(mapp[s][i]) break;
     t = i;//取任意邻接与s的点为t
     visit[s] = visit[t] = true;
     ans[] = s;
     ans[] = t;
     while(true)
     {
         while(true) //从t向外扩展
         {
             for(i = ; i <= n; i++)
             {
                 if(mapp[t][i] && !visit[i])
                 {
                     ans[ansi++] = i;
                     visit[i] = true;
                     t = i;
                     break;
                 }
             }
             if(i > n) break;
         }
         w = ansi - ;//将当前得到的序列倒置,s和t互换,从t继续扩展,相当于在原来的序列上从s向外扩展
         i = ;
         _reverse(i, w);
         temp = s;
         s = t;
         t = temp;
         while(true) //从新的t继续向外扩展,相当于在原来的序列上从s向外扩展
         {
             for(i = ; i <= n; i++)
             {
                 if(mapp[t][i] && !visit[i])
                 {
                     ans[ansi++] = i;
                     visit[i] = true;
                     t = i;
                     break;
                 }
             }
             if(i > n) break;
         }
         if(!mapp[s][t]) //如果s和t不相邻,进行调整
         {
             for(i = ; i < ansi - ; i++)//取序列中的一点i,使得ans[i]与t相连,并且ans[i+1]与s相连
                 if(mapp[ans[i]][t] && mapp[s][ans[i + ]])break;
             w = ansi - ;
             i++;
             t = ans[i];
             _reverse(i, w);//将从ans[i +１]到ｔ部分的ans[]倒置
         }//此时s和t相连
         if(ansi == n) return;//如果当前序列包含n个元素,算法结束
         for(j = ; j <= n; j++) //当前序列中元素的个数小于n,寻找点ans[i],使得ans[i]与ans[]外的一个点相连
         {
             if(visit[j]) continue;
             for(i = ; i < ansi - ; i++)if(mapp[ans[i]][j])break;
             if(mapp[ans[i]][j]) break;
         }
         s = ans[i - ];
         t = j;//将新找到的点j赋给t
         _reverse(, i - );//将ans[]中s到ans[i-1]的部分倒置
         _reverse(i, ansi - );//将ans[]中ans[i]到t的部分倒置
         ans[ansi++] = j;//将点j加入到ans[]尾部
         visit[j] = true;
     }
 }
 int main()
 {
     while(scanf("%d%d",&n,&m)!=EOF)
     {
         if(n==)break;
         n*=;
         memset(mapp,,sizeof(mapp));
         for(int i=;i<=n;i++)
             for(int j=;j<=n;j++)
                 mapp[i][j]=i==j?:;
         for(int i=;i<m;i++)
         {
             int u,v;
             scanf("%d%d",&u,&v);
             mapp[u][v]=mapp[v][u]=;
         }
         Hamilton(n);
         printf("%d",ans[]);
         for(int i=;i<=n-;i++)
         {
             printf(" %d",ans[i]);
         }
         printf("\n");
     }
 }

该算法的详细过程及哈密顿回路的其他知识

https://www.cnblogs.com/Ash-ly/p/5452580.html