第七章回溯算法part03(● 39. 组合总和 ● 40.组合总和II ● 131.分割回文串)

G_qingxin

已于 2023-12-27 17:05:24 修改

阅读量395

点赞数 9

分类专栏：算法笔记文章标签：算法 javascript 数据结构

于 2023-12-27 15:30:31 首次发布

本文链接：https://blog.csdn.net/G_qingxin/article/details/135218534

版权

算法笔记专栏收录该内容

53 篇文章 0 订阅

订阅专栏

本文介绍了编程题目中的三个挑战：39.组合总和（允许重复元素）和40.组合总和II（每个元素仅使用一次），以及131.分割回文串，涉及递归、剪枝和数组去重的技巧。通过视频讲解详细解析了算法实现和解题思路。

摘要由CSDN通过智能技术生成

学习目标：

● 39. 组合总和
● 40.组合总和II
● 131.分割回文串

学习内容：● 39. 组合总和

题目链接/文章讲解：https://programmercarl.com/0039.%E7%BB%84%E5%90%88%E6%80%BB%E5%92%8C.html
视频讲解：https://www.bilibili.com/video/BV1KT4y1M7HJ

var combinationSum = function(candidates, target) {
    let result = [];
    let path = [];
    candidates.sort((a,b)=>a-b)// 排序//剪枝
    backtracking(candidates,target,0,0)
    return result
    function backtracking(candidates,target,sum,startIndex){
        if(sum>target){
            return
        }
        if(sum == target){
            result.push([...path])
            return
        }
        for(let i=startIndex;i<candidates.length;i++){
            if(candidates[i]>target-sum){
                break;
            }//剪枝
            path.push(candidates[i])
            sum+=candidates[i]
            backtracking(candidates,target,sum,i)
            path.pop()
            sum-=candidates[i]
        }
    }
};

学习内容：● 40.组合总和II

题目链接/文章讲解：https://programmercarl.com/0040.%E7%BB%84%E5%90%88%E6%80%BB%E5%92%8CII.html
视频讲解：https://www.bilibili.com/video/BV12V4y1V73A

这道题目和39.组合总和 (opens new window)如下区别：
1.本题candidates 中的每个数字在每个组合中只能使用一次。
2.本题数组candidates的元素是有重复的，而39.组合总和 (opens new window)是无重复元素的数组candidates
我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重。

used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
used[i - 1] == false，说明同一树层candidates[i - 1]使用过
let used = new Array(candidates.length).fill(false);

var combinationSum2 = function(candidates, target) {
    const result = []
    const path = []
    let used = new Array(candidates.length).fill(false);
    candidates.sort((a,b)=>a-b)
    backtracking(0,0,used)
    return result
    function backtracking(sum,startIndex,used){
        if(sum>target)return 
        if(sum == target){
            result.push([...path])
            return
        }
        for(let i=startIndex;i<candidates.length;i++){
            //树层去重(used[i-1]==1去重的是树枝)
            if(i>0&&candidates[i]==candidates[i-1]&&used[i-1]==0){
                continue
            }
            sum+=candidates[i]
            path.push(candidates[i])
            used[i]=true
            backtracking(sum,i+1,used)
            used[i]=false
            sum-=candidates[i]
            path.pop()
        }
    }
};

学习内容：● 131.分割回文串

https://programmercarl.com/0131.%E5%88%86%E5%89%B2%E5%9B%9E%E6%96%87%E4%B8%B2.html
视频讲解：https://www.bilibili.com/video/BV1c54y1e7k6

第一遍刷不太会

//双指针
var partition = function(s) {
    const isPalindrome= function(s,i,j){
        for(let x=i,y=j;x<y;x++,y--){
            if(s[x]!==s[y]){
                return false
            }
        }
        return true
    }
  const path = []
  const result = []
  const len = s.length
  backtracking(0)
  return result
  function backtracking(startIndex){
      if(startIndex>=len){
          result.push([...path])
          return
      }
      for(let i=startIndex;i<len;i++){
          if(isPalindrome(s,startIndex,i)){
              path.push(s.slice(startIndex,i+1))
          }else{
              continue
          }
          backtracking(i+1)
          path.pop()
      }
  }
};