更快的哈密顿路径/哈密顿回路算法
对于哈密顿问题，朴素的做法通常是 \(O(n!)\) 或者 \(O(2^n n^3)\) 的简单状压。接下来我们对哈密顿问题的状压做法进行若干优化，做到空间 \(O(2^n)\)，时间 \(O(2^n n)\)。
首先朴素状压设 \(f_{S,u,v}\) 表示是否存在一条 \(u\) 到 \(v\) 的经过的点集为 \(S\) 的路径。
01 状态显然非常浪费，可以拿类似 bitset 的技巧优化一下。我们将 \(v\) 这一维压成一个数，状态变成 \(f_{S,u}\)，对于点 \(v\) 的邻域也压成一个数 \(g_v\)，那么转移的判断条件变成了 \(g_v\ \text{bitand}\ f_{S,u}\neq 0\)
时间优化到了 \(O(2^n n^2)\)，空间到了 \(O(2^n n)\)。
接下来有两种优化路线：
Route 1
给出这道题，此题瓶颈在于判断每一个点的集合是否是一个回路。
回路的特点是起点任意，所以我们钦定集合中最小的那个点永远是起点，扔掉了 \(u\) 这一维，接下来按照上述方法优化转移即可。
输出方案需要一定的技巧，如果直接记录每个状态的前驱空间复杂度会多一个 \(n\)，这样常数巨大。
正确的做法是用 \(\text{bitand}\) 和 \(\text{lowbit}\) 操作每次找出一个当前点的合法前驱。
原题代码：
#include <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
template<typename T=int>
T read(){
char c=getchar();T x=0;
while(c<48||c>57) c=getchar();
do x=(x<<1)+(x<<3)+(c^48),c=getchar();
while(c>=48&&c<=57);
return x;
}
int n,m;
int g[20];
int f[1<<20];
bool cir[1<<20];
int res[20];
int lis[20],rk;
void output(int s,int x){
puts("Yes");
for(int i=0;i<n;++i){
if(s>>i&1) continue;
res[i]=__builtin_ctz(g[i]&s);
}
while(s^=(1<<x)){
lis[rk++]=x;
x=__builtin_ctz(f[s]&g[x]);
}
lis[rk++]=x;
for(int i=1;i<rk;++i) res[lis[i-1]]=lis[i];
res[lis[rk-1]]=lis[0];
for(int i=0;i<n;++i) printf("%d ",res[i]+1);
putchar('\n');
}
int main(){
n=read();m=read();
for(int i=0;i<m;++i){
int u=read()-1,v=read()-1;
g[u]|=(1<<v);
g[v]|=(1<<u);
}
for(int i=0;i<n;++i) f[1<<i]=1<<i;
for(int s=1;s<(1<<n);++s){
int lb=__builtin_ctz(s);
for(int i=lb+1;i<n;++i){
if(s>>i&1) continue;
if(f[s]&g[i]) f[s|(1<<i)]|=(1<<i);
}
if(f[s]&g[lb]){
bool fl=1;
for(int i=0;i<n;++i){
if(s>>i&1) continue;
if(g[i]&s) continue;
fl=0;break;
}
if(fl){output(s,__builtin_ctz(f[s]&g[lb]));return 0;}
}
}
puts("No");
return 0;
}
哈密顿回路核心代码：
#include <cstdio>
using namespace std;
int n;
int f[1<<24],g[24];
int lis[24],rk;
char str[30];
int main(){
scanf("%d",&n);
for(int i=0;i<n;++i){
scanf("%s",str);
for(int j=0;j<n;++j) g[i]|=(str[j]^48)<<j;
}
for(int i=0;i<n;++i) f[1<<i]=1<<i;
for(int s=1;s<(1<<n);++s){
int lb=__builtin_ctz(s);
for(int i=lb+1;i<n;++i){
if(s>>i&1) continue;
if(f[s]&g[i]) f[s|(1<<i)]|=(1<<i);
}
}
if(f[(1<<n)-1]&g[0]){
puts("Yes");
int s=(1<<n)-1;
int x=__builtin_ctz(f[s]&g[0]);
while(s^=(1<<x)){
printf("%d ",x);
x=__builtin_ctz(f[s]&g[x]);
}
printf("%d ",x);
putchar('\n');
}
else puts("No");
return 0;
}
上述方法不好做哈密顿路径。下面的方法更具有普遍性。
Route 2
给出这道题。
我们发现对于每个起点跑一遍 \(O(2^n n)\) 的 \(\text{DP}\) 很浪费。我们只对一个节点 \(0\) 跑出以它为起点的路径信息 \(f_S\)。
对于一条哈密顿回路，必须有 \(u\in f_{mask_u},v\in f_{mask_v}\)，并且 \(mask_u \cup mask_v=\{0,1,\dots ,n-1\},mask_u \cap mask_v=\{0\}\)
于是枚举 \(mask_u\) 就可以利用位运算统计出所有点对间是否存在哈密顿路径，自然也判断出了哈密顿回路。
原题代码：
#include <cstdio>
using namespace std;
int n;
int f[1<<24],g[24];
int lis[24],rk;
char str[30];
int res[24];
int main(){
scanf("%d",&n);
for(int i=0;i<n;++i){
scanf("%s",str);
for(int j=0;j<n;++j) g[i]|=(str[j]^48)<<j;
}
f[1]=1;
for(int s=1;s<(1<<n);s+=2){
if(!f[s]) continue;
for(int i=1;i<n;++i){
if(s>>i&1) continue;
if(f[s]&g[i]) f[s|(1<<i)]|=(1<<i);
}
}
for(int s=1;s<(1<<n);s+=2){
if(!f[s]) continue;
for(int u=0;u<n;++u)
if(f[s]>>u&1) res[u]|=f[((1<<n)-1)^s^1];
}
for(int u=0;u<n;++u){
for(int v=0;v<n;++v)
if(res[u]>>v&1) putchar('1');
else putchar('0');
putchar('\n');
}
return 0;
}
