【LeetCode】Sama的个人记录_34

 

【Q491】(md) 递增子序列
 
给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是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]]
 
说明:
给定数组的长度不会超过15。
数组中的整数范围是 [-100,100]。
给定数组中可能包含重复数字，相等的数字应该被视为递增的一种情况。

class Solution {
    /**
     *【回溯】(或者说是【DFS】)
     * 难点在于避免重复————思路是，在一次for循环中，某个值如果第二次遇到就跳过(用set集合不难实现)
     * ↑ 注意是一次for中，不是一条路径中
     * 
     * 比如[1, 3, 5, 5, 7, 5]，此时layer=1，那么for循环决定下一层时候，只用第一个5,其余的在此次for中直接跳过
     * ↑ 其正确性与安全性需要稍微思考一下，毕竟不是很直观
     */
    public List<List<Integer>> findSubsequences(int[] nums) {
        traceback(new ArrayList<>(), 0, nums);
        List<List<Integer>> finalRes = new ArrayList<>();
        return resList;
    }

    private List<List<Integer>> resList = new ArrayList<>();

    /**
     *
     * @param tempList 暂存串
     * @param layer 表示nums数组从layer开始以及之后的数字可用
     * @param nums 信息
     */
    private void traceback(List<Integer> tempList, int layer, int[] nums){
        if(tempList.size() >= 2){
            resList.add(new ArrayList<>(tempList));
        }

        Set<Integer> set = new HashSet<>(); // (!)关键
        for(int i = layer; i < nums.length; i++){
            if(set.contains(nums[i])){
                continue;
            }
            set.add(nums[i]);
            if(!tempList.isEmpty() && nums[i] < tempList.get(tempList.size() - 1)){
                continue;
            }
            tempList.add(nums[i]);
            traceback(tempList, i + 1, nums);
            tempList.remove(tempList.size() - 1);
        }
    }
}

 
 

【Q332】(md) 重新安排行程
 
给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从 JFK出发的先生，所以该行程必须从 JFK 开始。
 
提示(要求)：

如果存在多种有效的行程，请你按字符自然排序返回最小的行程组合。例如，行程 [“JFK”, “LGA”] 与 [“JFK”, “LGB”]相比就更小，排序更靠前
所有的机场都用三个大写字母表示（机场代码）。
假定所有机票至少存在一种合理的行程。 所有的机票必须都用一次 且只能用一次。
 
示例 1：

输入：[[“MUC”, “LHR”], [“JFK”, “MUC”], [“SFO”, “SJC”], [“LHR”, “SFO”]]
输出：[“JFK”, “MUC”, “LHR”, “SFO”, “SJC”]
 
示例 2：
输入：[[“JFK”,“SFO”],[“JFK”,“ATL”],[“SFO”,“ATL”],[“ATL”,“JFK”],[“ATL”,“SFO”]]
输出：[“JFK”,“ATL”,“JFK”,“SFO”,“ATL”,“SFO”]
解释：另一种有效的行程是 [“JFK”,“SFO”,“ATL”,“JFK”,“ATL”,“SFO”]。但是它自然排序更大更靠后。

class Solution {
    /**
     *【欧拉图】
     * 这道题目其实就是【一笔画】找出一个欧拉通路，采用的核心思想是【DFS+删除图的边】
     *      1.先转化为有向图的邻接表
     *      2.从固定的"JFK"开始深搜
     *      3.注1：在dfs的同时删除走过的路径
     *      4.注3：当一个节点没有出度后，进入结果队列
     *
     * 理解：
     *      1.根据题目要求，这条欧拉通路是必然存在的，因此不需要使用【回溯】
     *      2.在解决图的相关问题时，【删边】是一个可供选择的思路
     */
    public List<String> findItinerary(List<List<String>> tickets) {
        for(List<String> ticket : tickets){
            String src = ticket.get(0);
            String des = ticket.get(1);
            if(!map.containsKey(src)){
                map.put(src, new PriorityQueue<>());
            }
            map.get(src).offer(des);
        }

        DFS("JFK");
        Collections.reverse(resList);
        return resList;
    }

    Map<String, PriorityQueue<String>> map = new HashMap<>();
    List<String> resList = new LinkedList<>();

    private void DFS(String cur){
        while (map.containsKey(cur) && map.get(cur).size() > 0){
            String next = map.get(cur).poll();
            DFS(next);
        }
        resList.add(cur);
    }
}

 
 

【Q486】(md) 预测赢家
 
给定一个表示分数的非负整数数组。 玩家 1 从数组任意一端拿取一个分数，随后玩家 2 继续从剩余数组任意一端拿取分数，然后玩家 1 拿，……每次一个玩家只能拿取一个分数，分数被拿取之后不再可取。直到没有剩余分数可取时游戏结束。最终获得分数总和最多的玩家获胜。
 
给定一个表示分数的数组，预测玩家1是否会成为赢家。你可以假设每个玩家的玩法都会使他的分数最大化。
 
示例 1：
输入：[1, 5, 2]
输出：False

 
示例 2：
输入：[1, 5, 233, 7]
输出：True
 
提示：

1 <= 给定的数组长度 <= 20.
数组里所有分数都为非负数且不会大于 10000000 。
如果最终两个玩家的分数相等，那么玩家 1仍为赢家。

class Solution {
    /**
     *【博弈】【动态规划】
     * 区间[i, j]中先手可获得的最大值：掌握主动权———拿[端点]+[剩下的后手]。拿左端点还是右端点自己决定(取最大值)
     * 区间[i, j]中后手可获得的最大值：身不由己———不到端点，且只能拿到[剩下的先手]。因为只能用对手剩下的，所以只能取[剩下先手]的最小值
     *
     * 注意：
     * 1.【博弈】的题目中，先手和后手在动态规划的过程中不断巧妙转化，注意体会
     * 2.【博弈】的题目中，先手主动，后手被动———后手倾向于【被动记录】而非【主动选择】，这是博弈题目的默认要求
     * 3.【动态规划】时：注意填表顺序；数组可以压缩，但没必要
     */
    public boolean PredictTheWinner(int[] nums) {
        int len = nums.length;
        int[][] dp1 = new int[len][len];    // 先手
        int[][] dp2 = new int[len][len];    // 后手

        for(int j = 0; j < len; j++){
            for(int i = j; i >= 0; i--){
                if(i == j){
                    dp1[i][j] = nums[i];    // 初始化
                    continue;
                }
                dp1[i][j] = Math.max(nums[i] + dp2[i + 1][j], nums[j] + dp2[i][j - 1]);     //【主动选择】
                dp2[i][j] = Math.min(dp1[i + 1][j], dp1[i][j - 1]);                         //【被动记录】
            }
        }

        return dp1[0][len - 1] >= dp2[0][len - 1];
    }
}

 
 

 

 

 

 

 

 

 

 

 
 

 

 

Qs from https://leetcode-cn.com
♣ loli suki
♦ end