Day28 代码随想录(1刷) 回溯

491. 非递减子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：
输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]
示例 2：
输入：nums = [4,4,3,2,1]
输出：[[4,4]]
提示：

1 <= nums.length <= 15
-100 <= nums[i] <= 100

状态：完成

思路：这题也是一道树层去重的问题，但是有别于之前那题这题不能像之前一样用布尔数组前面等于后面这种思路，因为这题不能排序，所以采用hashset这种去重的方式就可以了。

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    LinkedList<Integer> list=new LinkedList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backstracking(0,nums);
        return result;
    }
    public void backstracking(int start,int[] nums){
        if(list.size()>1)
            result.add(new ArrayList(list));
            System.out.println(list);
        HashSet<Integer> used=new HashSet<>();
        for(int i=start;i<nums.length;i++){
            if(!list.isEmpty()&&list.getLast()>nums[i]) continue;
            if(used.contains(nums[i])){
                continue;
            }
            list.add(nums[i]);
            used.add(nums[i]);
            backstracking(i+1,nums);
            list.removeLast();
        }
    }
}

46. 全排列

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

示例 1：
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2：
输入：nums = [0,1]
输出：[[0,1],[1,0]]
示例 3：
输入：nums = [1]
输出：[[1]]
提示：

1 <= nums.length <= 6
-10 <= nums[i] <= 10
nums 中的所有整数 互不相同

状态：完成

思路：该题要求的是数组的全排列而且数组中不含重复的元素，所以这题是要路径去重的，就是同一个路径下的取得元素不能重复，然后回溯就可以了。

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    LinkedList<Integer> list=new LinkedList<>();
    HashSet<Integer> set=new HashSet<>();
    public List<List<Integer>> permute(int[] nums) {
        backstracking(nums);
        return result;
    }
    public void backstracking(int[] nums){
        if(list.size()==nums.length){
            result.add(new ArrayList(list));
            return;
        }
        
        for(int i=0;i<nums.length;i++){
            if(set.contains(nums[i])) continue;
            list.add(nums[i]);
            set.add(nums[i]);
            backstracking(nums);
            list.removeLast();
            set.remove(nums[i]);
        }
    }
}

47. 全排列 II

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：
输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]
示例 2：
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
提示：

1 <= nums.length <= 8
-10 <= nums[i] <= 10

状态：完成

思路：该题不仅涉及路径的去重还涉及树层的去重所以我这里用了两个hashset用于去重，set对结果进行去重，set2对路劲进行去重，其他与上一题无异。

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    LinkedList<Integer> list=new LinkedList<>();
    HashSet<LinkedList<Integer>> set =new HashSet<>();
    HashSet<Integer> set2=new HashSet<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        backstracking(nums);
        return result;
    }
    public void backstracking(int[] nums){
        if(list.size()==nums.length){
            if(!set.contains(list)){
                result.add(new ArrayList(list));
                set.add(list);
            }
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(set2.contains(i)) continue;
            list.add(nums[i]);
            set2.add(i);
            backstracking(nums);
            list.removeLast();
            set2.remove(i);
        }
    }
}

332. 重新安排行程

给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。

所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。

例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前。

假定所有机票至少存在一种合理的行程。且所有的机票必须都用一次且只能用一次。

示例 1：
输入：tickets = [["MUC","LHR"],["JFK","MUC"],["SFO","SJC"],["LHR","SFO"]]
输出：["JFK","MUC","LHR","SFO","SJC"]
示例 2：
输入：tickets = [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
输出：["JFK","ATL","JFK","SFO","ATL","SFO"]
解释：另一种有效的行程是 ["JFK","SFO","ATL","JFK","ATL","SFO"] ，但是它字典排序更大更靠后。
提示：

1 <= tickets.length <= 300
tickets[i].length == 2
fromi.length == 3
toi.length == 3
fromi 和 toi 由大写英文字母组成
fromi != toi

状态：超时了

思路：我一开始用暴力的回溯卡在80/81了，后面看了carl的方法用一个used数组去标记省得在hash表里查找了，这样应该不会超时但我这里用了另一个方法去做。这题题目条件说了每个票只能用一次所以说这是一个欧拉回路（经历每条边一次的路）的问题，他有一种解法就是，只有入度和出度相差1的节点是死结点意思就是他肯定就是最后一个节点的，换个方向思考先把死结点入栈然后再从死结点出发再回去起始节点就可以了。

class Solution {
    LinkedList<String> list=new LinkedList<>();
    HashSet<Integer> set=new HashSet<>();
    Map<String,PriorityQueue<String>> map=new HashMap<>();
    public List<String> findItinerary(List<List<String>> tickets) {
        for(List<String> s:tickets){
            if(map.containsKey(s.get(0))){
                map.get(s.get(0)).add(s.get(1));
            }else{
                PriorityQueue<String> queue=new PriorityQueue<String>();
                queue.add(s.get(1));
                map.put(s.get(0),queue);
            }
        }
        backstracking("JFK");
        Collections.reverse(list);
        return list;
    }
    public void backstracking(String from){
        while(map.containsKey(from)&&map.get(from).size()>0){
            String temp=map.get(from).poll();
            backstracking(temp);
        }
        list.add(from);
    }
}

感想：今天的题目质量比较高，也学了挺多新的方法方式去解决问题。明天最后一天回溯了。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/512248.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！