递归加回溯

1、框架

1.1、递归框架

function A

 结束条件

 违法判断

 正常逻辑代码

 for every situation
    递归
 

        切记上面你的违法判断,我们不用实现分情况讨论啥情况下回违法,只需要最后判断是否违法就行了,结束条件一定要弄清楚,其次你写递归的时候最好不要带返回值吧,如果需要返回值的情况下你可以使用全局变量或者用参数传递这个变量!!!(带返回值的递归会比较麻烦一点)

1.2、回溯框架

function B

    结束条件

    违法判断
 
    正常逻辑代码

    for every situation
        
        变量修改或者作出选择
        
        递归
        
        把修改的变量恢复原样,作出的选择恢复原样

 

回溯和递归很相似,为啥叫回溯呢实际上就是在后面需要将之前作出的修改恢复。递归和回溯都有个很麻烦的逻辑思维,我给你画一个图:

        对你想得没错,只要你这个递归没有走到结束条件那一块就会无限这样套娃,谁都执行不完,只有最后一个可以执行完成,在递归调用之前的出口执行结束,然后再从最后一个一个的返回执行后续的代码。那么选择或者变量改变的意思就是在函数A的调用前对某些变量作出了修改,目的是为了后面的递归执行时需要用到这个变量(让其保持下一个时刻情况下的正确值),然后返回的时候我们需要将改变进行修改,因为当前分支可能并不满足,如下图:

       然后再每个情况的分支上又每个都分N个,一直这样递归的下去,这就是带情况分支的递归。我们就以这个为例:假设我程序先执行情况1对某些变量进行了修改,但是这些修改只是在情况1发生的前提下修改的。(比如我中了彩票,我就要去买个法拉利,但是这个假设是我要中彩票才行!!)然后这个情况走完了(注意这个走完了的意思是:)

1、这个分支可能最后成功了(满足我们的要求了)

2、这个分支可能失败了(走不下去了并且不满足我们的要求)

无论是上面的哪种情况,我们都要返回到上一层的分支,因为我们的目的是求出所有的可能性,然后选一个最好的可能性!!!

        那么在回到上一层,需要进行情况2的选择时,我们应该排除之前情况1的干扰,因为不管成不成功,那都将影响我们拔剑的速度(影响后面分支情况),这就是回溯的原因。

2、纸上得来终觉浅

例题2.1

给定一个整数n,要求从1~~~n的整数间选出K个数,但是要求不能选相邻的两个数,请问有多少种选择方法?

 

解析:做编程题目的时候就不要想啥排列组合啦,而且也非常的难想,这道题目的难点在于不能取邻接的两个数据,这个就是一个小技巧的使用,你看看我的代码:

int count = 0;

// @Param last:最后一次选取的数
// @Param n:输入的n,代表从1-n取数据
void function(int last,int n){
        
    for(int i = last+2;i <= n;i++)
    {
        count++;
        function(i,n);
    }
}

       上面关键点就在i = last+2,然后递归的参数是记录上一次最后选取的数据,我们只需要跳过相邻的那个数就好了,后面的数都可以取。其实从这个代码我们还能感受到递归的优势就是之前讲解的,值考虑局部就好了。就比如这个题目你不用考虑我要是选择的两个数据是相邻的,然后怎么样;我选择的两个数隔两个,然后怎么样。。。。你只需要知道当前局面怎么处理,然后问题规模减小,直接把新的变量传入就行了,这么处理肯定是对的,因为下一次面临的局面还是和本次一模一样,只是问题的规模减小了(简单认为就是数变少了)

       不知道细心的你发现上面代码的问题了吗?对比模板我们发现其实少了一些东西是吧,对照模板补充如下:

int count = 0;

