leetcode每周.周赛第284场周赛 理想汽车专场 ~ 暴力模拟思维考察

📖本篇内容：leetcode每周.周赛第284场周赛 理想汽车专场 ~ 暴力模拟思维考察

📑 文章专栏：leetcode周赛打卡《周周打卡》

📆 最近更新：2022年3月 6日 leetcode每周.周赛第282场周赛 葡萄城专场 ~简单模拟 + 哈希表的应用 + 排序二分缩小范围求最值

🙊个人简介：一只二本院校在读的大三程序猿，本着注重基础，打卡算法，分享技术作为个人的经验总结性的博文博主，虽然可能有时会犯懒，但是还是会坚持下去的，如果你很喜欢博文的话，建议看下面一行~（疯狂暗示QwQ）

🌇 点赞 👍 收藏 ⭐留言 📝 一键三连 _{关爱程序猿，从你我做起}

🙊写在前面

🙊小付来喽，今天接着有更新周赛栏目了哦，今天的小付是在学校打的第二把周赛，菜鸡本鸡，深处重庆的崽子们都要开始做核酸了，据说打周赛的时候，学校的队伍已经排到了我们宿舍这条gai上了。

📆第284场周赛——2022-03-13

📝T1.6031. 找出数组中的所有 K 近邻下标

题目

给你一个下标从 0 开始的整数数组 nums 和两个整数 key 和 k 。K 近邻下标 是 nums 中的一个下标 i ，并满足至少存在一个下标 j 使得 |i - j| <= k 且 nums[j] == key 。

以列表形式返回按 递增顺序 排序的所有 K 近邻下标。

示例

示例1：

输入：nums = [3,4,9,1,3,9,5], key = 9, k = 1
输出：[1,2,3,4,5,6]
解释：因此，nums[2] == key 且 nums[5] == key 。
- 对下标 0 ，|0 - 2| > k 且 |0 - 5| > k ，所以不存在 j 使得 |0 - j| <= k 且 nums[j] == key 。所以 0 不是一个 K 近邻下标。
- 对下标 1 ，|1 - 2| <= k 且 nums[2] == key ，所以 1 是一个 K 近邻下标。
- 对下标 2 ，|2 - 2| <= k 且 nums[2] == key ，所以 2 是一个 K 近邻下标。
- 对下标 3 ，|3 - 2| <= k 且 nums[2] == key ，所以 3 是一个 K 近邻下标。
- 对下标 4 ，|4 - 5| <= k 且 nums[5] == key ，所以 4 是一个 K 近邻下标。
- 对下标 5 ，|5 - 5| <= k 且 nums[5] == key ，所以 5 是一个 K 近邻下标。
- 对下标 6 ，|6 - 5| <= k 且 nums[5] == key ，所以 6 是一个 K 近邻下标。
因此，按递增顺序返回 [1,2,3,4,5,6] 。 

示例2：

输入：nums = [2,2,2,2,2], key = 2, k = 2
输出：[0,1,2,3,4]
解释：对 nums 的所有下标 i ，总存在某个下标 j 使得 |i - j| <= k 且 nums[j] == key ，所以每个下标都是一个 K 近邻下标。 
因此，返回 [0,1,2,3,4] 。

⭐思路 ⭐

本题思路以及考察点：

• 这是一道简单的模拟题（签到题）：根据示例，我们很容易想到用 Set 存储我们的数组中每个与 key 值相等的下标位置。然后根据每个值等下标进行模拟 i 与 j，符合条件的就加入结果。

代码实现

常规解法

class Solution {
    public List<Integer> findKDistantIndices(int[] nums, int key, int k) {
        List<Integer> res = new ArrayList<>();
        Set<Integer> set = new HashSet<>();
        int n = nums.length;
        // 将值等下标加入set 
        for (int i = 0 ; i < n;i++){
            if (nums[i] == key)set.add(i);
        }
    	// 模拟
        for (int i = 0 ; i< n;i++){
            for (int j : set){
            	// 对当前值等下标进行 绝对值差 判断是否符合条件 <=k 如果符合条件就将其加入结果 
                if (Math.abs(i-j) <= k){
                    res.add(i);
                    break;
                }
            }       
        }
        return res;
    }
}

流式去重 + 集合排序 + 暴力模拟

class Solution {
    public List<Integer> findKDistantIndices(int[] nums, int key, int k) {
        List<Integer> res = new ArrayList<>();
        Set<Integer> set = new HashSet<>();
        int n = nums.length;
        for (int i = 0 ; i < n;i++){
            if (nums[i] == key)set.add(i);
        }
    
        for (int j : set) {
            for (int i = 0 ; i< n;i++){
                if (Math.abs(i-j) <= k)res.add(i);
            }
        }
        // 流式去重
        res = res.stream().distinct().collect(Collectors.toList());
        // 集合排序
        Collections.sort(res);
        return res;
    }
}

