回溯法算法框架及基础

回溯法其实也是一种搜索算法,它可以方便的搜索解空间。
回溯法解题通常可以从以下三步入手:
1、针对问题,定义解空间
2、确定易于搜索的解空间结构
3、以深度优先的方式搜索解空间,并在搜索的过程中进行剪枝
回溯法通常在解空间树上进行搜索,而解空间树通常有子集树和排列树。 


针对这两个问题,算法的框架基本如下:
用回溯法搜索子集合树的一般框架:

void backtrack(int t){  
	if(t > n)
		output(x);  
	else{
		for(int i = f(n,t); i <= g(n,t);i++){  
			x[t] = h(i);  
			if(constraint(t) && bound(t))
				backtrack(t+1);  
		}  
	}
}


用回溯法搜索排列树的算法框架:

void backtrack(int t) {  
	if(t > n)
		output(x);
	else {
		for(int i = f(n,t); i <= g(n,t);i++) {  
			swap(x[t],x[i]);
			if(constraint(t) && bound(t)) {
				backtrack(t+1);
			}
			swap(x[t],x[i]);   
		}
	}
}

其中f(n,t),g(n,t)表示当前扩展结点处未搜索过的子树的起始标号和终止标号, h(i)表示当前扩展节点处,x[t]第i个可选值。constraint(t)和bound(t)是当前扩展结点处的约束函数和限界函数。

constraint(t)返回true时,在当前扩展结点x[1:t]取值满足约束条件,否则不满足约束条件,可减去相应的子树。

bound(t)返回的值为true时,在当前扩展结点x[1:x]处取值未使目标函数越界,还需要由backtrack(t+1)对其相应的子树进一步搜索。
用回溯法其实质上是提供了搜索解空间的方法,当我们能够搜遍解空间时,显然我们就能够找到最优的或者满足条件的解。这便是可行性的问题, 而效率可以通过剪枝函数来降低。但事实上一旦解空间的结构确定了,很大程度上时间复杂度也就确定了,所以选择易于搜索的解空间很重要。
下面我们看看两个最简单的回溯问题,他们也代表了两种搜索类型的问题:子集合问题和排列问题。

第一个问题:
求集合s的所有子集(不包括空集),我们可以按照第一个框架来写代码:

#include<iostream>  
using namespace std;  

int s[3] = {1,3,6};  
int x[3];  
int  N = 3;  
void print(){  
	for(int j = 0; j < N; j++)  
		if(x[j] == 1)  
			cout << s[j] << " ";  
	cout << endl;  
}  

void subset(int i){  
	if(i >= N){  
		print();  
		return;  
	}  
	x[i] = 1;//搜索右子树  
	subset(i+1);  
	x[i] = 0;//搜索左子树  
	subset(i+1);  
}

int main(){  
	subset(0);  
	return 0;  
}



下面我们看第二个问题:排列的问题,求一个集合元素的全排列。
我们可以按照第二个框架写出代码:

#include<iostream>  
using namespace std;  

int a[4] = {1,2,3,4};  
const int N = 4;  

void print(){  
	for(int i = 0; i < N; i++)  
		cout << a[i] << " ";  
	cout << endl;  
}  

void swap(int *a,int i,int j){  
	int temp;  
	temp = a[i];  
	a[i] = a[j];  
	a[j] = temp;  
}  

void backtrack(int i){  
	if(i >= N){  
		print();  
	}  
	for(int j = i; j < N; j++){  
		swap(a,i,j);  
		backtrack(i+1);  
		swap(a,i,j);  
	}  
}  

int main(){  
	backtrack(0);  
	return 0;  
}  

这两个问题很有代表性,事实上有许多问题都是从这两个问题演变而来的。第一个问题,它穷举了所有问题的子集,这是所有第一种类型的基础,第二个问题,它给出了穷举所有排列的方法,这是所有的第二种类型的问题的基础。理解这两个问题,是回溯算法的基础.
下面看看一个较简单的问题:
整数集合s和一个整数sum,求集合s的所有子集su,使得su的元素之和为sum。
这个问题很显然是个子集合问题,我们很容易就可以把第一段代码修改成这个问题的代码:

#include<iostream>  
using namespace std;  

int sum = 10;  
int r = 0;  
int s[5] = {1,3,6,4,2};  
int x[5];  
int  N = 5;  

void print(){  
	for(int j = 0; j < N; j++)  
		if(x[j] == 1)  
			cout << s[j] << " ";  
	cout << endl;  
}  
void sumSet(int i){  
	if(i >= N){  
		if(sum == r) print();  
		return;  
	}  
	if(r < sum){//搜索右子树  
		r += s[i];  
		x[i] = 1;  
		sumSet(i+1);  
		r -= s[i];   
	}  
	x[i] = 0;//搜索左子树  
	sumSet(i+1);  
}  
int main(){  
	sumSet(0);  
	return 0;  
} 

 permute

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值