算法---回溯（正文）

1.什么是回溯？

回溯算法的定义就是和暴力枚举一样枚举所有可能并加撤回，也能和暴力一样去掉一些重复（在之前就被筛出，但还要枚举这个，我们可以跳过这个了---------这个就是回溯剪枝）。但为什么回溯不是暴力呢？----这个问题大家可以先想想最后我在说。

其实回溯也是递归，如果你熟悉树状图的话，你会发现回溯的枚举过程就是一个树，而递归呢也是一棵树

2.“回溯”该怎么做？

回溯顾名思义就是撤回，走到头也要像递归一样终止（如果到头的结果对了储藏答案反之否）。如果没走到头则产生多个子节点继续探索。
根据上面的解释回溯的代码应为

void dfs(变量){
	if(终止条件){
		存放结果 
		return ; //结束 
	}
	枚举所有可行 
}

当然这是最基本的模版，并没用到回溯
下面是标准模板

int flag[105];//标记 1 yes 2 no
void dfs(变量){
    if(终止条件){
	   if(判断是否存放结果){
	   	存放 
	   }
	   return ;
	} 
	for(枚举){
	   if(flag[i]==0)   //判断是否被标记过
	   {
	   	flag[i]=1; //标记 
	   	存放数据 
		   dfs(变量+1);
		   flag[i]=0; //回溯 
	   } 
	} 
} 

3.回溯经典问题

全排列

输入正整数N，输出由1到N这N个数(N<=7)的所有排列，每行一个排列，数与数之间有一个空格，两个排列中，第一个数小的优先输出，第一个数相同，比较第二个数，后面以此类推。

输入
正整数N

输出
所有排列

样例
输入 1
3
输出 1
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
【分析】题目比较简单，模板一带就行

#include
using namespace std;
int n;
int a[105],flag[105];
void dfs(int dep){   //判断到第几层了
	if(dep==n+1){   
		for(int i=1;i<=n;i++){  //输出
			cout<<a[i]<<" ";
		}
		cout<<"\n";
		return ;
	}
	for(int i=1;i<=n;i++){
		if(flag[i]!=1){
			flag[i]=1;
			a[dep]=i;
			dfs(dep+1);
			flag[i]=0;  //回溯
		}
	}
} 
int main(){
cin>>n;
dfs(1);
    return 0;
}

组合数的拆分

【题目描述】
排列与组合是常用的数学方法，其中组合就是从n个元素中抽出r个元素(不分顺序且r≤n)，我们可以简单地将n个元素理解为自然数1，2，…，n，从中任取r个数。

现要求你用递归的方法输出所有组合。

例如n＝5，r＝3，所有组合为：

1 2 3 1 2 4 1 2 5 1 3 4 1 3 5 1 4 5 2 3 4 2 3 5 2 4 5 3 4 5

