day27|LeetCode:● 39. 组合总和● 40.组合总和II● 131.分割回文串

题目链接:39. 组合总和

1.思路

选择可以等于target的几个组合,可以重复选

本题是 集合里元素可以用无数次,那么和组合问题的差别 其实仅在于 startIndex上的控制

2.回溯法

class Solution {
public:
vector<vector<int>>result;
vector<int>path;
void backtracking(vector<int>& candidates, int target, int sum, int startindex) {
    if (sum == target) {
       result.push_back(path);
       return;
    }
    for (int i = startindex; i < candidates.size() && candidates[i] + sum <= target; i++) {
        path.push_back(candidates[i]);
        sum += candidates[i];
        backtracking(candidates, target, sum, i);
        sum -= candidates[i];
        path.pop_back();
    }
} 
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

 3.回溯三部曲

1.确定递归函数参数

这里除了需要题目给的那些参数外,因为需要求和(边遍历边求),所以需要一个num参数(sum),因为下次递归不能重复遍历上次遍历的元素,就需要一个startindex来确定每层遍历的起始位置

因为可以重复选择,所以startindex不需要加1,从当前i进行递归

2.确定终止条件

当sum > target说明不符合,提前结束,但是 可以剪枝,我们发现sum == target就加入结果集中,返回到回溯函数

3.确定单层搜索的逻辑

每次递归一次就加入当前层的值,树枝搜索,当满了后就加入结果集中,返回回溯函数,到上一层for循环的下一层,进行树层搜索

4.注意点

树枝搜索和树层搜索的遍历时间和顺序不相同

1.树枝搜索是一层一层的搜索,一般都是靠着递归函数backtrackin来实现的。 每次递归一次加一个数

2.树层搜索一般是回溯来主导的,每次回溯都到下一层for循环,加入树这一行的下一个

5.剪枝

剪枝一般在终止条件和for循环中,根据函数参数进行推导

当对目标数组进行完排序后,当sum>target时return,但是会回溯而去遍历这一层的for循环的下一层,但是这一层是排序过的,后面必定更大,所以不需要再遍历后面了,提前结束这层for循环到上一层的for循环再加

  for (int i = startindex; i < candidates.size() && candidates[i] + sum <= target; i++) {

40. 组合总和 II

1.思路

注意题目中给我们 集合是有重复元素的,那么求出来的 组合有可能重复,但题目要求不能有重复组合。

因为需要不同组合,但是可以有组合中可以有相同元素,所以这里需要用到去重避免选到相同组合

2.回溯法+剪枝

class Solution {
public:
vector<int>path;
vector<vector<int>>result;

void backtracking(vector<int>& candidates, int target, int startindex, vector<int>& used, int num) {
    if (num == target) {
        result.push_back(path);
        return;
    }
    for (int i = startindex; i < candidates.size() && num + candidates[i] <= target; i++) {
        if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == 0) {
            continue;
        }
        used[i] = 1;
        path.push_back(candidates[i]);
        num += candidates[i];
        backtracking(candidates, target, i + 1, used, num);
        num -= candidates[i];
        path.pop_back();
        used[i] = 0;
    }
}
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<int>used(candidates.size(), 0);
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, used, 0);
        return result;
    }
};

3.递归三部曲

1.确定递归函数参数

除了题目给的参数外,还需要sum统计现在path中加起来的数,因为避免重复,防止访问以前的数据,就需要有一个startindex,因为这个可以有重复元素,但是不能有重复组合,我们就需要一个判断重复元素的used;

used作用:

在排序完后的数组中如果当前元素后上一个元素相同,就需要判断是否处于树枝搜索状态,还是处于树层搜索状态,当处于树枝搜索,可以有重复元素,即使被用过了还可以用,如果是树层元素,如果和上一层相同就会在后面遍历相同的数据,就需要continue掉。

2.确定终止条件

当遇到sum==taregt就结束了,也开头剪枝

3.确定单层搜索的逻辑

排序后树层遍历(靠递归函数),这里需要判断能不能加入这个数进入path中,也是为了去重,当现在的这个元素与上一个元素相同时,如果是树枝搜索遍历过还可以遍历,所以就能加入,但树层遍历时,因为弹出了以前的used,所以现在又变成0了,这里比较后就不能加

  • used[i - 1] == true,说明同一树枝candidates[i - 1]使用过
  • used[i - 1] == false,说明同一树层candidates[i - 1]使用过

4.注意

选择加不加到path数组中在for循环下面就需要判断,加入result就需要在终止条件中判断。


题目链接:131. 分割回文串

1.思路

就是判断一下字符串是否回文串,是回文串就加入到path数组中,直到遍历到s的最后结束

例如对于字符串abcdef:

  • 组合问题:选取一个a之后,在bcdef中再去选取第二个,选取b之后在cdef中再选取第三个.....。
  • 切割问题:切割一个a之后,在bcdef中再去切割第二段,切割b之后在cdef中再切割第三段.....。

切割其实就是当前for循环的startindex和i的切割

2.回溯法

class Solution {
public:
vector<string>path;
vector<vector<string>>result;
bool isPalindrome(string& s, int m, int n) {
   for (int i = m,j = n;i < j; i++,j--) {
       if (s[i] != s[j]) return false;
   }
   return true;
}
void backtracking(string& s, int startindex) {
    if (startindex >= s.size()) {
        result.push_back(path);
        return;
    }

    for(int i = startindex; i < s.size(); i++) {
        if (isPalindrome(s, startindex, i)) {
            path.push_back(s.substr(startindex, i - startindex + 1));
        } else {
            continue;
        }
        backtracking(s, i + 1);
        path.pop_back();
    }
}
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
};

3.回溯三部曲

1.确定递归函数参数

除了题目给出的参数,还需要一个startindex,确定当前切割块的起始位置,同时为了切割以前的

2.确定终止条件

当所有切割情况都遍历完了就可以结束了。就是当前下标出去了(因为从0开始,就需要有=号)

3.确定单层递归函数

那么在代码里什么是切割线呢?

在处理组合问题的时候,递归参数需要传入startIndex,表示下一轮递归遍历的起始位置,这个startIndex就是切割线。

所以终止条件代码如下:

void backtracking (const string& s, int startIndex) {
    // 如果起始位置已经大于s的大小,说明已经找到了一组分割方案了
    if (startIndex >= s.size()) {
        result.push_back(path);
        return;
    }
}

如果这一层切割的字符串是回文子串就加入到path中,不然就进行树层遍历到for循环的下一层,更改切割点。是就加入到path中,进行树枝遍历下一层。再判断,当startindex出去后就返回到回溯函数进行回溯,到下一树层。判断再加

其实就是把这一层的startindex当作成左边界,层序遍历后的i是右边界,就是现在变成了加入 的元素变成了右边界,startindex变成了左边界

 

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值