递归回溯法
一、什么是回溯
回溯本质上属于深度优先搜索(DFS),运用到的思想是暴力枚举+剪枝
从字面意思也很好理解,他的步骤就是**<枚举所有的可能,边枚举边验证,无效则回退>**显然在一些需要穷举所有可能的题就能用上。其中我们一般会定义一个char* path或int* path作为一次路径探索的容器
即一次被探索(构建)完成(满足问题条件)的path代表一种完全可能(满足条件的一种可能的答案)
// 通用回溯模板(伪代码)voidbacktrack(路径,选择列表,结果集){if(触发限制条件)return;// 剪枝if(满足终止条件){// 一次完整解决了问题的情况把路径加入结果集;return;}for(每个可选的选择 in 选择列表){// 基准问题,每一步做选择(把选择加入路径);backtrack(路径,选择列表,结果集);// 递归撤销选择(把选择从路径中移除);// 回溯}}二、回溯的基本思路
回溯的模板通常大差不差,具体区别就是每一题的具体要求使得剪枝、穷举、组合的具体规则不尽相同,因此理解每一个板块的核心思路很重要
1.确定问题被解决的情况+确定基准问题
顾名思义,这一部分的思路目标就是:
1. 确定什么情况算完成了一种可能的答案(对应模板中第二个if情况和return)
2. 把整个问题拆分细解到最小最基层的每一步(对应模板中的for循环部分)
例题:给1到n的正整数,取其中k个进行组合,能有多少种不同的组合
基准:取1到n的其中一个数,加入path中
一次被解决的情况:path内已填入元素的个数刚好等于k个
例题:每个数字可以代表多个字母(如1可以是a、b或c),给出一串数字,其代表字母的所有可能
基准:针对一个数字,取这个数字可代表的所有字母中的一个,加入path中
一次被解决的情况:每个数字都取了一个对应字母加入了path,path内字母的个数等于数字串长度
2.确定底线/剪枝条件 or 限制探索步骤
这一步就是弄明白在path探索的过程中,当探索过并已加入了path的元素触犯了什么条件就会使这一次探索不再符合题目条件,从而需要剪枝return;或者在递归调用的时候让元素从新的start开始遍历,避免重复
例题:给数字n,生成n对“合法的”括号,有多少种可能的组合
底线约束方式1:当前已生成的右括号数大于左括号数(无法向左合法匹配)
底线约束方式2:已生成的左括号数或者右括号数超过了n(多于n对)
例题:例题:给1到n的正整数,取其中k个进行组合(!!不能重复取!!),能有多少种不同的组合
底线约束方式:递归调用时,让下一个数字的遍历探索从i+1开始(函数参数多一个start,start作为for循环i的起始)
也就是分成了两种类型的剪枝:
| 剪枝类型 | 作用 | 典型场景 | 示例条件 | 剪枝操作 |
|---|---|---|---|---|
| 合法性剪枝 | 终止「本身无效」的路径 | 括号生成、组合总和 | 括号生成:右括号数 > 左括号数;组合总和:sum > target | return; |
| 重复性剪枝 | 避免「重复生成」相同的路径 | 组合、子集、全排列 | 组合:for 循环从 start 开始;全排列:used 数组标记已选元素 | 传新参start |
其中传新参和return的操作都很明了易懂,下面详细讲一下用used数组标记已使用元素的做法
used数组的完整使用步骤
初始化
used数组在主函数中分配内存并初始化为 0(未选状态),长度等于数组长度:
int*used=(int*)calloc(numsSize,sizeof(int));// calloc 自动初始化为 0,等价于 malloc + memset遍历中判断
used状态(剪枝)在回溯的
for循环中,跳过已标记的元素:
for(inti=0;i<numsSize;i++){if(used[i]==1)continue;// 跳过已选元素(核心剪枝)// 选择元素 + 递归 + 回溯}选择元素时标记
used将当前元素加入路径后,标记
used[i] = 1:
used[i]=1;// 标记为已选path[path_idx]=nums[i];// 加入路径递归返回后撤销标记(回溯核心)
递归返回后,将
used[i]恢复为 0,让该元素可被后续路径选择:
backtrack(...);// 递归used[i]=0;// 撤销标记(回溯)三、解题过程中的一些坑难点
主要聚焦在由于组合问题带来的需要返回结果大小的要求(力扣)
/** * Return an array of arrays of size *returnSize. * The sizes of the arrays are returned as *returnColumnSizes array. * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free(). */int**xxxxxx(...,int*returnSize,int**returnColumnSizes){}| 参数名 | 类型 | 核心作用 |
|---|---|---|
int** 返回值 | 二维 int 数组 | 存储所有最终结果(如所有组合 / 排列 / 括号串) |
int* returnSize | 一级指针 | 输出参数:返回「结果集的行数」(即有多少个合法答案) |
int** returnColumnSizes | 二级指针 | 输出参数:返回「每行结果的列数」(即每个结果有多少个元素) |
必须先为returnColumnSizes分配「和结果集行数上限匹配」的内存:
//main内intmax_size=200000;// 结果集最大行数(根据题目预估)*returnColumnSizes=(int*)malloc(max_size*sizeof(int));// 分配一维数组//自定义递归函数内的已完成分支内(*returnColumnSizes)[*answer_idx]=k;//左式相当于(*returnColumnSizes)[*answer_idx][0]虽说是一个数组,但其实只要一个数memcpy(目标, 源, 元素个数 *sizeof(元素类型)):
memcpy(answer[*answer_idx],path,k*sizeof(int));//重点在要有sizeof类型// 字符串类(如括号生成):memcpy(ans[idx], path, len * sizeof(char));主函数末尾必须将「实际生成的结果数」赋值给*returnSize:
*returnSize=answer_idx;// answer_idx是回溯中统计的结果行数一般常规操作:
voidbacktravel(...,int**answer,int*answer_idx,int**returnColumnSizes,intpath_idx,int*path,intstart,...){if(完整条件){//完成(填满)answer[*answer_idx]=(int*)malloc(ok_size*sizeof(int));memcpy(answer[*answer_idx],path,ok_size*sizeof(int));(*returnColumnSizes)[*answer_idx]=ok_size;//这个ok_size看题目来变动,一般是等于path_idx(*answer_idx)++;return;//不要忘了这个!!!}for(inti=start;i<=n;i++){//基准的每一步path[path_idx]=i;backtravel(...,answer,answer_idx,returnColumnSizes,path_idx+1,path,i+1,...);}}main(){int**answer=(int**)malloc(max_size*sizeof(int*));//max_size根据题意调整int*path=(int*)calloc(max_size,sizeof(int));*returnColumnSizes=(int*)malloc(max_size*sizeof(int));intanswer_idx=0;backtravel(...,&answer_idx,...);free(path);*returnSize=answer_idx;returnanswer;}四、例题
题解:
这题只需穷举,还不存在明显的剪枝constchar*numtoword[]={//定义数字对应字母集"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz",};//确定基准:每一个数字的所有可能//for遍历解决每个数字的所有可能,递归解决这个数字紧接着的下一个数字的所有可能//path是一个字符串,代表一种完全可能(每个数字都已对应着某一种字母的排列)voidbacktrap(char*digits,char**answer,int*answer_idx,char*path,intpath_idx){if(digits[path_idx]=='\0'){//这条路已经探索完整answer[*answer_idx]=(char*)malloc((strlen(path)+1)*sizeof(char));strcpy(answer[*answer_idx],path);(*answer_idx)++;//作用于全体,因为是下一条路了return;}//对于当前数字,for遍历当前数字的所有可能intnum=digits[path_idx]-'0';intpossible_len=strlen(numtoword[num]);//这个数字对应的字母集的长度就是他所有可能的个数for(inti=0;i<possible_len;i++){//基准的最小步path[path_idx]=numtoword[num][i];backtrap(digits,answer,answer_idx,path,path_idx+1);//对于这个数字的这个字母,他的下一个数字对应的字母又有许多可能}}char**letterCombinations(char*digits,int*returnSize){intdigits_len=strlen(digits);intpossible_path_count=0;int*pb_pac=&possible_path_count;intanswer_max_size=1;//最大的 可能的“组合” 的 个数for(inti=0;i<digits_len;i++){intnum=digits[i]-'0';answer_max_size*=strlen(numtoword[num]);}char**answer=(char**)malloc(answer_max_size*sizeof(char*));char*path=(char*)malloc((digits_len+1)*sizeof(char));//每条路即每个组合的字母数显然等于数字个数,加一个给\0path[digits_len]='\0';backtrap(digits,answer,pb_pac,path,0);//从第一个数字开始*returnSize=possible_path_count;free(path);returnanswer;}题解:
本题出现了剪枝voidbacktrap(char**answer,char*path,intpath_idx,int*answer_idx,inttotaltimes,intlessleft,intlessright){if(lessleft<0||lessright<0||lessright<lessleft)return;//剪枝if(path_idx==totaltimes&&lessleft==0&&lessright==0){//完成一条路answer[*answer_idx]=(char*)malloc((totaltimes+1)*sizeof(char));strcpy(answer[*answer_idx],path);(*answer_idx)++;return;}if(lessleft>0){path[path_idx]='(';backtrap(answer,path,path_idx+1,answer_idx,totaltimes,lessleft-1,lessright);path[path_idx]='\0';}if(lessright>0&&path_idx!=0){path[path_idx]=')';backtrap(answer,path,path_idx+1,answer_idx,totaltimes,lessleft,lessright-1);path[path_idx]='\0';}}char**generateParenthesis(intn,int*returnSize){inttotaltimes=n*2;intmax_size=2000;char**answer=(char**)malloc(max_size*sizeof(char*));char*path=(char*)calloc(totaltimes+1,sizeof(char));intpath_idx=0,answer_idx=0;int*ans_idx=&answer_idx;backtrap(answer,path,0,ans_idx,totaltimes,n,n);*returnSize=answer_idx;free(path);returnanswer;}题解:
本题用到了used数组避免重复元素voidback(int*nums,intnumsSize,int*used,int*path,int**answer,int*answer_idx,intpath_idx,int**returnColumnSizes){if(path_idx==numsSize){answer[*answer_idx]=(int*)malloc(numsSize*sizeof(int));memcpy(answer[*answer_idx],path,numsSize*sizeof(int));(*returnColumnSizes)[*answer_idx]=numsSize;(*answer_idx)++;return;}for(inti=0;i<numsSize;i++){if(used[i]==1)continue;used[i]=1;path[path_idx]=nums[i];back(nums,numsSize,used,path,answer,answer_idx,path_idx+1,returnColumnSizes);used[i]=0;}}int**permute(int*nums,intnumsSize,int*returnSize,int**returnColumnSizes){int**answer=(int**)malloc(1000*sizeof(int*));int*path=(int*)malloc(numsSize*sizeof(int));*returnColumnSizes=(int*)malloc(1000*sizeof(int));int*used=(int*)calloc(numsSize,sizeof(int));intanswer_idx=0;back(nums,numsSize,used,path,answer,&answer_idx,0,returnColumnSizes);*returnSize=answer_idx;returnanswer;}题解:
本题用到了传新参start避免结果的重复(如[2,2,3]和[2,3,2])voidbacktravel(int*candidates,intcandidatesSize,inttarget,int**returnColumnSizes,int*path,int**answer,int*answer_idx,intpath_idx,intsum,intstart){if(sum>target)return;//剪枝if(sum==target){//完成一条路answer[*answer_idx]=(int*)malloc(path_idx*sizeof(int));memcpy(answer[*answer_idx],path,path_idx*sizeof(int));(*returnColumnSizes)[*answer_idx]=path_idx;(*answer_idx)++;return;}for(inti=start;i<candidatesSize;i++){intnum=candidates[i];path[path_idx]=num;backtravel(candidates,candidatesSize,target,returnColumnSizes,path,answer,answer_idx,path_idx+1,sum+num,i);}}int**combinationSum(int*candidates,intcandidatesSize,inttarget,int*returnSize,int**returnColumnSizes){int**answer=(int**)malloc(150*sizeof(int*));int*path=(int*)calloc(100,sizeof(int));*returnColumnSizes=(int*)malloc(150*sizeof(int));intanswer_idx=0;backtravel(candidates,candidatesSize,target,returnColumnSizes,path,answer,&answer_idx,0,0,0);*returnSize=answer_idx;free(path);returnanswer;}