LeetCode148周赛

LeetCode148周赛

1144. 递减元素使数组呈锯齿状

https://leetcode-cn.com/contest/weekly-contest-148/problems/decrease-elements-to-make-array-zigzag/

给你一个整数数组 nums，每次 操作 会从中选择一个元素并 将该元素的值减少 1。

如果符合下列情况之一，则数组 A 就是 锯齿数组：

• 每个偶数索引对应的元素都大于相邻的元素，即 A[0] > A[1] < A[2] > A[3] < A[4] > ...
• 或者，每个奇数索引对应的元素都大于相邻的元素，即 A[0] < A[1] > A[2] < A[3] > A[4] < ...

返回将数组 nums 转换为锯齿数组所需的最小操作次数。

 

示例 1：

输入：nums = [1,2,3]
输出：2
解释：我们可以把 2 递减到 0，或把 3 递减到 1。

示例 2：

输入：nums = [9,6,1,6,2]
输出：4

 

提示：

• 1 <= nums.length <= 1000
• 1 <= nums[i] <= 1000

思路：只有两种改变方法，要不改变奇数位，要不改变偶数位置，返回两个改变方法所需代价的最小值。 

垃圾代码，凑活着看吧

public int movesToMakeZigzag(int[] nums) {
    int cnt1 = 0,cnt2 = 0;
    for (int i = 0;i < nums.length;i++) { //cnt1 - A[0] < A[1] > A[2] < A[3] > A[4] 
        if(i % 2 == 0) {
            if (i == 0){
                if (nums[1] <= nums[0]) {
                    cnt1 += nums[0] - (nums[1] - 1);
                }            		
            }
            else {
                if(i + 1 == nums.length) {
                    if(nums[i] >= nums[i-1])
                        cnt1 += nums[i] - nums[i-1] + 1;
                }else {
                    int min = Math.min(nums[i-1], nums[i+1]);
                    cnt1 += nums[i] < min ? 0 : nums[i] - min + 1;
                }            		
            }   
        } else {// cnt2 - A[0] > A[1] < A[2] > A[3] < A[4]	> A[5]	
            if(i + 1 == nums.length) {
                if(nums[i] >= nums[i-1])
                    cnt2 += nums[i] - nums[i-1] + 1;
            } else {
                int min = Math.min(nums[i-1], nums[i+1]);
                cnt2 += nums[i] < min ? 0 : nums[i] - min + 1;
            }
        }       	      	
    }
    return Math.min(cnt1, cnt2);	
}

1145. 二叉树着色游戏

https://leetcode-cn.com/contest/weekly-contest-148/problems/binary-tree-coloring-game/

有两位极客玩家参与了一场「二叉树着色」的游戏。游戏中，给出二叉树的根节点 root，树上总共有 n 个节点，且 n 为奇数，其中每个节点上的值从 1 到 n 各不相同。

 

游戏从「一号」玩家开始（「一号」玩家为红色，「二号」玩家为蓝色），最开始时，

「一号」玩家从 [1, n] 中取一个值 x（1 <= x <= n）；

「二号」玩家也从 [1, n] 中取一个值 y（1 <= y <= n）且 y != x。

「一号」玩家给值为 x 的节点染上红色，而「二号」玩家给值为 y 的节点染上蓝色。

 

之后两位玩家轮流进行操作，每一回合，玩家选择一个他之前涂好颜色的节点，将所选节点一个 未着色 的邻节点（即左右子节点、或父节点）进行染色。

如果当前玩家无法找到这样的节点来染色时，他的回合就会被跳过。

若两个玩家都没有可以染色的节点时，游戏结束。着色节点最多的那位玩家获得胜利 ✌️。

 

现在，假设你是「二号」玩家，根据所给出的输入，假如存在一个 y 值可以确保你赢得这场游戏，则返回 true；若无法获胜，就请返回 false。

输入：root = [1,2,3,4,5,6,7,8,9,10,11], n = 11, x = 3
输出：True
解释：第二个玩家可以选择值为 2 的节点。

 思路：只有三个位置可以占，x节点的左右节点和父节点，分别统计这三种占位能获得的节点数目，取这三种情况的最大值，判断其是否大于n/2。

int max = 0;
public boolean btreeGameWinningMove(TreeNode root, int n, int x) {
    dfs(root,n,x);
    if(max > n/2)
        return true;
    return false;
}
public void dfs(TreeNode root, int n, int x){
    if(root == null)
        return;
    if(root.val == x){
        int left = count(root.left,x);
        int right = count(root.right,x);
        max = Math.max(n - left - right - 1,Math.max(left,right));
        return;
    }
    dfs(root.left,n,x);
    dfs(root.right,n,x);
}

public int count(TreeNode root,int x){
    if(root == null)
        return 0;
    if(root.val == x)
        return 0;
    return count(root.left,x) + count(root.right,x) + 1;      
}

 1146. 快照数组

https://leetcode-cn.com/contest/weekly-contest-148/problems/snapshot-array/

实现支持下列接口的「快照数组」- SnapshotArray：

• SnapshotArray(int length) - 初始化一个与指定长度相等的 类数组 的数据结构。初始时，每个元素都等于 0。
• void set(index, val) - 会将指定索引 index 处的元素设置为 val。
• int snap() - 获取该数组的快照，并返回快照的编号 snap_id（快照号是调用 snap() 的总次数减去 1）。
• int get(index, snap_id) - 根据指定的 snap_id 选择快照，并返回该快照指定索引 index 的值。

  示例：

  输入：["SnapshotArray","set","snap","set","get"]
       [[3],[0,5],[],[0,6],[0,0]]
  输出：[null,null,0,null,5]
  解释：
  SnapshotArray snapshotArr = new SnapshotArray(3); // 初始化一个长度为 3 的快照数组
  snapshotArr.set(0,5);  // 令 array[0] = 5
  snapshotArr.snap();  // 获取快照，返回 snap_id = 0
  snapshotArr.set(0,6);
  snapshotArr.get(0,0);  // 获取 snap_id = 0 的快照中 array[0] 的值，返回 5
  

  提示：

• 1 <= length <= 50000
• 题目最多进行50000 次set，snap，和 get的调用 。
• 0 <= index < length
• 0 <= snap_id < 我们调用 snap() 的总次数
• 0 <= val <= 10^9

思路：用TreeMap记录在哪个快照对该数组进行了更改

import java.util.Map.Entry;
class SnapshotArray {
    int snap_id;
    ArrayList<TreeMap<Integer,Integer>> list = new ArrayList<TreeMap<Integer,Integer>>();
    public SnapshotArray(int length) {
        list.clear();
        for(int i = 0;i < length;i++) {
            list.add(new TreeMap<Integer,Integer>());
        }
    }    
    public void set(int index, int val) {
        TreeMap<Integer, Integer> pairMap = list.get(index);  
        Integer value = pairMap.getOrDefault(snap_id, val);
        pairMap.put(snap_id, val);
    }    
    public int snap() {   
        return snap_id++;
    }   
    public int get(int index, int snap_id) {
        Entry<Integer, Integer> entry = list.get(index).floorEntry(snap_id);
    	return entry == null ? 0 : entry.getValue();
    }
}