【算法笔记】哈密顿问题

图论 - 哈密顿问题 同时被 2 个专栏收录
1 篇文章 0 订阅
80 篇文章 29 订阅

哈密顿问题

基本概念

  1. 哈密尔顿通路:经过图中每个结点且仅经过一次的通路。
  2. 哈密尔顿回路:经过图中每个结点且仅经过一次的回路。
  3. 哈密尔顿图:存在哈密尔顿回路的图。
  4. 竞赛图:每对顶点之间都有一条边相连的有向图,n 个顶点的竞赛图称为 n 阶竞赛图。
  5. 与欧拉回路的对比:欧拉回路是指不重复地走过所有路径的回路;哈密尔顿回路是指不重复地走过所有点并且最后回到起点的回路。
    1.哈密尔顿通路的判定
    设一无向图有 n 个顶点,u、v 为图中任意不相邻的两点,deg(x) 代表 x 的度数
    deg(u)+deg(v)\geqslant n-1 成立,则图中存在哈密尔顿通路
    2.哈密尔顿回路的判定:Dirac 定理
    设一无向图有 n 个顶点,u、v 为图中任意不相邻的两点,deg(x) 代表 x 的度数
    deg(u)+deg(v)\geqslant n,则图中存在哈密尔顿回路
    推论:对于 n \geqslant 3 的无向图,若其任一一点 u 的度数 deg(u)\geqslant \frac n2 ,则图中存在哈密尔顿回路
    3.竞赛图
    对于 n \geqslant 2 (点数)的竞赛图,一定存在哈密尔顿通路

状压DP求最短Hamilton

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z8qLv5xs-1602234310079)(C:\Users\11111\AppData\Roaming\Typora\typora-user-images\image-20201009170245133.png)]

int f[1 << 20][20];
int w[20][20];
int n, m;
int main(){
    scanf("%d", &n);
    for(int i = 0; i < n; ++ i)
    for(int j = 0; j < n; ++ j)
    scanf("%d", &w[i][j]);
    
    memset(f, 0x3f, sizeof f);
    f[1][0] = 0;
    
    for(int i = 0; i <= (1 << n) - 1; ++ i)
    for(int j = 0; j < n; ++ j){
        if((i >> j) & 1){
            for(int k = 0; k < n; ++ k){
                if(i ^ (1 << j) >> k & 1){
                    f[i][j] = min(f[i][j], f[i ^ (1 << j)][k] + w[k][j]);
                }
            }
        }
    }
    printf("%d\n", f[(1 << n) - 1][n - 1]);
    return 0;
}


dfs 搜索求哈密尔顿回路

以每个点为起点进行搜索,直到形成回路

#define N 101 
int n,m;
int u,v;
int g[N][N];
int vis[N],appear[N];
int ans[N],num[N];
int length;
void dfs(int last,int i)//last表示上次访问的点 
{  
    vis[i]=1;//标记为已经访问过  
    appear[i]=1;//标记为已在一张图中出现过  
    
    ans[length++]=i;//记录答案  
    for(int j=1;j<=num[i];j++)  
    {  
        if(g[i][j]==x&&g[i][j]!=last)//回到起点构成哈密顿环  
        {   
        	ans[++length]=g[i][j];//存储答案
            
       		for(int i=1;i<=length-1;i++) //找到了一个环,输出ans
       			cout<<ans[i]<<' ';  
    		cout<<ans[length]<<endl;
            
       		length--;//长度-1
        	break;
        }  
        if(!vis[g[i][j]])//遍历与i相关联的所有未访问的点。  
            dfs(i,g[i][j]); 
    }  
    length--;  
    vis[i]=0;//回溯
}  
int main()  
{  
    memset(vis,0,sizeof(vis));  
    memset(appear,0,sizeof(appear));  
    
    cin>>n>>m; //读入点数与边数
    for(int i=1;i<=m;i++)
    {   
        cin>>u>>v; //读入两点
        g[u][++num[v]]=v;//记录u-v的边
        g[v][++num[v]]=u;//记录v-u的边
    }  
  
    for(x=1;x<=n;x++) //枚举每一个点,将其作为起点来尝试访问
    {  
        if(!appear[x])//如果点x不在之前曾经被访问过的图里  
        {  
            length=0;//记录答案的长度  
            dfs(0,x);  
        }  
    }  
    return 0;  
} 

Dirac 定理下构造无向图的哈密顿回路

O ( n 2 ) O(n^2) O(n2)空间上由于边数非常多,所以采用邻接矩阵来存储比较适合

