代码随想录 day29 回溯算法

代码随想录 day29 回溯算法

题491 求递增子序列

给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。
输入: [4, 6, 7, 7]
输出: [[4, 6], [4, 7], [4, 6, 7], [4, 6, 7, 7], [6, 7], [6, 7, 7], [7,7], [4,7,7]]

思考

1，自己按照求子集的类似方法写了，但nums = [1,2,3,4,5,6,7,8,9,10,1,1,1,1,1] 时出错了，结果集中出现了[1,2,3,4,5,6,7,8,9,10,1],[1,2,3,4,5,6,7,8,9,10,1,1],[1,2,3,4,5,6,7,8,9,10,1,1,1] 等等不该出现的结果。两个地方错误：一个是取path最后的元素错用了peek()方法，对于linkedlist来说，peek()方法是取的第一个元素而不是最后加入的元素。第二个错误是仅仅判断了相邻的相同元素而没有判断不相邻的相同元素。

启发：

1，本题不能对原数组进行排序，需要在原有顺序上求递增子序列。这就造成了自己写的时候的第二个错误，也就是说本题需要判断不相邻的相同元素。
2，如果nums = [4,7,6,7,9]这样两个7不挨着的数组，那么第二个7也应该跳过，因此在不能排序的情况下如果采用和求子集一样的用used数组来记录用过的元素就不合适了，题解中在每个数层中采用了一个set来记录用过的元素，每递归一次就有创建一个新的set来记录，这样无论重复元素是否出现在一起都能够知道该元素是否出现过。
3，由于原数组中的元素要求在-100-100之间，是有限个（201）个数，可以用数组来做哈希查找（效率比set和map更高）。
4，需要注意的另外一点在于由于used数组是在每个数层都重新创建的新数组，因此不需要回溯。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backTracking(nums, 0);
        return result;
    }

    public void backTracking(int[] nums, int startIndex){
        if(path.size() > 1){
            result.add(new ArrayList<>(path));
        }
        //定义一个数组来记录每个树层中出现过的元素，-100-100，用201大小的数组。
        int[] used = new int[201];
        if(startIndex >= nums.length) return;
        for(int i = startIndex; i < nums.length; i++){
            //看当前元素是否出现过。
            if(used[nums[i] + 100] == 1){
                continue;
            }
            if(!path.isEmpty() && path.get(path.size() - 1) > nums[i]){
                continue; 
            }
            path.add(nums[i]);
            used[nums[i] + 100] = 1;
            backTracking(nums, i + 1);
            path.removeLast();
        }
    }
}

题46 全排列

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:
输入: [1,2,3]
输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]

思考

1，本题自己写通过了。通过自己画树形结构进行分析，每次递归时传入的参数为取出当前元素后的数组，比如[1,2,3]取1后，递归函数应该传入[2,3]。
2，与组合问题不同的是，不需要startindex。
3，注意终止条件应该为数组为空。（这个第一次还弄错了)。

启发

1，题解中引入used数组来记录已经使用过的元素，其实可以想象为每次取元素都从原数组中的第一个开始取，但需要判断是否被使用过，如果使用过就跳过该元素，其实与上面自己思考中将原数组中已经使用过的元素删除是一样的效果，只不过引入used数组更高效，适用范围应该也会更广泛。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();

    /**
    方法2:引入used数组来记录使用过的元素。
     */
    public List<List<Integer>> permute(int[] nums) {
        int[] used = new int[nums.length];
        backTracking(nums, used);
        return result;
    }

    public void backTracking(int[] nums, int[] used) {
        if(path.size() == nums.length) {
            result.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0; i < nums.length; i++) {
            if(used[i] == 1) continue;
            path.add(nums[i]);
            used[i] = 1;
            backTracking(nums, used);
            path.removeLast();
            used[i] = 0;
        }
    }


    /**
    方法1:没有引入used数组记录已经用过的元素，而是下一层遍历时传入移除当前元素后的数组
     */
    // public List<List<Integer>> permute(int[] nums) {
    //     backTracking(nums);
    //     return result;
    // }

    // public void backTracking(int[] nums){
    //     //注意终止条件。
    //     if(nums.length == 0){
    //         result.add(new ArrayList<>(path));
    //         return;
    //     }
    //     for(int i = 0; i < nums.length; i++){
    //         path.add(nums[i]);
    //         backTracking(removeElement(nums, i));
    //         path.removeLast();
    //     }
    // }

    // //数组中移除一个元素。
    // public int[] removeElement(int[] nums, int index){
    //     if(index < 0 || index >= nums.length){
    //         return nums;
    //     }
    //     int[] result = new int[nums.length - 1];
    //     for(int i = 0; i < index; i++){
    //         result[i] = nums[i];
    //     }
    //     for(int j = index; j < nums.length - 1; j++){
    //         result[j] = nums[j + 1];
    //     }
    //     return result;
    // }
}

题47

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
示例 1：
输入：nums = [1,1,2]
输出： [[1,1,2], [1,2,1], [2,1,1]]

思考

1，比照上一题，题目中多了一个条件就是原数组中有重复元素，但结果集中不能有重复元素，因此需要进行去重。可以参考求递增子集中每层循环里新建一个set来保存已经用过的元素，如果遇到了相同元素就跳过。

启发

1，其实没有必要单独定义一个set，只在used数组上进行操作就可以了，当然前提是要先把原数组排序。
2，只有used数组，就是当used[i-1] == 0 时跳过，表明数层上遇到了重复元素，当used[i - 1] 为1时代表树枝上遇到了重复元素。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        int[] used = new int[nums.length];
        Arrays.sort(nums);
        backTracking(nums, used);
        return result;
    }

    public void backTracking(int[] nums, int[] used) {
        if(path.size() == nums.length) {
            result.add(new ArrayList<>(path));
            return;
        }
        //int[] usedSet = new int[21]; // 定义一个数组来处理树层上的去重
        for(int i = 0; i < nums.length; i++) {
            //if(used[i] == 1 || usedSet[nums[i] + 10] == 1) continue;
            if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == 0) continue;
            if(used[i] == 1) continue;
            path.add(nums[i]);
            used[i] = 1;
            //usedSet[nums[i] + 10] = 1;
            backTracking(nums, used);
            path.removeLast();
            used[i] = 0;
        }
    }
}