算法学习（七）回溯算法

回溯算法浅学

1、回溯算法的思想

1.1 概念

回溯法（back tracking）（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回到上一步，重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

1.2 对比穷举法（解空间不同、通过剪枝回溯实现）

1.3 解空间和其他一些概念

解空间结构：

1.4 剪枝函数（当某个顶点没有希望则其所在树枝可以减去）

1.5 回溯算法设计步骤

2、实战例子

2.1、货物装载问题（子集树）

最简单的装载问题
描述：
给定n个货物、每个货物重量为Wi，一艘船的载货总重量为W。问如何选择货物装载使得船尽可能多的装载货物而不翻船？
输入：货物数量n，每个货物的重量
输出：选择的货物i、最大的货物装载量

分析
这个问题其实很像0-1背包问题，只不过约束条件少了价值。货物装与不装使用Xi={0,1}表示，0表示不装，1表示装。则

下面我们来思考其剪枝函数——约束函数和限界函数。
1、如果仅用约束函数作为剪枝函数：

基于上面的理解，我们可以写出如下算法：

#include<iostream>
using namespace std;
int cw=0;//表示当前船上装的货物重量
int bestw=0;//能装载的最大货物重量 

void Backtrack(int t,int *w,int W,int n){//t表示层级，w表示货物的重量，W表示船最大载重，n输入的货物数 
	if(t>n-1){//已经搜索到末尾
		if(cw>bestw&&cw<=W)
			bestw=cw;//最大的重量记录 
		return; 		
	}else{
		if(cw<W){//还能装下货物 
			cw=cw+w[t];//装、左子树 
			Backtrack(t+1,w,W,n); 
			cw=cw-w[t];//不装、右子树 cw之前添加了w，必须减回去
			Backtrack(t+1,w,W,n);
		}
		if(cw==W){
			bestw=cw;
		}//cw>W直接回溯 
		return; 		 
	}
}

int main(){
	int n,W;
	cout<<"请输入n件货物及船的最大载重量W:";
	cin>>n>>W;
	int w[n];
	cout<<"请输入"<<n<<"件物品的重量:"; 
	for(int i=0;i<n;i++){
		cin>>w[i];	
	}
	Backtrack(0,w,W,n); 
	cout<<"最大能装载货量为："<<bestw;
	
	
	return 0;
}

2、如果在约束函数基础上还添加了限界函数，算法效率得到优化

void Backtrack(int t,int *w,int W,int n,int r){//t表示层级，w表示货物的重量，W表示船最大载重，n输入的货物数
	//r表示剩余货物的重量 
	if(t>n-1){//已经搜索到末尾
		if(cw>bestw&&cw<=W)
			bestw=cw;//最大的重量记录 
		return; 		
	}else{
		r=r-w[t];//已经访问该货物了。它不属于剩下的物品了	 
		if(cw<W){//还能装下货物 
			cw=cw+w[t];//装、左子树  
			Backtrack(t+1,w,W,n,r); 
			cw=cw-w[t];//不装、右子树 cw之前添加了w，必须减回去		
		}
		if(r+cw>bestw)//有希望
			Backtrack(t+1,w,W,n,r);		
		r=r+w[t];//
			
		 
	}
}

如果需要追踪装哪些货物的话：

int cw=0;//表示当前船上装的货物重量
int bestw=0;//能装载的最大货物重量  
int bestx[100]={0}; //记录所装货物

void Backtrack(int t,int *w,int W,int n,int r,int *x){//t表示层级，w表示货物的重量，W表示船最大载重，n输入的货物数
//r表示剩余货物的重量 ,x[i]表示货物装不装 
	if(t>n-1){//已经搜索到末尾
		if(cw>bestw&&cw<=W){
			bestw=cw;//最大的重量记录
			for(int i=0;i<n;i++){
				bestx[i]=x[i];
			} 
		} 		 
		return; 
		
	}else{
		r=r-w[t];//已经访问该货物了。它不属于剩下的物品了	 
		if(cw<W){//还能装下货物
			x[t]=1 ;
			cw=cw+w[t];//装、左子树  
			Backtrack(t+1,w,W,n,r,x); 
			cw=cw-w[t];//不装、右子树 cw之前添加了w，必须减回去
		
		}
		if(r+cw>bestw)//有希望
		{
			x[t]=0; 
			Backtrack(t+1,w,W,n,r,x);
		}	
		r=r+w[t];		 
	}
}

