哈密顿图 Dirac 竞赛图

理论https://blog.csdn.net/qq_41848675/article/details/99686010

---

目录

Dirac

竞赛图

---

Dirac

时间复杂度O(N^2)

分析

模板的63~71时间复杂度n^2

其他的都是n，遵循加法规则，所以时间复杂度O(N^2)

下面是我做的一些配图

S和T不相邻时

相当于T和Vi+1部分颠倒

找到新点j时（T代表终点，而不是哈密顿数组里的t） 方向是哈密顿数组下标增大的方向 j是新的终点，也是新的t，可以用来拓展新点

上图也可以逆时针标一圈箭头表示数组下标增大的方向

 

模板

bool G[N][N];//https://blog.csdn.net/qq_41848675/article/details/99686010
bool vis[N];//哈密顿图不关心权值，因此G数组1代表连通，0代表断路 
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向外扩展
		for(int i=1;i<=n;i++){
			if(G[t][i] && !vis[i]) {
				ans[ansi++]=i;
				vis[i]=true;
				t=i;
				break;
			}
		} 
		//将当前得到的序列倒置
		Reverse(ans,0,ansi-1);//得到的序列是0~ansi-1，长度为ansi 
		//s和t互换
		swap(s,t);
		for(int i=1;i<=n;i++){
			if(G[t][i] && !vis[i]) {
				ans[ansi++]=i;
				vis[i]=true;
				t=i;
				break;
			}
		} 
		//如果s和t不相邻,进行调整
		if(!G[s][t]) {
			//取序列中的一点i,使得ans[i]与t相连,并且ans[i+1]与s相连
			for(int i=1; i<ansi-2; i++)
				if(G[ans[i]][t]&&G[s][ans[i+1]])
					break;
			i++;//i++后地址为Vi+1的地址  转化为S->Vi->T->Vi+1(->S) 
			t=ans[i];//Vi+1  T和Vi+1部分颠倒
			Reverse(ans,i,ansi-1);//将从ans[i+1]到ｔ部分的ans[]倒置
		}//此时s和t相连
		//如果当前序列包含n个元素,算法结束
		if(ansi==n)//得到的序列是0~ansi-1，长度为ansi
			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++)//点j不在哈密顿回路中 
				if(G[ans[i]][j])//哈密顿回路中的i与j相连
					break;
			if(G[ans[i]][j])//i+1也与需要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;//这么做的目的是新节点j可以再次循环去拓展新点 
	}
}
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;
}

竞赛图

时间复杂度最坏为O（n^3）分析

以下均考虑最坏情况

一共要遍历n个点，复杂度为O(n)

内层循环最坏情况下复杂度也是O（n）

最坏情况下每次都要插入到第一位，复杂度是len，len从1到n，姑且算是kn，k=i/n，那么复杂度为kn^3，也就是in^2，i从1~n,取平均值n/2，那么复杂度达到O(n^3)

或者换一种计算方式，先计算插入的总复杂度。外层循环是n^2，意味着要进行n^2级别的插入，而n级别的插入是从1~n，也就是n次从1~n的插入。

而每一次从1~n的插入复杂度为n^2（等差数列1~n求Sn），所以n次复杂度为O(n^3)

综上，时间复杂度最坏为O（n^3）

当然，正常情况下复杂度远远低于n^3，就像网络流一样

模板

int ans[105];//https://blog.csdn.net/qq_41848675/article/details/99686010
int map[105][105];
void Insert(int arv[], int &len, int index, int key){//将key插入长度为len的arv数组中的第index位 
    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[ans[ansi-1][i]]==1)
            ans[ansi++]=i;
        else{
            int flag=0;
            //当前序列从后往前找到第一个满足条件的点j,使得存在<Vj,Vi>且<Vi,Vj+1>.
            for(int j=ansi-2; j>0; j--){
                if(map[ans[j][i]==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;
}