LeetCode 1984. 学生分数的最小差值 / 1020. 飞地的数量 / 1189. “气球” 的最大数量

1984. 学生分数的最小差值

2022.2.11 每日一题

题目描述

给你一个 下标从 0 开始 的整数数组 nums ，其中 nums[i] 表示第 i 名学生的分数。另给你一个整数 k 。

从数组中选出任意 k 名学生的分数，使这 k 个分数间 最高分 和 最低分 的 差值 达到 最小化 。

返回可能的 最小差值 。

示例 1：

输入：nums = [90], k = 1
输出：0
解释：选出 1 名学生的分数，仅有 1 种方法：
-[90] 最高分和最低分之间的差值是 90 - 90 = 0
可能的最小差值是 0

示例 2：

输入：nums = [9,4,1,7], k = 2
输出：2
解释：选出 2 名学生的分数，有 6 种方法：
-[9,4,1,7] 最高分和最低分之间的差值是 9 - 4 = 5
-[9,4,1,7] 最高分和最低分之间的差值是 9 - 1 = 8
-[9,4,1,7] 最高分和最低分之间的差值是 9 - 7 = 2
-[9,4,1,7] 最高分和最低分之间的差值是 4 - 1 = 3
-[9,4,1,7] 最高分和最低分之间的差值是 7 - 4 = 3
-[9,4,1,7] 最高分和最低分之间的差值是 7 - 1 = 6
可能的最小差值是 2

提示：

1 <= k <= nums.length <= 1000
0 <= nums[i] <= 10^5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-difference-between-highest-and-lowest-of-k-scores
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

排序，滑动窗口

class Solution {
    public int minimumDifference(int[] nums, int k) {
        Arrays.sort(nums);
        int l = nums.length;
        int min = Integer.MAX_VALUE;
        for(int i = 0; i < l - k + 1; i++){
            min = Math.min(nums[i + k - 1] - nums[i], min);
        }
        return min;
    }
}

1020. 飞地的数量

2022.2.12 每日一题

题目描述

给你一个大小为 m x n 的二进制矩阵 grid ，其中 0 表示一个海洋单元格、1 表示一个陆地单元格。

一次 移动 是指从一个陆地单元格走到另一个相邻（上、下、左、右）的陆地单元格或跨过 grid 的边界。

返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。

示例 1：

输入：grid = [[0,0,0,0],[1,0,1,0],[0,1,1,0],[0,0,0,0]]
输出：3
解释：有三个 1 被 0 包围。一个 1 没有被包围，因为它在边界上。

示例 2：

输入：grid = [[0,1,1,0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]
输出：0
解释：所有 1 都在边界上或可以到达边界。

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 500
grid[i][j] 的值为 0 或 1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-enclaves
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

class Solution {
    int m;
    int n;
    int[][] grid;
    int[][] dir = {{0,1}, {0,-1}, {-1, 0}, {1, 0}};
    
    public int numEnclaves(int[][] grid) {
        //其实第一反应想到的是并查集，看来又得被动复习一波了
        //深度的话简单
        //广度其实也同理
        //从边界出发把能遍历到的全部标为2

        m = grid.length;
        n = grid[0].length;
        this.grid = grid;
        int res = 0;
        for(int i = 0; i < m; i++){
            if(grid[i][0] == 1){
                grid[i][0] = 2;
                dfs(i, 0);
            }
            if(grid[i][n - 1] == 1){
                grid[i][n - 1] = 2;
                dfs(i, n - 1);
            }
        }
        for(int j = 1; j < n - 1; j++){
            if(grid[0][j] == 1){
                grid[0][j] = 2;
                dfs(0, j);
            }
            if(grid[m - 1][j] == 1){
                grid[m - 1][j] = 2;
                dfs(m - 1, j);
            }
        }

        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                if(grid[i][j] == 1)
                    res++;
            }
        }
        return res;
    }

    //标志是否在边界
    public void dfs(int i, int j){
        for(int[] d :dir){
            int x = i + d[0];
            int y = j + d[1];
            if(x < 0 || x >= m || y < 0 || y >= n || grid[x][y] != 1)
                continue;
            grid[x][y] = 2;
            dfs(x, y);
        }
    }
}

1189. “气球” 的最大数量

2022.2.13 每日一题

题目描述

给你一个字符串 text，你需要使用 text 中的字母来拼凑尽可能多的单词 “balloon”（气球）。

字符串 text 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 “balloon”。

示例 1：

输入：text = “nlaebolko”
输出：1

示例 2：

输入：text = “loonbalxballpoon”
输出：2

示例 3：

输入：text = “leetcode”
输出：0

提示：

1 <= text.length <= 10^4
text 全部由小写英文字母组成

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-number-of-balloons
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

class Solution {
    public int maxNumberOfBalloons(String text) {
        int b = 0, a = 0, l = 0, o = 0, n = 0;
        int res = 0;
        for(char c : text.toCharArray()){
            if(c == 'a')
                a++;
            else if(c == 'b')
                b++;
            else if(c == 'o')
                o++;
            else if(c == 'l')
                l++;
            else if(c == 'n')
                n++;
        }
        l /= 2;
        o /= 2;
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        pq.offer(a);
        pq.offer(b);
        pq.offer(l);
        pq.offer(o);
        pq.offer(n);
        return pq.poll();
    }
}