【输入】
一行两个自然数n、r(1

【输出】
所有的组合，每一个组合占一行且其中的元素按由小到大的顺序排列，每个元素占三个字符的位置，所有的组合也按字典顺序。

【输入样例】
5 3
【输出样例】
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
【分析】与全排列只能说如出一辙，只需注意排序顺序

int ab[30];
int flag[30];
int n,r;
void dfs(int dep,int last){   //底几层   上一个数+1是啥
	if(dep == r+1){
		for(int i = 1 ; i < dep ; i++){
	    cout << setw(3) << ab[i];
		}
		cout << "\n";
		return ;
	}
	for(int i = last ; i <= n ; i++){  //从上一个数+1开始枚举
		if(flag[i] == 0){
			flag[i] = 1;
			ab[dep] = i;
			dfs( dep+1 , i+1 );
			flag[i] = 0;
		}
	}
}
int main()
{
cin >> n >> r;
dfs(1,1);
	return 0;
}

LETTERS

【题目描述】
给出一个row×col
的大写字母矩阵，一开始的位置为左上角，你可以向上下左右四个方向移动，并且不能移向曾经经过的字母。问最多可以经过几个字母。

【输入】
第一行，输入字母矩阵行数R
和列数S
，1≤R,S≤20
。

接着输出R
行S
列字母矩阵。

【输出】
最多能走过的不同字母的个数。

【输入样例】
3 6
HFDFFB
AJHGDH
DGAGEH
【输出样例】
6
【分析】这个题目是回溯+递归（深搜），不过难度不大有方向数组就行

#include
using namespace std;
int row,col; 
char ab[25][25];
int flag[27];
int dx[]={0,0,-1,1}; //方向数组
int dy[]={1,-1,0,0};
int rc[25][25],cnt=0;
void dfs(int x,int y,int ans){  //当前位置    探索了多少
	cnt=max(ans,cnt);
	for(int i=0;i<4;i++){
		int xd=dx[i]+x;
		int yd=dy[i]+y;
		if(flag[int(ab[xd][yd]-'A')]==0&&rc[xd][yd]==0&&xd>=1&&xd<=row&&yd>=1&&yd<=col){
			flag[int(ab[xd][yd]-'A')]=1;
			rc[xd][yd]=1;
			dfs(xd,yd,ans+1);
			flag[int(ab[xd][yd]-'A')]=0;  //回溯
			rc[xd][yd]=0;
		}
	}
	return;
}
int main()
{
cin>>row>>col;
for(int i=1;i<=row;i++){
	for(int j=1;j<=col;j++){
		cin>>ab[i][j];
	}
}
flag[int(ab[1][1]-'A')]=1; //刚开始的被探索过了
rc[1][1]=1;
dfs(1,1,1);
cout<<cnt;
	return 0;
}

N皇后

在8*8国际象棋盘上，放置8个皇后，使得任意两个皇后都不会互相攻击，一共有多少种摆法？这就是著名的8皇后问题。

现在我们来尝试，在N*N的棋盘上，放置N个皇后，使得它们不会互相攻击。

皇后的走子规则是，沿着横、竖、两条对角线方向可以走任意步数。

输入
1个整数N

输出
一个整数,表示N皇后的不同解答个数

样例
输入 1
8
输出 1
92
5<=n<=9
【分析】毋庸置疑回溯，他要判断三项，那我们想，我们是不是可以不用关行了，因为我们可以枚举每一行，然后可以用回溯解决列，那斜线呢，当然也能拿数组去回溯。可是当你去回溯时，怎么做呢？
我们不妨句例子下
4皇后
（1,1）（1,2）（1,3）（1,4）
（2,1）（2,2）（2,3）（2,4）
（3,1）（3,2）（3,3）（3,4）
（4,1）（4,2）（4,3）（4,4）
当我们打上正反斜线，发现什么了？每个斜线上的各店的x+y互相相等----正斜线
每个斜线上的x与y的差（abs(x-y)）互相相等----反斜线
所以我们可以用俩个数组标记俩斜线

#include
using namespace std;
int n;
int lie[12],ans,xie1[100],xie2[100]; //标记数组
void dfs(int dep){
	if(dep==n+1){
		ans++;
		return ;
	} 
	for(int i=1;i<=n;i++){
		if(lie[i]==0&&xie1[dep+i]==0&&xie2[dep-i+10]==0){  //如果dep-i<0,+10会让dep-i>0因为n<=9
			lie[i]=1;
			xie1[dep+i]=1;
			xie2[dep-i+10]=1;
			dfs(dep+1);
			lie[i]=0;
			xie1[dep+i]=0;
			xie2[dep-i+10]=0;
		}
	}
}
int main()
{
cin>>n;
dfs(1);
cout<<ans;
	return 0;
}

造素数

现在给你n个数，你需要从中选出m个数，使得这m个数的和为素数，求出可选的方案数。

输入
第一行两个整数n和m。

第二行n个整数，表示可选的数字。

输出
输出有多少种方案可以使得选出的数之后为素数。

样例
输入 1
3 2
1 2 3

输出 1
2

输入 2
3 1
2 2 2
输出 2
3
这里不做分析了原理同组合数的拆分

#include
using namespace std;
int n,m,ans;
int a[105],b[105];
bool isprime(int n){
	if(n==1) return false;
	for(int i=2;i*i<=n;i++){
		if(n%i==0) return false;
	}
	return true;
}
void dfs(int cnt,int now){
	if(now==n+1){
		if(cnt==m){
			int k=0;
			for(int i=0;i<cnt;i++){
				k+=b[i];
			}
			if(isprime(k)){
				ans++;
			}
		}
		return ;
	}
	b[cnt]=a[now];
	dfs(cnt+1,now+1); //选
	dfs(cnt,now+1); //不选
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++) cin>>a[i];
dfs(0,1);
cout<<ans<<"\n";
    return 0;
}

最后解答一下开始时的问题
在这几个例题中，相信大家已经看出来了暴力需要好几层，而虽然回溯也是和暴力差不多的时间复杂度可是却可以用少量代码解决要几个for才能解决的问题（有的时候也是解决不了的如LETTERS）