回溯的递归框架	回溯的非递归模式
输入：n
输出：所有的解x[]
int x[n],i=1; search(int i) { if(i>n)//递归出口输出结果; else//枚举所有可能的路径 { for(j=下界;j<=上界;j=j+1)//当前结点的子节点的同一层 { //满足界限函数和约束条件 if(P(j))// { //深度下一层 x[i]=j;//将符合要求的结点的编号，存储到解的数组里 ...//其他操作 search(i+1); 回溯前的清理工作;//再进行for循环下一个结点 } } } }	int x[n],i=1; //还未回溯到头， i为真表示有路可走 while(i&&(未达到目标) ) { if(i>n)//搜索到叶节点搜索到一个解，输出; else//处理第i个元素 { x[i]第一个可能的值； //x[i]不满足约束条件，但在搜索空间内 while( !P(x[i]) && x[i]在搜索空间内 ) x[i]下一个可能的值； if( x[i]在搜索空间内) { 标识占用的资源； i=i+1;//扩展下一个结点 } else { 清理所占的状态空间； i=i-1;//回溯 } } }

思考题1：

(1)不是唯一， n元组

（3）剪枝：判断是否满足约束条件。执行：将结点标为死结点。

回溯算法的适用条件

多米诺性质

设向量X i =<x 1 , x 2 ,…,x i >，X i $\subseteq$ X，X = < x 1 , x 2 ,…,x i ,…,x n >，

将X i 输入评价函数P，可以得到X i 的一组特征值P(X i )，

取X i+1 =<x 1 , x 2 ,…,x i , x i+1 >【增加一个元素】，Xi+1 $\subseteq$ X，则P(Xi+1) 真蕴涵P(X i )，即

P(Xi+1) -> P(Xi) i∈(0,n) ,其中，n代表解向量的维数。

【子集，否则可能丢解】

【例6-1】求满足下列不等式的所有整数解：

解：令X i =<x 1 , x 2 ,…,x i >，P(X i )为对X i 的评估，判断其Xi是否满

足不等式，即P(X i ) ≤10。依据题目可知，本例中向量为一个三元

组< x 1 , x 2 , x 3 > 。

【丢解】

当x1=1、x2=2时， P(x1 ,x2 )= 5x1+4x2=5*1+4*2=13>10 不满足约束条件，分支x2=2将被剪去

然而，当x 1 =1、x 2 =2、x 3=3时， P(x 1 ,x 2 ,x 3 )= 5x 1 +4x 2 - x 3=5*1+4*2 - 3=10 满足约束条件，即<1, 2, 3>是不等式的解，

显然，此例中P(X 3 )不真蕴涵P(X 2)，违反了多米诺性质，从而丢解了。

【解决】

如果令x’3=4-x3 ，将原不等式变换为：5x1+4x2+x’3≤14 1≤xi , x’3≤3 i=1, 2

则该不等式满足多米诺性质，可以使用回溯法，对所得到的解x 1 、x 2 、x’ 3 转

换成原不等式的解x 1 、x 2 、x 3 即可。

代码：

#include<iostream>
using namespace std;


//
int n=3;
int x[3]={1,1,1};

void show(int a[]) 
{
	for(int i=0;i<n;i++)
		cout<<a[i]<<"\t";
	cout<<endl<<endl;
}

//约束条件
bool P(int x[],int i)//表示第几层 
{
	switch(i)
	{
	case 0: 
		if(5*x[0]<=14)return true;
			else return false;
	case 1:
		if(5*x[0]+4*x[1]<=14)return true;
			else return false;
	case 2:
		if(5*x[0]+4*x[1]+x[2]<=14)return true;
			else return false;
	}
	
} 

void fun(int i)
{
//	cout<<i<<"c"<<endl;
//	show(x);
	if(i>n-1)//已经结束了最后一个数 
	{
//		cout<<"结果:";
		show(x);
		return;//结束最后一层，回溯到上一层 
	}
	//若不变 
	if(P(x,i)&&x[i]<4)//符合约束条件 
	{
		x[i]=1;
		fun(i+1); //下一层 
	}
	//若2
	if(P(x,i)&&x[i]<4)//符合约束条件 
	{
		int t=x[i];
		x[i]=2;
		fun(i+1); //下一层 
		x[i]=t;//回复 
	}
	
	//若3
	if(P(x,i)&&x[i]<4)//符合约束条件 
	{
		int t=x[i];
		x[i]=3; 
		fun(i+1); //下一层 
		x[i]=t;//回溯后，本层尝试下一个可能 
	} 
}

int main()
{
	fun(0);
	return 0;
	
} 
/*
1       1       1

1       1       2

1       1       3

1       2       1

1       2       2

1       2       3
*/

6.2回溯算法的经典例题

【例6-2】装载问题

有n个集装箱要装上一艘载重量为c的轮船，其中，集装箱i的重量为w i 。找出一种最优装载方案，让轮船尽可能多装集装箱，即在装载体积不受限制的情况下，尽可能使轮船满载。

 问题分析

设集装箱数量n=5，轮船载重c=10，集装箱的重量w={7,2,6,5,4}

对于n个集装箱的装载问题，可将该问题的解定义为一个n元组

(x 1 ,…,x i ,…x n ), i∈Z, 1≤i≤n, x i ∈{0,1},

x i =1表示装入集装箱i，x i=0表示不装入集装箱i。

其中，wi 表示第i个集装箱的重量。

满足多米诺条件 ：

计算模型

1. 数据结构定义

 静态数据结构：

轮船载重量为c，集装箱数量为n，集装箱重量数组 w[]，这些变量在运算中不会发生改变。

 动态数据结构：

i表示搜索的层数，加入一个集装箱后计算出的当前载重量nowc、当前解x[]、当前最优重量maxc、当前最优解maxx[]，剩余的集装箱重量r（初值为全部集装箱重量），

这些值都是边测试边生成的，当所有计算全部完成后，maxc和maxx[]就是题目要求的最优值和最优解。

2. 迭代公式

 算法设计与描述

输入：c, n, w[]

输出：最优值maxc和最优解maxx[]

void search (int i){ /*递归法*/
	if(i>n){//搜索完
		if(nowc>maxc){//现在重量值
			maxc=nowc;
			for(int j=1;j<=n;j++)
				maxx[j]=x[j];
		}
		return;
	}
	
	//剩余量 
	r=r-w[i]; //搜索第i层，同时减少可用量
	//若不装，则岸上重量减去
	if(nowc+w[i]<=c){ //满足约束，左子树
		x[i]=1;
		nowc=nowc+w[i];
		search(i+1);//递归搜索i+1层
		nowc=nowc-w[i];//回溯后恢复nowc
	} 
	/*下面开始搜索右子树*/
	if(nowc+r>maxc){ /*大于当前最优*/
		x[i]=0;
		search(i+1); //递归搜索i+1层
	}
	r=r+w[i];//对第i层搜索完毕，恢复r
}

算法分析：

(1)由算法设计与描述推导

T(1) = 2T(1) //集装箱1选择与不选择

2T(1) = 2*2T(1)＝2^ 2 T(1)

……

2 ^( n-1) T(1) = 2*2^( n-1) T(1) = 2^ n T(1)

T(n) = T(1)+ 2T(1)+ 2^ 2 T(1)+……+2^ n T(1)

= T(1)*(2^( n+1) – 1)≤2×2^ n =O(2^ n )

(2) 由选择树推导

结点数为: 1+2+2^ 2 +……+2^ n

=2^( n+1) - 1≤ 2×2^ n =O(2^ n )

代码：

#include<iostream>
using namespace std;

int n=5;//集装箱数量 
int c=10;//轮船载重
int w[]={7,2,6,5,4};//集装箱的重量

int nowc=0;//当前载重量 
int x[5];//当前解
int maxc=0;//当前最优重量 
int maxx[5]; //当前最优解
int r=7+2+6+5+4;//剩余集装箱的总重量 


void show(int a[]) 
{
	for(int i=0;i<n;i++)
		cout<<a[i]<<"\t";
	cout<<endl<<endl;
}

void search (int i){ /*递归法*/
	if(i>n-1){//搜索完 递归出口 
		if(nowc>maxc){//现在重量值>当前最优 
			//更新最优解 
			maxc=nowc;
			//记录最优解的路径 
			for(int j=1;j<=n;j++)
				maxx[j]=x[j];
		}
		return;//结束最后一层的函数，回溯到上一层进行递归调用 
	}
	
	r=r-w[i]; //此时 陆地上集装箱的剩余重量 
	//若不装，则岸上重量减去
	
	if(nowc+w[i]<=c){ //满足约束（小于轮船载重量），左子树
		x[i]=1;
		nowc=nowc+w[i];
		search(i+1);//递归搜索i+1层
		nowc=nowc-w[i];//回溯后恢复nowc
		//回到上一层 
	}
	/*下面开始搜索右子树 */
	//右子树是否需要递归
	if(nowc+r>maxc){ /*上界函数 此时当前轮船已载重量+剩余集装箱重量 > 当前最优*/
		x[i]=0;
		search(i+1); //递归搜索i+1层
	}//否则不进行递归，也就是可以确认为死结点 
	
	r=r+w[i];//对第i层搜索完毕，恢复r
	//陆地上增加 
}

int main()
{
	search(0);//从第1层开始 
	cout<<maxc<<endl;
	show(maxx);
	
	return 0;
}

【例6-3】n皇后问题。

在n*n的棋盘上放置相互攻击不到的n个皇后。

国际象棋规则：任意两个皇后之间不能处在同一行、同一列和同一斜线上，否则皇后间就可以相互攻击。

请给出满足条件的所有方案。

 问题分析算法思想详见开篇。

 计算模型

（1）数据结构

皇后数量为n； sum为可行解的数量。

x[]记录皇后的摆放位置，下标为皇后所在行，值为列。

/*若数组下标参与运算，会大大遍历*/

（2）计算模型

其中，式（2）与式（3）共同构成了对式（1）中所取得的值的一个评价，所以可以统称式（2）和式（3）为评价函数P。

 算法设计与描述

输入：皇后的数量n

输出：皇后的摆放位置x[]，可以有多组


/*判断当前格局x[1...i]，是否符合约束*/
bool ok(int i){
    for(int j=1;j<i;j++)
        //值相等 或 在对角线上 
        if(x[i]==x[j]||(abs(x[i]-x[j])==(i-j)))
            return false;
    return true;
}

void queen(int i){
    
    if(i>n){//找到可行解
        for(int j=1;j<=n;j++)
            printf("%-5d",x[j]);
        printf("\n");
        sum=sum+1;//可行解数目+1 
    }
    
    for(int j=1;j<=n;j++){//每一层都有n个元素 
        x[i]=j;
        if(ok(i))//如果满足约束
            queen(i+1);//搜索第i+1层
        //否则就结束在这一层 
    }
}

 算法分析

由选择树可知：

由ok函数：

时间复杂度为：

另一种：随机算法

程序设计可能很麻烦，实际实现效率非常差。

回溯和随机相结合——更好

【例6-4】 0-1背包问题。

已知有n件物品，物品i的重量为wi、价值为pi。现从中选取一部分物品装入一个背包内，背包最多可容纳的总重量是m，如何选择才能使得物品的总价值最大？

 问题分析

物品数量n=3

物品重量w={10,20,30}

物品价值p={60,100,120}

背包承重m=50

数学模型

pi第i个物品价值>0，xi第i个物品是否被选择[0,1]

计算模型

1. 数据结构

背包容量m，物品数量n，物品重量数组w[]，物品价值数组p[]。

当前背包重量bagw，当前背包总价bagp，当前最优解x[]

当前最优总价值maxp，最优解maxx[]，可用的物品价值r。

2. 迭代公式

 算法设计与描述

void bag(int i){

if(i>n){

if(bagp>maxp){

maxp=bagp;

for(int j=1;j<=n;j++){

maxx[j]=x[j];

}

return;

}

r=r-p[i]; //对第i层进行搜索,用r减少

if(bagw+w[i]<=m){ //满足约束

x[i]=1;

bagw=bagw+w[i];

bagp=bagp+p[i];

bag(i+1);

bagw=bagw-w[i]; //回溯后恢复bagw

bagp=bagp-p[i]; //回溯后恢复bagp

}

if(bagp+r>maxp){ //搜索右子树

x[i]=0;

bag(i+1);

}

r=r+p[i]; //对第i层进行搜索回来，恢复r

}

 算法分析

思考题：

	蛮力法	回溯法
区别	回溯法有对右子树的剪枝
时间渐进复杂度	T(n)=O(2^n)	T(n)=O(2^n)
区别	在实际运算中，同样情况下回溯法的时间复杂度优于蛮力法，回溯法最坏情况下的时间渐进复杂度与蛮力法相同。
原因	回溯法存在剪枝操作。

代码：

#include<iostream>

using namespace std;

int n=3;//物品数量 
int w[]={10,20,30};//物品重量 
int p[]={60,100,120};//物品价值 
int m=50;//背包称重
//使物品总价值最大 

int bagw=0;//当前背包重量
int bagp=0;//当前背包价值
int x[3];//当前最优解
int maxp=0;//当前最优总价值
int maxx[3];//最优解
int r=60+100+120;//可用的物品价值，也就是物品总价值剩余量 

void show(int a[]) 
{
	for(int i=0;i<n;i++)
		cout<<a[i]<<"\t";
	cout<<endl<<endl;
}

void bag(int i)
{
	if(i>n-1)
	{
		if(bagp>maxp)
		{
			maxp=bagp;
			for(int j=0;j<n;j++)
			{
				maxx[j]=x[j];
			}
		}
		return ;
	}
	//
	r=r-p[i];//对第i层进行搜索，r 减少
	
	if(bagw+w[i]<=m)//小于背包总重量（约束条件） 
	{
		x[i]=1;
		bagw=bagw+w[i];//更新当前背包重量
		bagp=bagp+p[i];//更新价值
		bag(i+1);//下一层
		bagw=bagw-w[i];//回溯
		bagp=bagp-p[i]; 
	} 
	if(bagp+r >maxp)//如果当前价值+剩余价值> 当前最大价值 还有递归的必要
	//如果是 当前价值+剩余价值 <= 当前最大价值,那么其实就没有递归的必要了 
	{
		x[i]=0;//右子树 
		bag(i+1);
	}
	r=r+p[i];//对第i层进行搜索回来，回复r 
	
}

int main()
{
	bag(0); 
	cout<<maxp<<endl;
	show(maxx);
	return 0;
}