LeetCode Weekly Contest 193

最新推荐文章于 2022-05-09 10:49:46 发布

da_kao_la

最新推荐文章于 2022-05-09 10:49:46 发布

阅读量225

点赞数

分类专栏： LeetCode 文章标签： LeetCode 周赛

本文链接：https://blog.youkuaiyun.com/da_kao_la/article/details/106746314

版权

LeetCode 专栏收录该内容

371 篇文章

订阅专栏

5436. 一维数组的动态和

给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。

请返回 nums 的动态和。

示例 1：

输入：nums = [1,2,3,4]
输出：[1,3,6,10]
解释：动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。
示例 2：

输入：nums = [1,1,1,1,1]
输出：[1,2,3,4,5]
解释：动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。
示例 3：

输入：nums = [3,1,2,10,1]
输出：[3,4,6,16,17]

提示：

1 <= nums.length <= 1000
-10^6 <= nums[i] <= 10^6

代码

class Solution {
    public int[] runningSum(int[] nums) {
        int n = nums.length, i = 0;
        int[] sums = new int[n];
        sums[0] = nums[0];
        for (i=1; i<n; ++i) {
            sums[i] = sums[i-1] + nums[i]; 
        }
        return sums;
    }
}

5437. 不同整数的最少数目

给你一个整数数组 arr 和一个整数 k 。现需要从数组中恰好移除 k 个元素，请找出移除后数组中不同整数的最少数目。

示例 1：

输入：arr = [5,5,4], k = 1
输出：1
解释：移除 1 个 4 ，数组中只剩下 5 一种整数。
示例 2：

输入：arr = [4,3,1,1,3,3,2], k = 3
输出：2
解释：先移除 4、2 ，然后再移除两个 1 中的任意 1 个或者三个 3 中的任意 1 个，最后剩下 1 和 3 两种整数。

提示：

1 <= arr.length <= 10^5
1 <= arr[i] <= 10^9
0 <= k <= arr.length

代码

class Solution:
    def findLeastNumOfUniqueInts(self, arr: List[int], k: int) -> int:
        cnts = dict()
        for num in arr:
            cnts[num] = cnts.setdefault(num, 0) + 1
        cnts = list(cnts.values())
        cnts.sort()
        ans = len(cnts)
        for cnt in cnts:
            if k >= cnt:
                k -= cnt
                ans -= 1
            else:
                break
        return ans

5438. 制作 m 束花所需的最少天数

给你一个整数数组 bloomDay，以及两个整数 m 和 k 。

现需要制作 m 束花。制作花束时，需要使用花园中相邻的 k 朵花。

花园中有 n 朵花，第 i 朵花会在 bloomDay[i] 时盛开，恰好可以用于一束花中。

请你返回从花园中摘 m 束花需要等待的最少的天数。如果不能摘到 m 束花则返回 -1 。

示例 1：

输入：bloomDay = [1,10,3,10,2], m = 3, k = 1
输出：3
解释：让我们一起观察这三天的花开过程，x 表示花开，而 _ 表示花还未开。
现在需要制作 3 束花，每束只需要 1 朵。
1 天后：[x, _, _, _, _] // 只能制作 1 束花
2 天后：[x, _, _, _, x] // 只能制作 2 束花
3 天后：[x, _, x, _, x] // 可以制作 3 束花，答案为 3
示例 2：

输入：bloomDay = [1,10,3,10,2], m = 3, k = 2
输出：-1
解释：要制作 3 束花，每束需要 2 朵花，也就是一共需要 6 朵花。而花园中只有 5 朵花，无法满足制作要求，返回 -1 。
示例 3：

输入：bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3
输出：12
解释：要制作 2 束花，每束需要 3 朵。
花园在 7 天后和 12 天后的情况如下：
7 天后：[x, x, x, x, _, x, x]
可以用前 3 朵盛开的花制作第一束花。但不能使用后 3 朵盛开的花，因为它们不相邻。
12 天后：[x, x, x, x, x, x, x]
显然，我们可以用不同的方式制作两束花。
示例 4：

输入：bloomDay = [1000000000,1000000000], m = 1, k = 1
输出：1000000000
解释：需要等 1000000000 天才能采到花来制作花束
示例 5：

输入：bloomDay = [1,10,2,9,3,8,4,7,5,6], m = 4, k = 2
输出：9

提示：

