leetcode378. 有序矩阵中第K小的元素/二分查找，堆

题目：378. 有序矩阵中第K小的元素

给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。
请注意，它是排序后的第 k 小元素，而不是第 k 个不同的元素。

示例：

matrix = [
   [ 1,  5,  9],
   [10, 11, 13],
   [12, 13, 15]
],
k = 8,

返回 13。
1
2
3
4
5
6
7
8

提示：
你可以假设 k 的值永远是有效的，1 ≤ k ≤ n2 。

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

基本思想1：优先队列(没有用到元素有序这个条件)

class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        priority_queue<int, vector<int>, greater<int>> pq;
        for(int i = 0; i < matrix.size(); ++i){
            for(int j = 0; j < matrix[0].size(); ++j){
                pq.push(matrix[i][j]);
            }
        }
        k--;
        while(k--){
            pq.pop();
        }
        return pq.top();
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

基本思想2：归并排序(只利用到矩阵的列是有序的)

借助优先队列进行归并排序，取排在第k个位置的元素。

struct num{
    int x, y, val;
    num(int a, int b, int c): x(a), y(b), val(c){}
    bool operator<(num a) const{
        return val > a.val;
    }
};
class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        priority_queue<num> pq;
        for(int i = 0; i < matrix.size(); ++i){
            pq.push({i, 0, matrix[i][0]});
        }
        for(int i = 0; i < k - 1; ++i){
            auto t = pq.top();
            pq.pop();
            if(t.y != matrix[0].size() - 1){
                pq.push({t.x, t.y + 1, matrix[t.x][t.y + 1]});
            }
        }
        return pq.top().val;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

基本思想3：二分查找

注意到这个二维矩阵满足：左上角的元素都是大于右下角的元素，可以将整个矩阵作为一个整体进行二分查找。

• 初始边界：矩阵的最大值（右下角的值）和矩阵的最小值（左上角的值）
• 统计中间值左面元素（不大于中间值）的个数cnt，从左下角开始统计
• 边界移动的条件：
  cnt 小于 k 说明第k小的在右半部分
  否则在左半部分

写法一：

class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        //二分查找
        int n = matrix.size();//n*n的矩阵
        int left = matrix[0][0], right = matrix[n - 1][n - 1];
        while(left < right){
            int mid = left + ((right - left) >> 1);
            if(count(matrix, mid, k)){//左侧的元素个数少于k个
                left = mid + 1;
            }
            else{
                right = mid;//右边界可能成为答案
            }
        }
        return left;
    }
    bool count(vector<vector<int>>& matrix, int mid, int k){
        int n = matrix.size();
        int i = n - 1, j = 0;
        int cnt = 0;
        while(i >= 0 && j < n){
            if(matrix[i][j] <= mid){
                cnt += i + 1;
                ++j;
            }
            else{
                --i;
            }
        }
        return cnt < k;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

写法二：

class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        //二分查找
        int n = matrix.size();//n*n的矩阵
        int left = matrix[0][0], right = matrix[n - 1][n - 1];
        while(left < right){
            int mid = left + ((right - left + 1) >> 1);//取偏右的
            if(count(matrix, mid, k)){//左侧的元素个数少于k个
                left = mid;//左边界可能成为答案
            }
            else{
                right = mid - 1;
            }
        }
        return left;
    }
    bool count(vector<vector<int>>& matrix, int mid, int k){
        int n = matrix.size();
        int i = n - 1, j = 0;
        int cnt = 0;
        while(i >= 0 && j < n){
            if(matrix[i][j] < mid){//这里和写法一不一样
                cnt += i + 1;
                ++j;
            }
            else{
                --i;
            }
        }
        return cnt < k;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33