[算法]LeetCode第193场周赛202006014

最新推荐文章于 2023-10-02 15:19:52 发布

GitKid

最新推荐文章于 2023-10-02 15:19:52 发布

阅读量208

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/shinef/article/details/106865147

版权

算法专栏收录该内容

65 篇文章 0 订阅

订阅专栏

第193场周赛

20200614

1480. 一维数组的动态和

难度：简单

题目描述1

给你一个数组 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

Solution1

前缀和的作用：某一个区间的和。

class Solution {
    public int[] runningSum(int[] nums) {
        int[] ans = new int[nums.length];
        for(int i = 0; i < nums.length; i++){
            int sum = 0;
            for(int j = 0; j <= i; j++){
                sum += nums[j];
            }
            ans[i] = sum;
        }
        return ans;
    }
}

1481. 不同整数的最少数目

难度：中等

题目描述2

给你一个整数数组 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

Solution

HashMap来存储每个数字的次数，然后放进数组里。数组排序之后，从小到大，如果k大于这个数字次数，那么这个数字就可以移除

class Solution {
    public int findLeastNumOfUniqueInts(int[] arr, int k) {
        Map<Integer, Integer> map = new HashMap<>();//map来存储每个数字的次数
        for(int num : arr){
            map.put(num, map.getOrDefault(num, 0) + 1);//map的这个用法经常用到，getOrDefault
        }
        int size = map.size();
        int[] cnt = new int[size];
        int m = 0;
        // 用keySet把每一个key取出来，然后用map.get(key)来取值
        // 之前用Map.Entry方法，感觉更繁琐
        for(int key : map.keySet()){
            cnt[m++] = map.get(key);
        }
        Arrays.sort(cnt);
        // 排序之后，从小到大，如果k大于这个数字次数，那么这个数字就可以移除
        // 否则就break
        for(int c : cnt){
            if(k >= c){
                k -= c;
                size--;
            }else{
                break;
            }
        }
        return size;
    }
}

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

难度；中等

题目描述3

给你一个整数数组 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

Solution3

二分法。

二分时间，这个时间前的所有花朵都盛开了，计算每个区间内可以得到的花束(区间长度/k)并求和，与总共需要的花束比较。

class Solution {
    public int minDays(int[] bloomDay, int m, int k) {
        //如果所需的花比现有的花还多
        if(m * k > bloomDay.length){
            return -1;
        }
        int low = Integer.MAX_VALUE;
        int high = 1;
        for(int day : bloomDay){
            high = Math.max(day, high);
            low = Math.min(day, low);
        }
        while(low < high){
            int mid = low + (high - low) / 2;
            int count = get(bloomDay, mid, k);
            if(count == m){
                high = mid;
            }else if(count < m){
                low = mid + 1;
            }else{
                high = mid - 1;
            }
        }
        return low;
    }
    public int get(int[] bloomDay, int day, int k){
        //获取当到达天数为day的时候，能够制作的花束数量
        int num = 0;//盛开的花的数量
        int sum = 0;//花束数量总和
        for(int i = 0; i < bloomDay.length; i++){
            //根据到达这天时，盛开或者没盛开，统计每个区间可以制作花束数量并求和
            if(bloomDay[i] <= day){
                //这里的花盛开了
                num++;
            }else{
                //一旦区间断掉，计算这一区间花束总和
                sum += num / k;
                num = 0;
            }
        }
        sum += num / k;//要加上最后一个区间的
        return sum;
    }
}

1483. 树节点的第 K 个祖先

难度；困难

题目描述4

给你一棵树，树上有 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 <= 5*10^4
parent[0] == -1 表示编号为 0 的节点是根节点。
对于所有的 0 < i < n ，0 <= parent[i] < n 总成立
0 <= node < n
至多查询 5*10^4 次

Solution4

dp[i][j] 表示节点i的第 $2^j$ 代祖先。

因为第7代祖先，可以表示为 $2^0 + 2^1 + 2^2$ 代祖先，同理，第k代祖先也可以这样表示。

所以有dp[i][j] = dp[dp[i][j-1]][j-1];

其他就是细节部分要注意。

class TreeAncestor {

    int[][] dp;

    public TreeAncestor(int n, int[] parent) {
        // dp[i][j] 表示节点i的第2^j代祖先。
        // j = 0，就是父亲。
        dp = new int[n+5][20];
        // dp[0][0] = 0;
        for(int i = 1; i <= n; i++){
            // 为什么要+1？因为否则会出现-1的索引，那样数组索引就会报错。
            // 注意dp[i]存储的是第i-1的祖宗节点
            dp[i][0] = parent[i -1] + 1;
        }
        for(int j = 1; j < 20; j++){
            for(int i = 0; i <= n; i++){
                dp[i][j] = dp[dp[i][j-1]][j-1];
            }
        }
    }

    public int getKthAncestor(int node, int k) {
        int res = node+1;
        for(int i = 0; i < 20; i++){
            // 测试了两种方法，都可以
            // if(((k >> i) & 1) > 0){
            //     res = dp[res][i];

            // }
            if(((1 << i) & k) > 0){
                res = dp[res][i];

            }
        }
        return res - 1;

    }
}

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

我的公众号:GitKid

暂时每日分享LeetCode，我在不断学习的过程中，公众号也在不断充实，欢迎大家扫码关注。

TODO:《剑指offer》系列

在这里插入图片描述

GitKid

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[算法]LeetCode第193场周赛202006014

第193场周赛202006141480. 一维数组的动态和难度：简单题目描述1给你一个数组 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]解释：动态和计算过程
复制链接

扫一扫