// @Param last:最后一次选取的数
// @Param n:输入的n,代表从1-n取数据
// @Param k:记录要取多少个数
void function(int last,int n,int k){
    
    // 出口自然就是数pick完成了
    // return的意思就是本次函数执行完了,
    // 直接跳到本函数的最后面,中间的代码全部
    // 不执行了,管你中间有没有递归还是什么牛
    // 鬼蛇神的
    if(k == 0){
         count++;
         return;
    }

    // 违法
    if(k > n) return;

    // 特殊情况,当然你的递归写得优秀这个不一定有
    // 不过有时候一些很特殊的情况,边界条件拿出来
    // 是会有大用处的
    if(n == k){
        count = 1;
        return;
    }

    for(int i = last+2;i < n;i++)
    {
        // 注意这里不要写成k--了,因为k--就代表把k改变了
        // 回来的时候你是需要回溯的
        // k-1的好处就是k没有改变,但是又把k-1的值传递个下
        // 一次调用了,因为本次选了一个数,所以下一次还需要
        // 选取的数的数量就少1
        function(i,n,k-1);
    }
}

例题2.2

在第一行我们写上一个 0。接下来的每一行,将前一行中的0替换为011替换为10

给定行数 N 和序数 K,返回第 N 行中第 K个字符。(K从1开始)

同样也是个递归的小题目,我们的很多小伙伴看见题目确实知道该递归,但是怎么写就不知道了,来我们看模板:

1、出口条件是啥? 

答:第N行

2、违法判断是啥?

答:无

3、正常逻辑是啥?

答:把每行的数字填充上

4、是否涉及到分支选择:

答:无

ok,那么来写程序:

#include<math.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
char *number;
int index = 0;
char remember;

void kthGrammar(int N, int K){
	// 出口
	if(N == 1){
		remember = number[K-1];
		printf("result:%c\n",remember);
		return;
	}
	
	//违法判断,K必^n大,这个在主函数判断一下就行了

	//正常逻辑
    for(int i = index-1;i >= 0;i--){
		// 注意需要从后面开始挪动,不然从前面会把后面还没有挪动
		// 的数据覆盖
		if(number[i] == '0'){
			number[2*i] = '0';
			number[2*i+1] = '1';
		}else{
			number[2*i] = '1';
			number[2*i+1] = '0';
		}
	}
	index = index*2;
	number[index] = '\0';
	//printf("当前的层数:%d:%s\n",N,number);
	//printf("\n");
	// 这里--也行,但是为了统一我们以后都用-1吧!
	kthGrammar(N-1, K);
}

实际上上面的正常逻辑很简单,主要是你看看递归的参数和结束条件。

例题2.3

上面的两个题目你可能会觉得比较简单,那么我们来一个稍微难一点的,但是思路其实都类似!

 

这道题目就很难了,首先我们要明白这种全排列,选子集,一共有多少种方法的题目很大概率可以用递归来解决问题!!!

1、出口条件是什么呢?

答:输入的字符串被我们转换成字母完成了(转换最后一个数完成。)

2、违法是什么呢?

答:无

3、正常逻辑就是看见一个数字转换成对应的字母就行

4、有无分支选择?

答:肯定有的嘛,不就是一个按键有几种可能的字母嘛

那么程序其实并不难:

// 存储结果和一共存了多少个结果
char ** result;
int index = 0;

// @Param digits:输入的数字字符串
// @Param index:当前已经转换到第几个字符了
// @Param transferString:到当前的index为止的结果字符串
void letterCombinations(char * digits, int index,char *transferString){
	// 出口条件
	if(index >= strlen(digits)){
		// 复制字符串到结果数组中
		strcpy(result[index++],transferString);
		return;
	}

	//违法没有

	//分支,麻烦在这里
	if(digits[index] == '2'){
		// 递归,回溯我写在参数中,这样回来的时候就自己回溯了
		// 这里我就写成伪代码的形式了哈,你懂上意思就行了哈
		letterCombinations(digits,index+1,transferString+'a')
		letterCombinations(digits,index+1,transferString+'b')
		letterCombinations(digits,index+1,transferString+'c')
		/*
			上面这种回溯当然还可以写成:
			index++;
			transferString+='a';
			letterCombinations(digits,index,transferString)
			//回溯
			index--
			transferString-='a';

			//情况2
			index++;
			transferString+='b';
			letterCombinations(digits,index,transferString)
			//回溯
			index--
			transferString-='b';

  			//情况3
			index++;
			transferString+='c';
			letterCombinations(digits,index,transferString)
			//回溯
			index--
			transferString-='c';

		*/
	}else if(digits[index] == '3'){
		// 递归,回溯我写在参数中,这样回来的时候就自己回溯了
		// 这里我就写成伪代码的形式了哈,你懂上意思就行了哈
		letterCombinations(digits,index+1,transferString+'d')
		letterCombinations(digits,index+1,transferString+'e')
		letterCombinations(digits,index+1,transferString+'f')
	}else
		...

}

