【Javascript】回溯算法--组合和排列问题

回溯算法

基本介绍

回溯是一种通过探索所有可能的候选解来找出所有的解的算法。如果候选解被确认不是一个解（或者至少不是最后一个解），回溯算法会通过在上一步进行一些变化抛弃该解，即回溯并且再次尝试。

回溯是递归的副产品，只要有递归就会有回溯。回溯常用来解决的问题：排列组合问题、子集问题、数独、N皇后问题等等。

回溯法解决的问题都可抽象为树形结构。因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。

回溯题解决套路

遇到回溯问题可以这样去思考：

• 回溯函数模板返回值以及参数

返回值一般为空

参数一般不太好确定，需要先写逻辑，然后看需要什么参数

• 回溯函数终止条件

因为可以抽象成树的结构，所以遍历到叶子节点，就可以结束本层回溯递归

• 回溯搜索的遍历过程

回溯一般是纵向遍历，这样就可以把这棵树全部遍历完

回溯算法的JS模板

let res = [], path = [];
function backtracking(n, k, startIndex){
        if(终止条件){
            存放结果;//res.push([...path]);
            return;
        }
        for(注意，树中节点孩子的数量就是集合的大小){
            处理节点；//path.push(xxx);
            backtracking();//递归
            回溯//path.pop();
        }

    }

回溯法抽象为树形结构后，其遍历过程就是：for循环横向遍历，递归纵向遍历，回溯不断调整结果集。

leetcode题目

组合问题

题目链接

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

剪枝优化：

举例：如果n=4,k=4，那么从元素2开始的遍历都没有意义。所以在每层遍历时可以进行剪枝操作。还需要添加的元素个数是k-path.length，因此最多从index为n - (k - path.length) + 1处开始遍历，剩余的元素才够添加。

代码实现：

var combine = function(n, k) {
    let res = [];
    let path = [];
    function backtracking(n, k, startIndex){
        if(path.length == k){
            res.push([...path]);
            return;
        }
        //i <= n - (k - path.length) + 1为剪枝操作
        for(let i = startIndex; i <= n - (k - path.length) + 1; i++){
            path.push(i);
            backtracking(n, k , i + 1);
            path.pop();
        }

    }
    backtracking(n, k, 1);
    return res;
};

全排列问题

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

解决思路：
这个题目乍一看和组合问题非常相似，但是组合是没有次序的，也就是[1,2]和[2,1]是一样的，但是排列上是不一样的。这也是这两道题目的主要区别。因此我们这里就不使用startIndex了，而采用used记录是否已经使用过。

代码实现：

 var permute = function(nums) {
    let res = [], path = [];
    function backtracking(n, k, used){
        //递归结束条件
        if(path.length === k){
            res.push([...path]);
            return;
        }
        for(let i = 0; i < k; i++){
            if(used[i]) continue;
            path.push(n[i]);
            used[i] = true;
            backtracking(n, k ,used);
            path.pop();
            used[i] = false;
        }
    }
    backtracking(nums, nums.length,[]);
    return res;
};

排列和组合问题的区别

• 排列每层都是从0开始搜索，而组合我们用startIndex记录开始的元素下标
• 排列需要用used数组记录path里都放了哪些元素

---

关于去重问题

树枝去重可以通过对需要排列或组合的nums去重（借助Set()）

树层去重要稍微复杂一点，可以先对nums进行排序，参考题目全排列II

var permuteUnique = function(nums) {
    nums.sort((a,b) => a - b);
    let res = [], path = [];
    function backtracking(n, k, used) {
        //递归结束条件
        if (path.length === k) {
            res.push([...path]);
            return;
        }
        for (let i = 0; i < k; i++) {
            //used[i - 1]为true说明同一树枝n[i-1]使用过
            //used[i - 1]为false，由于按顺序加入，说明同一数层n[i-1]使用过
            if(i > 0 && n[i] === n[i - 1] && !used[i - 1]) continue;
            if (!used[i]) {
                path.push(n[i]);
                used[i] = true;
                backtracking(n, k, used);
                path.pop();
                used[i] = false;
            }
           
        }
    }
    backtracking(nums, nums.length, []);
    return res;
};

这里需要注意的是我们借助used[i]来判断元素是否使用过，当used[i]=true，则说明该path中已经使用过nums[i]，也就是我们刚才提到的树枝上重复；那么当used[i-1]=false时，如果我们这时步骤已经到要加入nums[i]，且nums[i]=nums[i - 1]，由于已经排序过，此时则说明同一层中nums[i-1]已经使用过，也就是数层重复。可以结合Carl哥的图来理解

学习参考