【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