你来尝试补充完整代码!!!!

 

例题2.4

给定一个字符串数组 arr,字符串 s 是将 arr 某一子序列字符串连接所得的字符串,如果 s 中的每一个字符都只出现过一次,那么它就是一个可行解。

请返回所有可行解 s 中最长长度。

       不知道你看见这道题目的大概思路是怎么样的,反正我一看见就觉得应该是找出所有的组合的可能,然后记录最长的长度,ok我猜到了你的难点就是什么时候记录长队对吧!

解题分析:

1、出口

答:我们将单词都拼接在一起,一旦出现重复的单词那么就应该结束当前的遍历了!!!!!

2、违法判断

答:无

3、是否存在分支?

答:显然存在,其实就是第一题选数字那个,选了不同的词下一次必须选后面的吧!!!

这个代码就那种有很多分支,然后每个都选一次的情况,代码大体都如下:

int Max = 0;


// @Param str:字符串数组
// @Param length:字符串数组长度
// @Param index:当前选取到第几个字符串了
// @Param current:当前选取的字符
void find_max_length(char **str,int length,int index,char *current){
	// 出口
	// 自己实现一个函数,看一个字符串是否包含重复的字符(HashMap是不是可以用上了)
	if(findchar(current)){
		// 把上一个加入的去除
		int current_length = strlen(current)-strlen(str[index-1]);
		Max = current_length > Max ? current_length : Max;
	}

	// 没有违法判断

	//分支
	for(int i= index;i < length-1;i++){
		// 同样是参数回溯,这样就可以自动回溯
		find_max_length(str,length,i+1,current+str[i]);
	}
}

习题2.5

习题2.6、简单的递归

 

解析:简单的递归练习。

1、出口:

答:装不下任意一个货物了

2、违法:

答:无

3、分支:

答:选择每一个货物,实际上就是for循环

那么代码就很简单了。(注意剪枝的运用!!)

 

习题2.7、旅行家的预算

 

 

3、在二维矩阵中的递归与回溯

        其实我们在之前的题目中发现很多的递归和回溯的题目都是和二维数组有关,对的,对于二维数组其天然存在递归的结构,我们每走到一个位置的时候,面临的选择情况和之前是一样的。然后每次在每个位置都有前后左右四个位置可以给我们选择,这是就对应了前面的分支(出口)结束条件就是满足题意的情况违法判断就是是否超出边界,简直就是完美的匹配模板对吧,所以爱考这个。

例题3.1

现在假定有一个游戏,游戏地图是一个二维的数组(实际上游戏就是这么处理的),然后每个格子有一个数字,如果是负数就代表有一个怪物,负数就是消灭怪物需要消耗的血量,现在规定从地图的左上角出发(0,0)要到达右下角去营救公主(n-1,n-1),并且每次都只能朝着左边或者下边前进(因为他是勇士),那么请问你最少需要多少初始血才能营救到公主?(保证全部是负数)

样例1:

-1      -2     -3
-4      -5     -6
-22   -19    -9

输出:21 因为   -1------》-2-------》-3-------》-6--------》-9是一条消耗最少的路径

样例2、

-1

输出:1

样例3、

输出:74 因为 -1-------》-2---------》-3---------》-6--------》-9---------》-13---------》-11----------》-27--------》-2(如果我没找错这个应该是最小的)

 

