174. 地下城游戏；剑指 Offer 40. 最小的k个数；378. 有序矩阵中第K小的元素；703. 数据流中的第K大元素

一些恶魔抓住了公主（P）并将她关在了地下城的右下角。地下城是由 M x N 个房间组成的二维网格。我们英勇的骑士（K）最初被安置在左上角的房间里，他必须穿过地下城并通过对抗恶魔来拯救公主。

骑士的初始健康点数为一个正整数。如果他的健康点数在某一时刻降至 0 或以下，他会立即死亡。

有些房间由恶魔守卫，因此骑士在进入这些房间时会失去健康点数（若房间里的值为负整数，则表示骑士将损失健康点数）；其他房间要么是空的（房间里的值为 0），要么包含增加骑士健康点数的魔法球（若房间里的值为正整数，则表示骑士将增加健康点数）。

为了尽快到达公主，骑士决定每次只向右或向下移动一步。

 

编写一个函数来计算确保骑士能够拯救到公主所需的最低初始健康点数。

例如，考虑到如下布局的地下城，如果骑士遵循最佳路径 右 -> 右 -> 下 -> 下，则骑士的初始健康点数至少为 7。

 
-2 (K) 
-3 
3 
 
 
-5 
-10 
1 
 
 
10 
30 
-5 (P) 
 

 

 

说明:

    
    骑士的健康点数没有上限。
    
    任何房间都可能对骑士的健康点数造成威胁，也可能增加骑士的健康点数，包括骑士进入的左上角房间以及公主被监禁的右下角房间。

class Solution {
public:
    int calculateMinimumHP(vector<vector<int>>& dungeon) {
        int n = dungeon.size(), m = dungeon[0].size();
        vector<vector<int>> dp(n + 1, vector<int>(m + 1, INT_MAX));
        dp[n][m - 1] = dp[n - 1][m] = 1;
        for (int i = n - 1; i >= 0; --i) {
            for (int j = m - 1; j >= 0; --j) {
                int minn = min(dp[i + 1][j], dp[i][j + 1]);
                dp[i][j] = max(minn - dungeon[i][j], 1);
            }
        }
        return dp[0][0];
    }
};

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。

 

示例 1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]

示例 2：

输入：arr = [0,1,2,1], k = 1
输出：[0]

 

限制：

    0 <= k <= arr.length <= 10000
    0 <= arr[i] <= 10000

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        if(k==0||arr.empty())return{};
        return helper(arr,0,arr.size()-1,k);
    }
    vector<int> helper(vector<int>& v,int low,int high,int k){
        if(low>high)return {};
        int key=v[low],le=low,ri=high;
        while(le<ri){
            while(le<ri&&v[ri]>=key)--ri;
            if(le<ri)v[le++]=v[ri];
            while(le<ri&&v[le]<=key)++le;
            if(le<ri)v[ri--]=v[le];
        }
        v[le]=key;//快排变形
        if(k-1==le)return vector<int>(v.begin(),v.begin()+k);
        else if(k-1<le)return helper(v,low,le-1,k);
        else return helper(v,le+1,high,k);
    }
};

 

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

 

示例：

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

返回 13。

 

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

class Solution {//二分法
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        int le=matrix[0][0],ri=matrix[matrix.size()-1][matrix[0].size()-1];
        while(le<ri){
            int mid=le+((ri-le)>>1);
            if(less(matrix,k,mid))ri=mid;
            else le=mid+1;
        }
        return le;
    }
    bool less(vector<vector<int>>& matrix, int k,int mid){
        int i=matrix.size()-1,j=0,cnt=0;
        while(i>=0&&j<matrix[0].size()){//
            if(mid>=matrix[i][j]){
                cnt+=i+1;
                ++j;
            }
            else --i;
        }
        return k<=cnt;
    }
};

设计一个找到数据流中第K大元素的类（class）。注意是排序后的第K大元素，不是第K个不同的元素。

你的 KthLargest 类需要一个同时接收整数 k 和整数数组nums 的构造器，它包含数据流中的初始元素。每次调用 KthLargest.add，返回当前数据流中第K大的元素。

示例:

int k = 3;
int[] arr = [4,5,8,2];
KthLargest kthLargest = new KthLargest(3, arr);
kthLargest.add(3);   // returns 4
kthLargest.add(5);   // returns 5
kthLargest.add(10);  // returns 5
kthLargest.add(9);   // returns 8
kthLargest.add(4);   // returns 8

说明: 
你可以假设 nums 的长度≥ k-1 且k ≥ 1。

class KthLargest {
    priority_queue<int,vector<int>,greater<int>>q;
    int k;
public:
    KthLargest(int k, vector<int>& nums) {
        this->k=k;
        for(int i=0;i<nums.size();++i){
            if(q.size()<k)
                q.push(nums[i]);
            else//
                if(q.top()<nums[i]){//
                    q.pop();
                    q.push(nums[i]);
                }
            }
    }    
    int add(int val) {
        if(q.size()<k)
            q.push(val);
        else//
            if(q.top()<val){//
                q.pop();
                q.push(val);
            }
        return q.top();
    }
};