执行结果

流式去重 + 集合排序 + 暴力模拟

📝T2. 5203. 统计可以提取的工件

题目

存在一个 n x n 大小、下标从 0 开始的网格，网格中埋着一些工件。给你一个整数 n 和一个下标从 0 开始的二维整数数组 artifacts ，artifacts 描述了矩形工件的位置，其中 artifacts[i] = [r1i, c1i, r2i, c2i] 表示第 i 个工件在子网格中的填埋情况：

(r1i, c1i) 是第 i 个工件 左上 单元格的坐标，且
(r2i, c2i) 是第 i 个工件 右下 单元格的坐标。
你将会挖掘网格中的一些单元格，并清除其中的填埋物。如果单元格中埋着工件的一部分，那么该工件这一部分将会裸露出来。如果一个工件的所有部分都都裸露出来，你就可以提取该工件。

给你一个下标从 0 开始的二维整数数组 dig ，其中 dig[i] = [ri, ci] 表示你将会挖掘单元格 (ri, ci) ，返回你可以提取的工件数目。

生成的测试用例满足：

不存在重叠的两个工件。
每个工件最多只覆盖 4 个单元格。
dig 中的元素互不相同。

示例

示例1：

输入：n = 2, artifacts = [[0,0,0,0],[0,1,1,1]], dig = [[0,0],[0,1]]
输出：1
解释： 
不同颜色表示不同的工件。挖掘的单元格用 'D' 在网格中进行标记。
有 1 个工件可以提取，即红色工件。
蓝色工件在单元格 (1,1) 的部分尚未裸露出来，所以无法提取该工件。
因此，返回 1 。

示例2：

输入：n = 2, artifacts = [[0,0,0,0],[0,1,1,1]], dig = [[0,0],[0,1],[1,1]]
输出：2
解释：红色工件和蓝色工件的所有部分都裸露出来（用 'D' 标记），都可以提取。因此，返回 2 。 

提示

• 1 <= n <= 1000
• 1 <= artifacts.length, dig.length <= min(n2, 105)
• artifacts[i].length == 4
• dig[i].length == 2
• 0 <= r1i, c1i, r2i, c2i, ri, ci <= n - 1
• r1i <= r2i
• c1i <= c2i
• 不存在重叠的两个工件
• 每个工件 最多 只覆盖 4 个单元格
• dig 中的元素互不相同

⭐思路 ⭐

本题思路以及考察点：

• 这题的难点在于读懂题，读这个题用了好久的说，由题可知，我们需要在网格中去挖工件，挖工件的区域中，当该工件完全暴露，（即在所有给定的区域范围中都可以进行挖掘，则说明该工件符合条件，全部部分都被暴露可以挖掘）那么符合条件的工件就可以+1 ，反之该工件就无法进行挖掘，判断下一个区域范围的工件能否全部暴露进行挖掘。
• 暴力模拟

代码实现

class Solution {
    public int digArtifacts(int n, int[][] artifacts, int[][] dig) {
        int res = 0;
        int[][] grid = new int[n][n];
        for(int i = 0; i < dig.length; i++){
            // 能挖取的格子
            grid[dig[i][0]][dig[i][1]] = 1;
        }

        for(int i = 0; i < artifacts.length; i++){
            // 分别记录挖取区间
            int r1 = artifacts[i][0];
            int c1 = artifacts[i][1];
            int r2 = artifacts[i][2];
            int c2 = artifacts[i][3];
            // 默认认为它当前区域的工件所有部分都暴露出来 都可以挖掘
            boolean isAllExposed = false;
            // 在挖取区间是否能把它挖出来
            for(int j = r1; j <= r2; j++)
                for(int k = c1; k <= c2; k++){
                    // 如果遇到这个区间中的一个工件无法提取那么他所暴露出来的部分就不完整 因为不是所有部分都被暴露所以该工件不能被提取
                    if(grid[j][k] != 1)
                        isAllExposed=true;
                }
            // 如果工件所有部分都被暴露出来 那说明可以被提取 那么他的提取工件数量就会+1，反之就无法提取该工件判断下一个工件，结果不变
            res = isAllExposed ? res : res + 1;
        }
        return res;
    }
}

执行结果

🙊写在最后

小付打卡的第10场单周赛 2022-03-13

尽可能把会做的题 都做好 就可以了

本次周赛 对了两道题

T3没看 重庆的崽子们要做核算 中午吃饭前就去排队啦

所以还是很不错的周赛体验

最后

每天进步点 每天收获点

愿诸君 事业有成 学有所获

如果觉得不错 别忘啦一键三连哦~