这道题你来完成,我相信你肯定可以!!(注意可以利用前面讲解的剪枝提高搜索速度

 

例题3.1-1 变式练习

如果我们规定移动的方向可以是前后左右,不再是只能向着左边和下面运动,这道题又该怎么写?

解题提示:

如果是这样只需要避免出现圈的情况就好了,就比如说你不能:

遍历了:

(0,0) --- >(0,1) ----> (1,1) ----> (1,0) ---- > (0,0)

年轻人这样不好,不讲武德,计算机会一直循环,那么怎么解决呢?

答:用一个bool数组,将走过的位置全部记为true,每次到一个新位置的时候判断一下是否被走过了,走过了就直接返回!!

 

例题3.1-2 变式练习

如果我们在地图的某些地方放上了血包又会出现什么情况呢?比如我用一个整数代表走到这个格子可以增加的血量。(给你一个提示啊,这个坑的地方在于如下的情况:

有人会做题选出下面这个路径:

-1 -----》 -4 -----》 -99 -----》 300 ----》 -6 ------》 -23  -----》 -11 -----》-27 -----》 -2

因为这个算下来结果是127,还是个正数,最开始直接不需要血就可以了,但是真的是这样的吗??

答案肯定不是的呀!!你在捡300点血的血包之前必须是需要血量才能到达那个位置的,实际上在到达那个位置的时候你是付出了惨痛的代价的,那么如果按照上面这条路走实际上你应该有初始血量=1+4+99 = 104点血才行,还不如不捡!!

请尝试完成!!!

 

 

例题3.2、A*遍历算法

我们在玩游戏的时候,主角都有自动寻路的功能,那么这个是怎么实现的呢?还有在我们看见的无人驾驶汽车,自动寻路避障都是怎么实现的呢?没错这就是这道题目的猪脚,叫做A*算法(非常的出名),本题目我们一起来模拟实现A*算法。我们还是将我们生活的平面看成二维数组,如下:

图说明:两个红色点代表其实位置和结束位置(行,列)代表位置,白色代表空白地区,橘色代表的是障碍物,不能穿过。现在我问从源头节点到目标节点的最短距离是多少?

说明输入:

N:代表地图大小

接下来一行输入

x1 y1 x2 y2

分别代表源头和结束节点的位置(用数组的下标,不是真正意义上的坐标轴那种计数)

接下来一个k代表障碍物的个数

接下来k行,每行输入x1 y1 x2 y2代表障碍物矩形的左上角点坐标和右下角点坐标。

输出:一个整数代表最短距离

样例1、如图(自己弄啊,可以弄小一点)

 

解题思路:

1、出口

答:找到结束节点

2、违法

答:边界和障碍物

3、分支选择?

答:四个方向!

上面的三个步骤你看似没用,但是你在做题目的时候按照这个流程思考是很能帮助你写出程序的。

// 记录最小距离的
int MinDis = 99999999;
// 用来记录当前的格子是否被走过了!!!这个很重要
bool **flag;

// @Param map:代表地图的二维数组
// @Param n:代表地图的大小
// @Param obstacle:障碍物
// @Param k:障碍物的个数
// @Param current_x,current_y:当前节点在数组中的下标
// @Param target_x,target_y:目标节点在数组中的下标
// @param currentDis:当前路径的距离
void shortest(int **map,int n,int **obstacle,int k,
			int current_x,int current_y,
			int target_x,int target_y,int currentDis){
	
	// 出口
	if(current_x == target_x && current_y == target_y)
		MinDis = MinDis > currentDis?currentDis:MinDis;
	
	// 违法,这个函数自己去实现,随便怎么实现都行,不一定要按照我的写法
	if(!valid(current_x,current_y,n,int **obstacle,int k)) return;

	// 逻辑
	// 记录当前这一个代价
	// currentDis += map[current_x][current_y];
	// 因为需要回溯,所以直接加在参数里面最好了,函数执行完毕回来的时候就自己
	// 回溯了
	// up
	shortest(map,n,obstacle,k,current_x-1,current_y,target_x,target_y,
		currentDis+map[current_x][current_y]);
	// down
	shortest(map,n,obstacle,k,current_x+1,current_y,target_x,target_y,
		currentDis+map[current_x][current_y]);
	// left
	...
	//right
	...
}

 

例题3.2-1 :A*算法的实现,上面的算法并不叫A*,上面的就是最简单的暴力递归,那么A*是这样的:

因为我们发现在查找的时候有的地方是不可能的,其方向和我们要查找的节点直接是相反的,那么我们可以利用上这一点:

cost = pre + future

其中的pre代表我们从源节点到目前的节点的花费,future代表从当前节点到目标结点的花费,你肯定会问我怎么知道到目标节点的代价,确实我们无法对未来做出精确的预测,但是我们可以粗略的估计一下,我们可以计算目标节点和当前节点的曼哈顿距离,然后选择曼哈顿距离小(我们认为这个方向更接近目标方向)的分支优先扩展。

请通过上述提供的思路实现A*算法。

 

习题3.3

 

习题3.4

上面的题目实际上个和之前的题目都是类似的,就是多个了违法区域而已,单独开辟一个函数就行!!

 

习题3-4-变式1:

如果我们题目中的要求是,每一次可以朝着4个方向前进,那么又该怎么办??

 

习题3-5:

皇后彼此不能相互攻击是指:任何两个皇后都不能处于同一条横行、纵行或斜线上。

输入任意一个整数N,求一共有多少种放置皇后的解法?

题目解析

实际上很简单别被题目吓到了,就是个简单的回溯问题

出口:

答:皇后放置完毕

违法:

答:皇后不能同行或者同列、同行、一条斜线上(难点在于如何判断斜线)

分支:

答:整个棋盘

那么实际上程序就比较明显了:

bool valid(int **chessBoard)
    // 判断当前的棋盘是否合法!!我们在每次放置的
    // 时候不用讨论啥情况下放置是合法的,我们只管
    // 放置,然后再下一层的递归调用一下这个函数判断
    // 当前的局面是否是合法的就行了



int count = 0;

// @Param chessBoard:棋盘,我们可以用0表示空的格子,1表示存放的
// 皇后,一般都是这么操作的
// @Param row:本次放置的行
// @Param col:本次放置的列
// @Param n:当前还有几个皇后没有放置
void functionNQueen(int *chessBoard,int row,int col,int n){
    //出口
    if(n == 0){
        count++;
        return;
    }
    //违法,注意这个违法不仅有皇后的放置还有边界的检查!!
    if(!valid(chessBoard) || row < 0 ||
       col < 0 || row >= n || col >= n) return;

    // 正常逻辑,皇后的放置
    chessBoard[row][col] = 1;
    
    //分支:棋盘的任何位置都有可能放置皇后
    for(int i = 0;i < n;i++){
        for(int j = 0;j < n;j++)
            functionNQueen(chessBoard,i,j,n-1)
    }

    // 回溯!
    chessBoard[row][col] = 0;
}    

TIPS1:

      上面的回溯其实和之前的稍微有点不一样,不知道你能不能发现???麻烦思考了和我交流

TIPS2:

      上面的递归太糟糕了,双重循环里面套递归,时间复杂度是难以接受的,还记得吃鱼那个题目吗?计算机其实对这种暴力的递归穷举所有可能的解法非常反感的,不然我们的象棋围棋这些直接用穷举就好了,干嘛费那么大劲去弄alphago!这里是可以改进的?想象办法?怎么剪枝?麻烦思考了和我交流

 

习题3.6,最长的滑雪赛道

 

 

 

4:排列、子集、所有组合

 

习题4.1

提示:本题有两种解法,但是我们就研究其中一种,以此体会模板的好处:

首先我们解题思路很明显弄一个备选的字母库,然后从里面每次选取一个字母就行了

1、出口:

答:组合出的新字符串长度等于原来的字符串长度了

2、违法:

答:无

3、分支:

答:肯定存在,备选的字母库就是

那么我们来写程序:

//字母库可以用HashMap来做
int HashMap[26]

// @Param current:当前组装的字符串
// @Param length:需要重新排列的原始字符串的长度
void qpl(char *current,int length){

    // 这个预备工作可以放在主函数完成!!
    // builHashMap();
    出口条件
    if(strlen(current) == length){
        printf("%s\n",current);
        return;
    }
    
    // 分支
    for(int i = 0;i < 26;i++){
        // 说明可以选择这个备选的字母,选择了就要减少,等回来
        // 的时候再回溯
        if(HashMap[i] != 0)
            HashMap[i]--;
        else continue;
        qpl(current+(i+'a'),length);
        // 别忘记回溯了
        HashMap[i]++;
    }
    
}

 

习题4-1 变式练习

从键盘输入一个整数,请输出整数的每个位数上的数字重新排列组合的所有可能!

 

习题4.2、子集

解析:看着题目感觉很难实际上别被吓着了,思路很简单就是个回溯。反正我看见题目第一思路就是每次选取一个数就输出一次就好了。

出口:

答:子集最大的就是本身,那么很好控制,利用长度就行了,如果目前的子集长度等于原来集合的长度就结束了

违法:

答:无

分支:

答:每次挑选一个数据,实际上就是一个for循环


int *number;
int length;


// @Param current:当前的子集
// @Param current_length:当前的子集长度
// @Param index:当前该找集合中第几个下标的数了 
void function(int *current,int current_length,int index){

    // 出口    
    if(currentV_length == length) return;
    
    // 分支
    for(int i = index;i < length;i++){
        // 每次新加入一个元素就可以输出了
        // 注意这个新元素就从number中获取就行了
        current[current_length++] = number[index];
        // 输出current
        printf("....");
        // 递归
        function(current,current_length,index+1);
        // 回溯
        current_length--;
    }
}

 

 

5、变换问题

 这类问题其实就是穷举,但是怎么穷举是门学问,因为如果你没明白上题目,你会感觉这个穷举是没有尽头的,举个栗子:

我给定字符串A和字符串B,然后规定几个操作,我问字符串A是否能变成字符串B?

上面的问题你递归给我看,出口是啥呢???

        对于这类型的题目你一定要去题目找一些隐含的出口条件,或者题目给出的字符串间的规律,也就是如果字符串A出现了什么状态他两一定是无法完成转换的,这个时候就可以认为这是出口了。

例题5.1、

解析:这道题目的出口条件不太好找,如果觉得就是判断当前数组是否是升序就行了,那你就太天真了,这样貌似是不行的。其实我们可以通过冒泡排序或者一些常识性的知识获知:要让N个数据变成升序或者降序的,那么我们最多只需要比较N^2次就好了,也就是说我们可以设置一个阈值,如果比较次数超过阈值就是出口了。这是前面提到过的一种基本的剪枝手法。

1、出口:

升序或者超过阈值了

2、违法:

3、分支:

挨个交换相邻的数据

不知道你发现没有递归的程序都是上面几步,都很好写。。。

// 判断是否存在降序的数据的函数
// @Param number:需要判断是否存在降序的数据的数组
// @Param length:数据的长度
bool DesOrder(int *number,int length)


// 记录交换的次数
int swapMinTimes = 9999999;

// 这个非常的重要,因为光靠判断是否是升序数组其实是出不来的
// 因为有可能两个数刚交换下一次递归这两个数又被交换回去了,
// 如此反复横跳,因为有必要设置一个阈值,如果交换次数比阈值还
// 大,那么就说明不需要交换了,一定不行。这个值也可以就用记录
// 交换次数的变量替换
// 这个初始值其实很好找,N^2
int vavel;

// @Param number:需要判断是否存在降序的数据的数组
// @Param length:数据的长度
// @Param current_times:数据当前需已经交换的次数
// @Param index:当前需要交换的数的下标
void function(int *number,int length,int current_times,int index){
    // 出口
    if(!DesOrder(number),length || current_times > vavel)  return;

    // 剪枝加速,已经比存在的最小次数大了,没必要再继续下去了
    if(current_times > swapMinTimes)  return;

    // 分支
    for(int j = index+1; j < length;j++){
        交换number[i]和number[j];
        function(number,length,current_times+1,j);
        回溯(交换回来就行了)
    }
    
}

 

 

 

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页