2.2、0-1背包问题（子集树）

分析：
同上面的货物装载问题分析，我们只需要知道其约束函数和限界函数，确定剪枝函数即可利用回溯法解决问题。

算法伪代码（这里就不实现了）：

利用了小数背包的算法伪代码：

2.3、 八皇后问题

问题描述：
八皇后问题是一个古老而著名的问题，是回溯算法的典型例题。该问题是十九世纪著名的数学家高斯1850年提出：在8X8格的国际象棋上摆放八个皇后（棋子），使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上。

分析：明显剪枝函数就是不能同行或者同列或同斜线。一旦违反约束函数、则回溯上一个结点。这里的问题就是第row行的皇后放在哪一列才不能违反约束当我们放到第n行说明完成任务。找到一种解法。

#include<iostream>
#include<Math.h>
using namespace std;
int count=0;//解法个数 
bool is_ok(int row,int *queen){   //判断设置的皇后是否在同一行，同一列，或者同一斜线上
    for (int j=0;j<row;j++)
    {
        if (queen[row]==queen[j]||abs(row-j)==abs(queen[row]-queen[j]))
            return false;       
    }
    return true;
}
void back_tracking(int n,int *queen,int row=0)    //算法函数，从第0行开始遍历
{
    if (row==n){//表示放完了n个皇后 
    	count++;//记录解法个数 
    	cout<<endl;
		for(int i=n-1;i>=0;i--){
    		cout<<queen[i]<<" ";
    	}
		return;
	} 	 
                      //判断若遍历完成，就进行计数     
    for (int col=0;col<n;col++)     //遍历棋盘每一列
    {
        queen[row] = col;           //将皇后的位置记录在数组
        if (is_ok(row,queen))             //判断皇后的位置是否有冲突
            back_tracking(n,queen,row+1);   //递归，计算下一个皇后的位置
    }
}
int main(){
	int n;
	cout<<"输入皇后数量："; 
	cin>>n;
	int queen[100]={-1};//皇后默认8个 
	back_tracking(n,queen,0) ;
	cout<<"总解法"<<count<<endl; 

	return 0;
}

2.4、 地图中的点m-着色问题（回溯图）

首先我们分析：
图是用邻接矩阵存储。则无向图对某个顶点v其邻接点判断其颜色是否和其有冲突，冲突我们就让顶点改变颜色即可。约束函数就是邻接顶点不允许有相同的颜色，才能进行下一个顶点的着色。

代码实现：

#include<iostream>
using namespace std;
#define n 5    //图有多少个点
#define m 4     //色数m
int count=0;    //方案数量 
int color[n]={0};          //第i个点里面放的是哪一种颜色 
int a[n][n]={0,1,1,1,0,      //a数组代表无向图的邻接矩阵 
             1,0,1,1,1,
             1,1,0,1,0,
             1,1,1,0,1,
             0,1,0,1,0};
bool OK(int t){
    for(int j=0;j<t;j++){//t表示已经着色的点数 
        if(a[t][j]==1){//存在边 
            if(color[t]==color[j])//两个顶点颜色相同 
                return false;
        } 
    } 
    return true;
} 
        
void traceback(int t){//t表示顶点编号 
    if(t==n){    //n个点都已经走完
        count++;
		cout<<"颜色标号: "; 
        for(int i=0;i<n;i++){
        	cout<<color[i]<<" "; 
		} 
		cout<<endl; 
        return;
    }
    for(int i=0;i<m;i++){   //i代表颜色 
        color[t]=i+1;//第t个顶点的颜色为i颜色 
        if(OK(t)){//判断是否违反约束函数 
            traceback(t+1);
        }
        //else
		//	color[t]=0; //违反，则将color（t）标记为未着色状态 	  
    } 
} 
             
int main(){
    traceback(0);   //t代表无向图的顶点 
    cout<<"方法数:"<<count; 
    return 0;
}

3、小结

回溯法就是改良版的穷举法。其属于深度优先搜索，由于是全局搜索，复杂度相对高。当然，如果你选择深入了解这个算法，必然会枯燥。