什么是回溯
回溯是一种暴力搜索的算法，回溯算法通过循环控制树的宽度，递归调用控制树的深度，来收集满足条件的集合。
回溯算法能解决什么问题
1.排列组合
2.组合总和
3.分割字串
4.子集
回溯算法经典OJ
1.排列组合问题
组合问题的分析：组合及每层选的值以及该值的左边所有值下一层则不能在被选择，为了控制选值，则需要startIndex来索引下标，并根据条件收集和返回结果。
排列问题的分析：排列问题每层都可以取除了上一层选择的值之外的所有值，所以一般不需要startIndex控制索引，而需要hash表记住上一层所选择的值。
剪枝：剪枝操作要根据题目的收集结果条件进行剪枝，一般都在for循环的判断部分进行剪枝。
组合
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。
问题分析：该题要求返回组合，则需要startIndex控制索引防止重复选取，同时返回条件是当收集到2个结果返回。
int* result;// - 结果数组
int arrTop;// - 控制返回数组的下标
int top;// - 控制结果数组的下标
int** arr;// - 结果数组
void BackTracking(int n, int k, int** arr, int index)
{
if(top == k)// - 满足条件返回
{
int* tmp = (int*)malloc(sizeof(int)*k);
for(int i = 0; i < k; i++)
{
tmp[i] = result[i];
}
arr[arrTop++] = tmp;
return;
}
for(int i = index; i <= n; i++)
{
result[top++] = i;
BackTracking(n,k,arr,i+1);
// - 回溯
top--;
}
}
int** combine(int n, int k, int* returnSize, int** returnColumnSizes)
{
arr = (int**)malloc(sizeof(int*)*10000);
result = (int*)malloc(sizeof(int)*k);
arrTop = top = 0;
BackTracking(n,k,arr,1);
*returnSize = arrTop;// - 返回arr数组有多少行
*returnColumnSizes = (int*)malloc(sizeof(int)*(*returnSize));// - 返回arr数组每列有多少个元素。
for(int i = 0; i < *returnSize; i++)
{
(*returnColumnSizes)[i] = k;
}
return arr;
}
剪枝：本题要求收集到k个值就返回，若接下来收集的元素最大值都收集不到k个，则就不用遍历了。
result数组中有Top个元素，所需需要的元素个数为: k - Top;
列表中剩余元素（n-i） >= 所需需要的元素个数（k - Top)
在集合n中至多要从该起始位置 : i <= n - (k - Top) + 1，开始遍历
for(int i = index; i <= n - (k-Top)+1; i++)
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
问题分析：不含重复数子，则代表不存在两个结果相同，但是所对应的下标不同，则不需要在每层去重，要返回全排列，返回条件就是rTop的值是numsSize，并且该问题为排列问题，可以重选。
int* path;
int pathTop;
int** ans;
int ansTop;
//将used中元素都设置为0
void initialize(int* used, int usedLength) {
int i;
for(i = 0; i < usedLength; i++) {
used[i] = 0;
}
}
//将path中元素拷贝到ans中
void copy() {
int* tempPath = (int*)malloc(sizeof(int) * pathTop);
int i;
for(i = 0; i < pathTop; i++) {
tempPath[i] = path[i];
}
ans[ansTop++] = tempPath;
}
void backTracking(int* nums, int numsSize, int* used)
{
//若path中元素个数等于nums元素个数，将nums放入ans中
if(pathTop == numsSize) {
copy();
return;
}
int i;
for(i = 0; i < numsSize; i++) {
//若当前下标中元素已使用过，则跳过当前元素
if(used[i])
continue;
used[i] = 1;
path[pathTop++] = nums[i];
backTracking(nums, numsSize, used);
//回溯
pathTop--;
used[i] = 0;
}
}
int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes){
//初始化辅助变量
path = (int*)malloc(sizeof(int) * numsSize);
ans = (int**)malloc(sizeof(int*) * 1000);
int* used = (int*)malloc(sizeof(int) * numsSize);
//将used数组中元素都置0
initialize(used, numsSize);
ansTop = pathTop = 0;
backTracking(nums, numsSize, used);
//设置path和ans数组的长度
*returnSize = ansTop;
*returnColumnSizes = (int*)malloc(sizeof(int) * ansTop);
int i;
for(i = 0; i < ansTop; i++) {
(*returnColumnSizes)[i] = numsSize;
}
return ans;
}
2.组合总和问题
组合总和问题的分析：组合及每层选的值以及该值的左边所有值下一层则不能在被选择，为了控制选值，则需要startIndex来索引下标，并根据条件收集和返回结果。
剪枝：剪枝操作要根据题目的收集结果条件进行剪枝，组合总和问题一般通过排序+和下一层的元素相加来剪枝，一般都在for循环的判断部分进行剪枝。
组合总和 III
找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：
- 只使用数字1到9
- 每个数字 最多使用一次
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
问题分析：该问题为组合问题，数字为1-9，则代表数字有序，要收集相加和为n的k个整数集合，则不满足这个条件直接返回。
int* result;
int rTop;
int aTop;
void BackTracking(int k, int n, int startIndex, int sum, int** arr)
{
// - 剪枝
if(rTop == k)
{
if(sum == n) {
int* tempPath = (int*)malloc(sizeof(int) * k);
int j;
for(j = 0; j < k; j++)
tempPath[j] = result[j];
arr[aTop++] = tempPath;
}
return;
}
// - 剪枝
else if(rTop != k && sum >= n)
{
return;
}
for(int j = startIndex; j <=9; j++)
{
sum+=j;
result[rTop++] = j;
BackTracking(k,n,j+1,sum,arr);
rTop--;
// - 组合总和问题要注意每层回溯要-=结果数组内容。
sum-=j;
}
}
int** combinationSum3(int k, int n, int* returnSize, int** returnColumnSizes)
{
int** arr = (int**)malloc(sizeof(int*)*1000);
//初始化辅助变量
result = (int*)malloc(sizeof(int) * k);
rTop = aTop = 0;
BackTracking(k, n, 1, 0,arr);
//设置返回的二维数组中元素个数为ansTop
*returnSize = aTop;
//设置二维数组中每个元素个数的大小为k
*returnColumnSizes = (int*)malloc(sizeof(int) * aTop);
int i;
for(i = 0; i < aTop; i++) {
(*returnColumnSizes)[i] = k;
}
return arr;
}
剪枝：该题依旧对数量有限制，则可以用组合问题的剪纸方法进行剪枝
for(int i = index; i <= 9 - (k-Top)+1; i++)
组合总和
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于 150 个。
问题分析：该问题为组合问题，同一个数子课重复使用，找出和为target的值。
int** arr;
int* result;
int rTop;
int aTop;
int* length;
void BackTracking(int sum, int target, int* candidates, int n, int startIndex)
{
// - sum > target返回
if(sum > target)
return;
// - 等于target收集数据
if(sum == target)
{
int* tmp = (int*)malloc(sizeof(int)*rTop);
for(int i = 0; i < rTop; i++)
{
tmp[i] = result[i];
}
arr[aTop] = tmp;
length[aTop++] = rTop;
return;
}
// - 改题目需要的是组合，所以不用遍历遍历过的
for(int j = startIndex; j < n; j++)
{
sum+=candidates[j];
result[rTop++] = candidates[j];
BackTracking(sum,target,candidates,n,j);
rTop--;
// - sum 要-;
sum-=candidates[j];
}
}
int** combinationSum(int* candidates, int candidatesSize, int target, int* returnSize, int** returnColumnSizes)
{
length = (int*)malloc(sizeof(int)*200);
arr = (int**)malloc(sizeof(int*)*1000);
result = (int*)malloc(sizeof(int)*100);
rTop = aTop = 0;
int sum = 0;
BackTracking(sum, target,candidates,candidatesSize,0);
*returnSize = aTop;
*returnColumnSizes = (int*)malloc(sizeof(int)*aTop);
int i;
for(i = 0; i < aTop; i++) {
(*returnColumnSizes)[i] = length[i];
}
return arr;
}
剪枝：只要某一层的和+下一层将要遍历的数大于target就不再进入循环。
for (int i = startIndex; i < n && sum + candidates[i] <= target; i++)
3.分割字串问题
分割字串问题的分析：**分割字串问题的本质在于选择分割位置，我们通过startIndex控制分割的起始位置，循环变量控制分割位置，分割过的位置不能在分割，会出现重复。
分割回文串
给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
问题分析：该问题为分割字串问题，同时收集结果的条件为全部回文，[startIndex,i]是一个分割区间，只要整个串被分割完，则代表可以收集结果了。
char*** arr;
char** result;
int aTop;
int rTop;
int* arrSize;
// - 判断回文
int checkStr(char* s, int start, int end)
{
while(start <= end)
{
if(s[start] == s[end])
{
start++;
end--;
}
else
{
return 0;
}
}
return 1;
}
char* curStr(char* s, int start, int end)
{
char* tmp = (char*)malloc(sizeof(char)*(end-start+2));
int index = 0;
for(int i = start; i <= end; i++)
{
tmp[index++] = s[i];
}
tmp[index] = '\0';
return tmp;
}
void copy()
{
char** tmp = (char**)malloc(sizeof(char*)*rTop);
for(int i = 0; i < rTop; i++)
{
tmp[i] = result[i];
}
arrSize[aTop] = rTop;
arr[aTop++] = tmp;
}
void BackTracking(char* s, int len, int startIndex)
{
// startIndex >= strlen的时候收集结果
if(startIndex >= len)
{
copy();
return ;
}
for(int j = startIndex; j < len; j++)
{
if(checkStr(s,startIndex,j))
{
result[rTop++] = curStr(s,startIndex,j);
}
// - 某层不回文，则++接着判断。
else
continue;
BackTracking(s,len,j+1);
rTop--;
}
}
char*** partition(char* s, int* returnSize, int** returnColumnSizes)
{
arrSize = (int*)malloc(sizeof(int)*40000);
arr = (char***)malloc(sizeof(char**)*40000);
int len = strlen(s);
// - result数组存储的是满足条件的组合，该组合不会超过len个
result = (char**)malloc(sizeof(char*)*len);
rTop = aTop = 0;
BackTracking(s,len,0);
*returnSize = aTop;
*returnColumnSizes = (int*)malloc(sizeof(int)*aTop);
for(int i = 0; i < aTop; i++)
{
(*returnColumnSizes)[i] = arrSize[i];
}
return arr;
}
复原IP地址
有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。
例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。
问题分析：本题目为分割字串问题，分割条件为加每个ip地址都是有效，且要加入点号。
char* result;
char** arr;
int rTop;
int aTop;
int isIPAdders(char* s, int start, int end)
{
if(start > end)
return 0;
if (s[start] == '0' && start != end) { // 0开头的数字不合法
return 0;
}
int num = 0;
for (int i = start; i <= end; i++) {
if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
return 0;
}
num = num * 10 + (s[i] - '0');
if (num > 255) { // 如果大于255了不合法
return 0;
}
}
return 1;
}
void CurStr(char* s, int start, int end)
{
for(int i = start; i <= end; i++)
{
result[rTop++] = s[i];
}
}
void BackTracking(char* s, int len, int startIndex, int pointSize)
{
if(pointSize == 3)
{
if(isIPAdders(s, startIndex, len-1))
{
char* tmp = (char*)malloc(sizeof(char)*(len+4));
CurStr(s, startIndex, len-1);
for(int i = 0; i <= rTop; i++)
{
tmp[i] = result[i];
}
tmp[rTop] = '\0';
arr[aTop++] = tmp;
// - 最后一次回退不能由循环完成，必须在这里完成，并且最后一个回退不用回退.号
rTop-=((len-1)-startIndex+1);
return;
}
return;
}
// - 每个合法地址从startIndex开始最多3个字符，剪枝。
for(int j = startIndex; j < 3+startIndex; j++)
{
if(isIPAdders(s,startIndex, j))
{
CurStr(s,startIndex,j);
result[rTop++] = '.';
pointSize++;
BackTracking(s,len,j+1,pointSize);
rTop-=(j-startIndex+2);
pointSize--;
}
// - 只要起始位置不是合法地址，则该串就无法分割出合法地址。
else
break;
}
}
// - 分割子串
char** restoreIpAddresses(char* s, int* returnSize)
{
int len = strlen(s);
if(len < 4 && len > 12)
return NULL;
arr = (char**)malloc(sizeof(char*)*10000);
result = (char*)malloc(sizeof(char)*(len+4));
rTop = aTop = 0;
BackTracking(s,len,0,0);
*returnSize = aTop;
return arr;
}
剪枝：每个分割项的数字个数是[1-3]，所以可以在for循环判断部分剪枝。
for(int j = startIndex; j < 3+startIndex; j++)
4.子集问题
子集问题的分析：子集问题的本质依旧是组合问题，不过收集条件为无，及收集所有结点，同时每次收集完不用返回。
子集
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
问题分析：本题为子集问题，则要收集所有结点。
int** arr;
int* result;
int* length;
int rTop;
int aTop;
void copy()
{
int* tmp = (int*)malloc(sizeof(int)*10);
for(int i = 0; i < rTop; i++)
{
tmp[i] = result[i];
}
length[aTop] = rTop;
arr[aTop++] = tmp;
}
// - 子集问题--收集所有回溯树的结点
void BackTracking(int* nums, int numsSize, int startIndex)
{
copy();
// - 没有元素可取，就返回。
if(startIndex >= numsSize)
return;
for(int i = startIndex; i < numsSize; i++)
{
result[rTop++] = nums[i];
BackTracking(nums,numsSize, i+1);
rTop--;
}
}
int** subsets(int* nums, int numsSize, int* returnSize, int** returnColumnSizes)
{
arr = (int**)malloc(sizeof(int*)*2000);
result = (int*)malloc(sizeof(int)*numsSize);
length = (int*)malloc(sizeof(int)*2000);
rTop = aTop = 0;
BackTracking(nums,numsSize,0);
*returnSize = aTop;
*returnColumnSizes = (int*)malloc(sizeof(int)*aTop);
for(int i = 0; i < aTop; i++)
{
(*returnColumnSizes)[i] = length[i];
}
return arr;
}
递增子序列
给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。
数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。
问题分析：存在重复元素，并且要求返回不同递增子序列，则不能通过排序去重，可以使用hash表，记录每次选择的元素，完成去重操作，去重的原因在于重复的元素存在重复收集结果的情况，同时改题目也需要我们遍历所有结点，收集结果的条件是result数字的元素大于1。
int** arr;
int* result;
int* length;
int rTop;
int aTop;
void copy()
{
int* tmp = (int*)malloc(sizeof(int)*rTop);
// for(int i = 0; i < rTop; i++)
// {
// tmp[i] = result[i];
// }
memcpy(tmp, result, rTop*sizeof(int));
length[aTop] = rTop;
arr[aTop++] = tmp;
}
find(int* hash, int size, int element)
{
int i;
for(i = 0; i < size; i++) {
if(hash[i] == element)
return 1;
}
return 0;
}
// - 去重 - 不能用排序进行去重，因为要求原数组的递增子序列 -- 哈希表
void BackTracking(int* nums, int numsSize, int startIndex)
{
if(rTop > 1)
copy();
// - 每层都生成一个哈希表，去重。
int* hash = (int*)malloc(numsSize*sizeof(int));
int hashTop = 0;
for(int i = startIndex; i < numsSize; i++)
{
// - 满足以下条件++，不收集结果。
if((rTop > 0 && nums[i] < result[rTop-1]) || find(hash, numsSize,nums[i]))
continue;
result[rTop++] = nums[i];
hash[hashTop++] = nums[i];
BackTracking(nums,numsSize, i+1);
rTop--;
}
}
int** findSubsequences(int* nums, int numsSize, int* returnSize, int** returnColumnSizes)
{
arr = (int**)malloc(sizeof(int*)*33000);
result = (int*)malloc(sizeof(int)*numsSize);
length = (int*)malloc(sizeof(int)*33000);
rTop = aTop = 0;
BackTracking(nums,numsSize,0);
*returnSize = aTop;
*returnColumnSizes = (int*)malloc(sizeof(int)*aTop);
for(int i = 0; i < aTop; i++)
{
(*returnColumnSizes)[i] = length[i];
}
return arr;
}
1158
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