bloomDay.length == n
1 <= n <= 10^5
1 <= bloomDay[i] <= 10^9
1 <= m <= 10^6
1 <= k <= n

思路

二分答案。判断答案是否符合要求的方法check用到了贪心

代码

class Solution:
    def check(self, mid, bloomDay, m, k):
        avail = 0
        consq = 0
        for bloom in bloomDay:
            if bloom <= mid:
                consq += 1
                if consq >= k:
                    consq -= k
                    avail += 1
            else:
                consq = 0
        return avail >= m
    
    def minDays(self, bloomDay: List[int], m: int, k: int) -> int:
        left = 1
        right = max(bloomDay)
        mid = 0
        if len(bloomDay) < m * k:
            return -1
        while left <= right:
            mid = left + (right - left) // 2
            if self.check(mid, bloomDay, m, k):
                right = mid - 1
            else:
                left = mid + 1
        return left

5188. 树节点的第 K 个祖先

题目难度Hard
给你一棵树，树上有 n 个节点，按从 0 到 n-1 编号。树以父节点数组的形式给出，其中 parent[i] 是节点 i 的父节点。树的根节点是编号为 0 的节点。

请你设计并实现 getKthAncestor(int node, int k) 函数，函数返回节点 node 的第 k 个祖先节点。如果不存在这样的祖先节点，返回 -1 。

树节点的第 k 个祖先节点是从该节点到根节点路径上的第 k 个节点。

示例：

输入：
[“TreeAncestor”,“getKthAncestor”,“getKthAncestor”,“getKthAncestor”]
[[7,[-1,0,0,1,1,2,2]],[3,1],[5,2],[6,3]]

输出：
[null,1,0,-1]

解释：
TreeAncestor treeAncestor = new TreeAncestor(7, [-1, 0, 0, 1, 1, 2, 2]);

treeAncestor.getKthAncestor(3, 1); // 返回 1 ，它是 3 的父节点
treeAncestor.getKthAncestor(5, 2); // 返回 0 ，它是 5 的祖父节点
treeAncestor.getKthAncestor(6, 3); // 返回 -1 因为不存在满足要求的祖先节点

提示：

1 <= k <= n <= 510^4
parent[0] == -1 表示编号为 0 的节点是根节点。
对于所有的 0 < i < n ，0 <= parent[i] < n 总成立
0 <= node < n
至多查询 510^4 次

思路

树上倍增。相当于对于所有(node, k)的结果的cache的一种二进制压缩。
cache[node][k]表示node节点的第2^k个祖先。递推公式：cache[node][k] = cache[cache[node][k-1]][k-1]. 查询时按k的二进制位（(1<<i)&k判断k的第i位是否是1）使用cache回溯
计算cache时间复杂度为O(nlogn)，一次查询时间复杂度为O(logn)，空间复杂度为O(nlogn).

代码

class TreeAncestor {
    private HashMap<Integer, ArrayList<Integer>> sons;
    private int[][] cache;
    private static final int MAX_LOG_DEPTH=20;

    public TreeAncestor(int n, int[] parent) {
        sons = new HashMap<>();
        for (int i=0; i<n; ++i) {
            if (parent[i] != -1) {
                if (!sons.containsKey(parent[i])) {
                    sons.put(parent[i], new ArrayList<>());
                }
                sons.get(parent[i]).add(i);
            }
        }
        cache = new int[n][MAX_LOG_DEPTH];
        for (int i=0; i<n; ++i) {
            Arrays.fill(cache[i], -1);
        }
        dfs(0);
    }
    
    private void dfs(int root) {
        if (sons.containsKey(root)) {
            for (int son: sons.get(root)) {
                cache[son][0] = root;
                for (int i=1; i<MAX_LOG_DEPTH; ++i) {
                    if (cache[son][i-1] == -1) {
                        break;
                    }
                    cache[son][i] = cache[cache[son][i-1]][i-1];
                }
                dfs(son);
            }
        }
    }
    
    public int getKthAncestor(int node, int k) {
        for (int i=0; i<MAX_LOG_DEPTH; ++i) {
            if (((1<<i) & k) != 0) {
                node = cache[node][i];
                if (node == -1) {
                    return -1;
                }
            }
        }
        return node;
    }
}

/**
 * Your TreeAncestor object will be instantiated and called as such:
 * TreeAncestor obj = new TreeAncestor(n, parent);
 * int param_1 = obj.getKthAncestor(node,k);
 */