LeetCode 1337. 矩阵中战斗力最弱的 K 行

原创

Daylight629 2023-01-31 14:48:22 博主文章分类：LeetCode题解 ©著作权

文章标签 矩阵 leetcode 算法复杂度 i++ 文章分类 虚拟化云计算

©著作权归作者所有：来自51CTO博客作者Daylight629的原创作品，请联系作者获取转载授权，否则将追究法律责任

1337. 矩阵中战斗力最弱的 K 行

给你一个大小为 m * n 的矩阵 mat，矩阵由若干军人和平民组成，分别用 1 和 0 表示。

请你返回矩阵中战斗力最弱的 k 行的索引，按从最弱到最强排序。

如果第 i 行的军人数量少于第 j 行，或者两行军人数量相同但 i 小于 j，那么我们认为第 i 行的战斗力比第 j 行弱。

军人总是排在一行中的靠前位置，也就是说 1 总是出现在 0 之前。

示例 1：

输入：mat = 
[[1,1,0,0,0],
 [1,1,1,1,0],
 [1,0,0,0,0],
 [1,1,0,0,0],
 [1,1,1,1,1]], 
k = 3
输出：[2,0,3]
解释：
每行中的军人数目：
行 0 -> 2 
行 1 -> 4 
行 2 -> 1 
行 3 -> 2 
行 4 -> 5 
从最弱到最强对这些行排序后得到 [2,0,3,1,4]

示例 2：

输入：mat = 
[[1,0,0,0],
 [1,1,1,1],
 [1,0,0,0],
 [1,0,0,0]], 
k = 2
输出：[0,2]
解释： 
每行中的军人数目：
行 0 -> 1 
行 1 -> 4 
行 2 -> 1 
行 3 -> 1 
从最弱到最强对这些行排序后得到 [0,2,3,1]

提示：

m == mat.length
n == mat[i].length
2 <= n, m <= 100
1 <= k <= m
matrix[i][j] 不是 0 就是 1

二、方法一

暴力解法，通过统计，每一行的大小，然后进行排序，输出前k行

class Solution {
    public int[] kWeakestRows(int[][] mat, int k) {
        if (mat == null || mat.length == 0 || mat[0].length == 0 || k == 0) {
            return new int[0];
        }
        int m = mat.length;
        int n = mat[0].length;
        int[][] arr = new int[m][2];
        for (int i = 0; i < m; i++) {
            int cur = 0;
            for (int j = 0; j < n; j++) {
                cur += mat[i][j];
            }
            arr[i] = new int[] {cur, i};
        }
        Arrays.sort(arr, (a, b) ->{
            if (a[0] != b[0]) return a[0] - b[0];
            else return a[1] - b[1];
        });
        int[] res = new int[k];
        for (int i = 0; i < k; i++) {
            res[i] = arr[i][1];
        }
        return res;

    }
}

时间复杂度：遍历矩阵的复杂度为 O(m * n)；排序复杂度为 O*(mlogm)；构造答案复杂度为 O*(k)。整体复杂度为O(max(m∗n,mlogm))
空间复杂度：O(m) 空间用于存储所有的行战力；O(logm) 空间用于排序。整体复杂度为 O(m+logm)

三、方法二

由于军人在前面相当于有序，我们可以通过二分查找，找到最后一个军人的位置，建立一个大根堆，如果当前的值比堆顶大就社群，如果比堆顶小，则弹出堆顶的元素，然后把这个元素加入堆，最后从堆弹出k个组数

class Solution {
    public int[] kWeakestRows(int[][] mat, int k) {
        if (mat == null || mat.length == 0 || mat[0].length == 0 || k == 0) {
            return new int[0];
        }
        int m = mat.length;
        int n = mat[0].length;
       PriorityQueue<int[]> queue = new PriorityQueue<>((a, b) -> {
           if (a[0] != b[0]) return b[0] - a[0];
           else return b[1] - a[1];
       });
       for (int i = 0; i < m; i++) {
           int l = 0;
           int r = n - 1;
           while (l < r) {
               int mid = l + r + 1 >> 1;
               if (mat[i][mid] >= 1) l = mid;
               else  r = mid - 1;
           }
           int cur = mat[i][r] >= 1 ? r + 1 : r;
           if (queue.size() ==k && queue.peek()[0] > cur) queue.poll();
           if (queue.size() < k) queue.add(new int[] {cur, i});
       }
       int[] res = new int[k];
       int index = k - 1;
       while (!queue.isEmpty()) res[index--] = queue.poll()[1];

       return res;

    }
}