bool G[N][N];
bool vis[N];
int ans[N]; 
void Reverse(int arv[N],int s,int t){//将数组anv从下标s到t的部分的顺序反向
    int temp;
    while(s<t){
        swap(arv[s],arv[t]);
        s++;
        t--;
    }
}
void Hamilton(int n){
 
    int t;
    int s=1;//初始化取s为1号点
    for(int i=1;i<=n;i++)
        if(G[s][i]){
            t=i;//取任意邻接与s的点为t
            break;
        }
 
    memset(vis,false,sizeof(vis));
    vis[s]=true;
    vis[t]=true;
    ans[0]=s;
    ans[1]=t;
 
 
    int ansi=2;
    while(true){
 
        //从t向外扩展
        while(true){
            int i;
            for(i=1;i<=n;i++){
                if(G[t][i] && !vis[i]){
                    ans[ansi++]=i;
                    vis[i]=true;
                    t=i;
                    break;
                }
            }
            if(i>n)
                break;
        }
 
        //将当前得到的序列倒置
        Reverse(ans,0,ansi-1);
 
        //s和t互换
        swap(s,t);
 
        while(true){//从t继续扩展,相当于在原来的序列上从s向外扩展
            int i;
            for(i=1;i<=n;i++){
                if(G[t][i] && !vis[i]){
                    ans[ansi++]=i;
                    vis[i]=true;
                    t=i;
                    break;
                }
            }
            if(i>n)
                break;
        }
 
 
        //如果s和t不相邻,进行调整
        if(!G[s][t]){
            //取序列中的一点i,使得ans[i]与t相连,并且ans[i+1]与s相连
            int i;
            for(i=1;i<ansi-2;i++)
                if(G[ans[i]][t]&&G[s][ans[i+1]])
                    break;
            i++;
            t=ans[i];
            Reverse(ans,i,ansi-1);//将从ans[i+1]到t部分的ans[]倒置
        }//此时s和t相连
 
 
        //如果当前序列包含n个元素,算法结束
        if(ansi==n)
            return;
 
        //当前序列中元素的个数小于n,寻找点ans[i],使得ans[i]与ans[]外的一个点相连
        int i,j;
        for(j=1;j<=n;j++){
            if(vis[j])
                continue;
            for(i=1;i<ansi-2;i++)
                if(G[ans[i]][j])
                    break;
            if(G[ans[i]][j])
                break;
        }
        s=ans[i-1];
        t=j;//将新找到的点j赋给t
        Reverse(ans,0,i-1);//将ans[]中s到ans[i-1]的部分倒置
        Reverse(ans,i,ansi-1);//将ans[]中ans[i]到t的部分倒置
        ans[ansi++]=j;//将点j加入到ans[]尾部
        vis[j]=true;
    }
}
 
int main(){
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF&&(n||m)){
 
        n*=2;
        for(int i=0;i<=n;i++){
            for(int j=0;j<=n;j++){
                if(i==j){
                    G[i][j]=false;
                    G[j][i]=false;
                }
                else{
                    G[i][j]=true;
                    G[j][i]=true;
                }
            }
        }
 
        int ansi=0;
        memset(ans, 0, sizeof(ans));
        for(int i=1;i<=m;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            G[y][x]=false;
            G[x][y]=false;
        }
 
        Hamilton(n);
        for(int i=0;i<n;i++)
            printf("%d ", ans[i]);
        printf("\n");
    }
    return 0;
}

** N 阶竞赛图下构造有向图的哈密顿通路**

含有N个顶点的有向图,且每对顶点之间都有一条边的图,一定存在哈密顿通路

int ans[105];
int map[105][105];
void Insert(int arv[], int &len, int index, int key){
    if(index>len)
        index=len;
    len++;
    for(int i=len-1; i>=0; i--){
        if(i!=index && i)
            arv[i]=arv[i-1];
        else{
            arv[i]=key;
            return;
        }
    }
}
void Hamilton(int n){
    int ansi = 1;
    ans[ansi++] = 1;
    for(int i=2; i<=n; i++){//第一种情况,直接把当前点添加到序列末尾
        if(map[i][ans[ansi-1]]==1)
            ans[ansi++]=i;
        else{
            int flag=0;
            //当前序列从后往前找到第一个满足条件的点j,使得存在<Vj,Vi>且<Vi,Vj+1>.
            for(int j=ansi-2; j>0; j--){
                if(map[i][ans[j]]==1){//找到后把该点插入到序列的第j+1个点前.
                    flag=1;
                    Insert(ans,ansi,j+1,i);
                    break;
                }
            }
            if(!flag)//否则说明所有点都邻接自点i,则把该点直接插入到序列首端.
                Insert(ans,ansi,1,i);
        }
    }
}
int main(){
    int n,m;
    scanf("%d", &n);
    m=n*(n-1)/2;
    for(int i=0;i<m;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        if(u<v)
            map[v][u]=1;
    }
    Hamilton(n);
    for(int i=1;i<=n;i++)
        printf(i==1? "%d":" %d",ans[i]);
    printf("\n");
    return 0;
}

来源

  • 2
    点赞
  • 0
    评论
  • 7
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 护眼 设计师:闪电赇 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值