有序矩阵中的第 k 个最小数组和

给你一个 m * n 的矩阵 mat，以及一个整数 k ，矩阵中的每一行都以非递减的顺序排列。

你可以从每一行中选出 1 个元素形成一个数组。返回所有可能数组中的第 k 个 最小 数组和。

示例 1：

输入：mat = [[1,3,11],[2,4,6]], k = 5

输出：7

解释：从每一行中选出一个元素，前 k 个和最小的数组分别是：

[1,2], [1,4], [3,2], [3,4], [1,6]。其中第 5 个的和是 7 。  

示例 2：

输入：mat = [[1,3,11],[2,4,6]], k = 9

输出：17

示例 3：

输入：mat = [[1,10,10],[1,4,5],[2,3,6]], k = 7

输出：9

解释：从每一行中选出一个元素，前 k 个和最小的数组分别是：

[1,1,2], [1,1,3], [1,4,2], [1,4,3], [1,1,6], [1,5,2], [1,5,3]。其中第 7 个的和是 9 。 

示例 4：

输入：mat = [[1,1,10],[2,2,9]], k = 7

输出：12

说明：

m ，n为矩阵 mat的行列数

1 <= m, n <= 40

1 <= k <= min(200, n ^ m)

1 <= mat[i][j] <= 5000

mat[i] 是一个非递减数组

输入说明 :

首先输入矩阵mat的行列数m和n

然后输入m行，每行n个非负整数，表示mat的元素值，以空格分隔。

最后输入k。

输出说明 :

输出一个整数，表示结果。

输入范例 :

2 3
1 3 11
2 4 6
5

输出范例 :

 7

#include<iostream>
#include<map>
#include<queue>
#include<set>
#include<vector>
#include<algorithm>
using namespace std;
class Solution {
public:
    //使用小顶堆 小顶堆中存储每列选的元素的坐标和加和
    //每次将最小的取出 当第k次取时即为答案
    //每次取出后 被选的元素的坐标依次加一
    struct Cell
    {
        int sum;
        vector<int> indexs;
        Cell(int _sum, vector<int>_v) :sum(_sum), indexs(_v) {};
        bool operator <(const Cell& c)const
        {
            return sum > c.sum;
        }
    };
    int kthSmallest(vector<vector<int>>& mat, int k) {
        priority_queue<Cell> pq;
        int n = mat.size(), m = mat[0].size();
        vector<int> indexs(n, 0);
        int sum = 0;
        for (int i = 0; i < n; i++)sum += mat[i][0];
        set<vector<int>> indexs_set;
        indexs_set.insert(indexs);
        pq.push({ sum, indexs });
        while (k--)
        {
            Cell c = pq.top();
            if (!k)return c.sum;
            pq.pop();
            for (int i = 0; i < n; i++)
            {
                indexs.assign( c.indexs.begin(),c.indexs.end());
                if (indexs[i] + 1 < m)
                {
                    indexs[i] += 1;
                    if (indexs_set.find(indexs) == indexs_set.end())
                    {
                        pq.push({ c.sum - mat[i][indexs[i] - 1] + mat[i][indexs[i]],indexs });
                        indexs_set.insert(indexs);
                    }  
                }
            }
        }
        return 0;
    }
    //动态规划 使用一个数组last_row记录之前所有的行 的最小数组和
    //然后使用新增加的行的每一个值 都加上last_row的值 然后排序 取前k个
    //o(n(mk+mklogmk))
    /*int kthSmallest(vector<vector<int>>& mat, int k) {
        vector<int> last_row = { 0 };
        vector<int> temp_row;
        for (int i = 0; i < mat.size(); i++)
        {
           // print_v(last_row);
            for (int j = 0; j < mat[0].size(); j++)
            {
                for (int p = 0; p < last_row.size(); p++)
                {
                    temp_row.push_back(last_row[p] + mat[i][j]);
                }
            }
            sort(temp_row.begin(),temp_row.end());
            //print_v(temp_row);
            if (temp_row.size() > k)
                last_row.assign(temp_row.begin(), temp_row.begin() + k);
            else
                last_row.assign(temp_row.begin(), temp_row.end());
            temp_row.resize(0);
        }
        return last_row[k - 1];
    }*/
};
int main()
{
    int m, n, data, k;
    vector<vector<int> > mat;
    cin >> m >> n;
    for (int i = 0; i < m; i++)
    {
        vector<int> row;
        for (int j = 0; j < n; j++)
        {
            cin >> data;
            row.push_back(data);
        }
        mat.push_back(row);
    }
    cin >> k;
    int res = Solution().kthSmallest(mat, k);
    cout << res << endl;
    return 0;
}