给你一个二维矩阵 matrix 和一个整数 k ，矩阵大小为 m x n 由非负整数组成。

矩阵中坐标 (a, b) 的 目标值 可以通过对所有元素 matrix[i][j] 执行异或运算得到，其中 i 和 j 满足 0 <= i <= a < m 且 0 <= j <= b < n（下标从 0 开始计数）。

请你找出 matrix 的所有坐标中第 k 大的目标值（k 的值从 1 开始计数）。

示例 1：

输入：matrix = [[5,2],[1,6]], k = 1
输出：7
解释：坐标 (0,1) 的目标值是 5 XOR 2 = 7 ，为最大的目标值。
示例 2：

输入：matrix = [[5,2],[1,6]], k = 2
输出：5
解释：坐标 (0,0) 的目标值是 5 = 5 ，为第 2 大的目标值。
示例 3：

输入：matrix = [[5,2],[1,6]], k = 3
输出：4
解释：坐标 (1,0) 的目标值是 5 XOR 1 = 4 ，为第 3 大的目标值。
示例 4：

输入：matrix = [[5,2],[1,6]], k = 4
输出：0
解释：坐标 (1,1) 的目标值是 5 XOR 2 XOR 1 XOR 6 = 0 ，为第 4 大的目标值。

二位前缀和

class Solution {
public:
    int kthLargestValue(vector<vector<int>>& matrix, int k) {
        int m = matrix.size(), n = matrix[0].size();
        vector<vector<int>> pre(m+1, vector<int>(n+1));
        vector<int> result;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                pre[i+1][j+1] = pre[i+1][j] ^ pre[i][j+1] ^ pre[i][j] ^ matrix[i][j];
                result.push_back(pre[i+1][j+1]);
            }
        }

        sort(result.begin(), result.end(),greater<int>());  //从大到小
        return result[k-1];
    }
};

时间复杂度：O(mnlog(mn))。计算二维前缀和的时间复杂度为 O(mn)，排序的时间复杂度为 O(mnlog(mn))，因此总时间复杂度为 O(mnlog(mn))。

空间复杂度：O(mn)，即为存储二维前缀和需要的空间。

计算异或前缀和和计算加法前缀和类似，维护一个二维数组pre，将前缀异或和储存在里面，然后进行排序，return[k-1]即可。
需要注意的是sort中的greater代表从大到小排序，less代表从小到大排序。

优化

class Solution {
public:
    int kthLargestValue(vector<vector<int>>& matrix, int k) {
        int m = matrix.size(), n = matrix[0].size();
        vector<vector<int>> pre(m+1, vector<int>(n+1));
        vector<int> result;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                pre[i+1][j+1] = pre[i+1][j] ^ pre[i][j+1] ^ pre[i][j] ^ matrix[i][j];
                result.push_back(pre[i+1][j+1]);
            }
        }

        nth_element(result.begin(), result.begin() + k - 1, result.end(), greater<int>());  //从大到小
        return result[k-1];
    }
};

时间复杂度：O(mn)。计算二维前缀和的时间复杂度为 O(mn)，快速选择找出第 k 大的元素的期望时间复杂度为 O(mn)，最坏情况下时间复杂度为 O((mn) ^2 )，因此总时间复杂度为 O(mn)。

空间复杂度：O(mn)，即为存储二维前缀和需要的空间。

由于sort排序对result所有元素进行排序，实际上我们只需要排序前k大个元素即可，所以可以使用nth_element排序进行优化，仅对结果中的前 k 大元素进行部分排序。

---

nth_element利用类似快排的分区步骤来找出第k大或第k小的元素。
分区算法 将数组分为两部分：一部分大于或等于枢轴，一部分小于枢轴。

分区算法
选择枢轴（pivot）：
通常从数组中随机选择一个元素作为枢轴，也可以选择第一个元素、最后一个元素或中间的元素。
例如，我们选择 pivot = results[right]，其中 right 是当前处理的区间的最后一个索引。
初始化指针：

定义两个指针，一个从左边开始（i），一个从右边开始（j），用于遍历和比较数组中的元素。
例如：i = left - 1，j = left，其中 left 和 right 是当前处理的区间。

分区操作：
遍历数组，将比枢轴小的元素移到左边，大的元素移到右边：
从左向右扫描数组，当 results[j] 大于等于枢轴时，i 增加并交换 results[i] 和 results[j]。
继续这个过程，直到所有元素都被处理完。
最后，将枢轴元素与分区位置 i+1 处的元素交换，从而确保左边的所有元素都大于或等于枢轴，右边的所有元素都小于或等于枢轴。