【回溯算法 4】全排列（medium）II（每日一题）

 🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇

                                      ⭐回溯⭐

🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇🎇

---

前言

回溯算法是⼀种经典的递归算法，通常⽤于解决组合问题、排列问题和搜索问题等。

回溯算法的基本思想：从⼀个初始状态开始，按照⼀定的规则向前搜索，当搜索到某个状态⽆法前进 时，回退到前⼀个状态，再按照其他的规则搜索。

回溯算法在搜索过程中维护⼀个状态树，通过遍历 状态树来实现对所有可能解的搜索。 回溯算法的核⼼思想：“试错”，即在搜索过程中不断地做出选择，如果选择正确，则继续向前搜 索；否则，回退到上⼀个状态，重新做出选择。

回溯算法通常⽤于解决具有多个解，且每个解都需要 搜索才能找到的问题。

---

 回溯算法的模板

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Backtracking {
    public void backtracking(int[] candidates, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(candidates);
      // 如果需要对candidates进行排序

        backtrack(result, new ArrayList<>(), candidates, target, 0);
    }

    private void backtrack(List<List<Integer>> result, List<Integer> tempList, int[] candidates, int remain, int start) {
        if (remain < 0) { 
       // 如果 remain 小于 0，表示当前的组合不符合要求，直接返回
            return;
        } else if (remain == 0) { 
            // 如果 remain 等于 0，表示当前的组合符合要求，加入到结果中
            result.add(new ArrayList<>(tempList));
        } else {
            for (int i = start; i < candidates.length; i++) {
                if (i > start && candidates[i] == candidates[i - 1]) {
                    continue; 
                  // 避免重复计算，如果当前数字和上一个数字相同，则跳过
                }
                tempList.add(candidates[i]); // 将当前数字加入到临时列表中
                backtrack(result, tempList, candidates, remain - candidates[i], i + 1); 
                // 递归调用，继续向下搜索
                tempList.remove(tempList.size() - 1); 
                // 回溯，将最后加入的数字移除，尝试下一个数字
            }
        }
    }
}

 回溯算法是⼀种⾮常重要的算法，可以解决许多组合问题、排列问题和搜索问题等。回溯算法的核⼼ 思想是搜索状态树，通过遍历状态树来实现对所有可能解的搜索。回溯算法的模板⾮常简单，但是实 现起来需要注意⼀些细节，⽐如如何做出选择、如何撤销选择等。

---

2. 全排列 II（medium）

题目链接：47. 全排列 II - 力扣（LeetCode）

算法思路：解法（归并排序）：

算法思路：

典型的回溯题⽬，我们需要在每⼀个位置上考虑所有的可能情况并且不能出现重复。通过深度优先搜 索的⽅式，不断地枚举每个数在当前位置的可能性，并回溯到上⼀个状态，直到枚举完所有可能性， 得到正确的结果。 每个数是否可以放⼊当前位置，只需要判断这个数在之前是否出现即可。具体地，在这道题⽬中，我 们可以通过⼀个递归函数backtrack和标记数组visited来实现全排列。

当递归过程如下：

1. 首先定义一个二维数组res用来存放所有可能的排列，一个一维数组ans用来存放每个状态的排列，一个一维数组visited标记元素，然后从第一个位置开始进行递归；

2. 在每个递归的状态中，我们维护一个步数step，表示当前已经处理了几个数字；

3. 递归结束条件：当step等于nums数组的长度时，说明我们已经处理完了所有数字，将当前数组存入结果中；

4. 在每个递归状态中，枚举所有下标i，若这个下标未被标记，则使用nums数组中当前下标的元素： a. 将visited[i] 标记为1； b. ans数组中第step个元素被nums[i]覆盖； c. 对第step+1个位置进行递归； d. 将visited[i] 重新赋值为0，表示回溯；

5. 最后，返回res。

特别地，我们可以不使用标记数组，直接遍历step之后的元素（未被使用），然后将其与需要递归的位置进行交换即可。

 代码实现：

class Solution {
    //这道题和全排列 1 很相似,只是一个重复不重复的改变,这里直接对之前的代码弄个剪枝就可以解决问题
    //全局变量(也可以写到dfs的参数里边)
    //返回值
    private List<List<Integer>> ret;
    //记录路径的数组
    private List<Integer> path;
    //检查是否已选择来剪枝
    private boolean[] check;
    private boolean[] isRepetitive;
    public List<List<Integer>> permuteUnique(int[] nums){
        //这里利用回溯 剪枝 dfs 画出决策树来解决问题
        ret = new ArrayList<>();
        path = new ArrayList<>();
        check = new boolean[nums.length];
        isRepetitive = new boolean[nums.length];
        dfs(nums);
        return ret;
    }
    public void dfs(int[] nums){
        //满足条件碰到叶子节点就丢进去
        if(path.size()==nums.length){
           ret.add(new ArrayList<>(path));
            return;
        }
        //开始遍历子树
        for(int i=0;i<nums.length;i++){
            //剪枝 如果 没被使用 并且 无重复 才走,不然不走
            if(check[i]==false && isRepetitive[i]==false){ 
               path.add(nums[i]);
               check[i] = true;
               //回溯
               for(int j = i+1;j<nums.length;j++){
                 if(nums[j] == nums[i]){
                    isRepetitive[j] = false;
                 } 
               }
               dfs(nums);
               //回溯 1. 路径删除这个数 2. 该数置否
               path.remove(path.size()-1);
               check[i] = false;
               //对后边重复的数置 true
               for(int j = i+1;j<nums.length;j++){
                 if(nums[j] == nums[i]){
                    isRepetitive[j] = true;
                 } 
               }
            }
        }

    }
}

---

总结

动动手点个赞会让作者更开心，感谢阅览，加油哇各位 ！