poj 2438 图遍历之哈密顿回路

  Dirac 定理：设一个无向图中有 N 个节点，若所有节点的度数都大于等于 N/2，则汉密尔顿回路一定存在。注意，“N/2” 中的除法不是整除，而是实数除法。如果 N 是偶数，当然没有歧义；如果 N 是奇数，则该条件中的 “N/2” 等价于 “⌈N/2⌉”（向上取整）。

证明汉密尔顿回路存在的过程其实就是构造这条回路的过程，分成以下几个步骤：

1. 任意找两个相邻的节点 S 和 T，在它们基础上扩展出一条尽量长的没有重复节点的路径。也就是说，如果 S 与节点 v 相邻，而且 v 不在路径 S → T 上，则可以把该路径变成 v → S → T，然后 v 成为新的 S。从 S 和 T 分别向两头扩展，直到无法扩为止，即所有与 S 或 T 相邻的节点都在路径 S → T 上。

2. 若 S 与 T 相邻，则路径 S → T 形成了一个回路。

3. 若 S 与 T 不相邻，可以构造出一个回路。设路径 S → T 上有 k + 2 个节点，依次为 S、 v1、 v2…… vk 和 T。可以证明存在节点 vi， i ∈ [1, k)，满足 vi 与 T 相邻，且 vi+1 与 S 相邻。证明方法也是根据鸽巢原理，既然与 S 和 T 相邻的点都在该路径上，它们分布的范围只有 v1 ∼ vk 这 k 个点， k ≤ N - 2，而 d(S) + d(T) ≥ N，那么可以想像，肯定存在一个与 S 相邻的点 vi 和一个与 T 相邻的点 vj， 满足 j < i。那么上面的命题也就显然成立了。 找到了满足条件的节点 vi 以后，就可以把原路径变成 S → vi+1 → T → vi → S，即形成了一个回路。

4. 现在我们有了一个没有重复节点的回路。如果它的长度为 N，则汉密尔顿回路就找到了。 如果回路的长度小于 N，由于整个图是连通的，所以在该回路上，一定存在一点与回路以外的点相邻。那么从该点处把回路断开，就变回了一条路径。再按照步骤 1 的方法尽量扩展路径，则一定有新的节点被加进来。接着回到步骤 2。

在整个构造过程中，如果说每次到步骤 4 算是一轮的话，那么由于每一轮当中，至少有一个节点被加入到路径 S → T 中来，所以总的轮数肯定不超过 N 轮。实际上，不难看出该算法的复杂度就是 O(N²)，因为总共扩展了 N 步路径，每步扩展最多枚举所有的节点。

#include <iostream>
#include <string.h>
#include <cstdio>
#include <cmath>
using namespace std;
const int N=410;
int mp[N][N];
int ans[N];
int vis[N];
int start;
int end;
int n,m;
int cnt;
void init()//预处理
{
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
            if(i==j)
                mp[i][j]=0;
            else
                mp[i][j]=1;
    memset(vis,0,sizeof(vis));
    memset(ans,0,sizeof(ans));
    cnt=0;
}
void reverse(int s,int e)//将ans数组中s到t的部分倒置
{
    while(s<e)
    {
        swap(ans[s],ans[e]);
        s++;
        e--;
    }
}
void kuozhan()//从end点开始向外扩展
{
    while(1)
    {
        int flag=0;
        for(int i=1; i<=n; i++)
        {
            if(!vis[i]&&mp[end][i])
            {
                ans[cnt++]=i;
                end=i;
                vis[i]=1;
                flag=1;
                break;
            }
        }
        if(!flag)//此时i=n+1，此时已经遍历全部的点
            break;
    }
}
void hamiltun()//汉密顿回路主体算法
{
    start=1;
    for(int i=1; i<=n; i++)//取任意邻接于s的点为end
        if(mp[1][i])
        {
            end=i;
            break;
        }
    vis[start]=1;
    vis[end]=1;
    ans[0]=start;
    ans[1]=end;
    cnt=2;
    while(1)
    {
        kuozhan();//从end开始向外扩展
        reverse(0,cnt-1);//将当前得到的序列倒置
        swap(start,end);// start和end互换，
        kuozhan();//从end继续扩展，相当于在原来的序列上从start向外扩展
//-------------------------------------------------------------------------------
   //情况一：如果start和end不相邻，进行调整
        int mid=0;
        if(!mp[start][end])
        {
            for(int i=1; i<cnt-2; i++)//取序列中的一点i，使得ans[i]与end相连，ans[i+1]和start相连（一定有这种情况）
            {
                if(mp[ans[i]][end]&&mp[ans[i+1]][start])
                {
                    mid=i+1;
                    break;
                }
            }
            reverse(mid,cnt-1);//将ans[i+1]到end部分的ans[]倒置
            end=ans[cnt-1];
        }
//------------------------------------------------------------------------
   //情况二：如果当前start和end相连
        if(cnt==n)//如果当前序列中已经包含n个元素，算法结束
            break;
        for(int i=1; i<=n; i++)//如果当前序列中元素的个数小于n，寻找点ans[i],使得ans[i]与ans[]外的一点相连
        {
            if(!vis[i])
            {
                int j;
                for(j=1; j<cnt-1; j++)
                    if(mp[ans[j]][i])
                    {
                        mid=j;
                        break;
                    }
                if(mp[ans[mid]][i])
                {
                    end=i;
                    mid=j;
                    break;
                }
            }
        }
        start=ans[mid-1];
        reverse(0,mid-1);//将ans[]中s到ans[i-1] 部分的ans[]倒置
        reverse(mid,cnt-1);//将ans[]中ans[i]到end的部分倒置
        ans[cnt++]=end;//将新找到的这一点i，加入到ans[]尾部
        vis[end]=1;//标记
        //继续进行循环
//-------------------------------------------------------------------------------------
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(!n&&!m)
            break;
        n*=2;
        int u,v;
        init();
        for(int i=1; i<=m; i++)
        {
            scanf("%d%d",&u,&v);//输出的两点是二者之间没有连通的路
            mp[u][v]=mp[v][u]=0;
        }
        hamiltun();
        cout<<ans[0];
        for(int i=1; i<cnt; i++)//输出哈密顿回路的访问路径
            printf(" %d",ans[i]);
        cout << endl;
    }
    return 0;
}

代码测试~~~~~~~~~~~~