leetcode.1738. 找出第 K 大的异或坐标值---利用dp得到二维前缀异或

1738. 找出第 K 大的异或坐标值

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

矩阵中坐标 (a, b) 的 值 可由对所有满足 0 <= i <= a < m 且 0 <= j <= b < n 的元素 matrix[i][j]（下标从 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 大的值。
 

提示：

m == matrix.length
n == matrix[i].length
1 <= m, n <= 1000
0 <= matrix[i][j] <= 106
1 <= k <= m * n

题解：

我们使用二维前缀异或+排序即可解题。
怎么求二维前缀异或呢？
一维前缀异或是很简单的，使用一层for加上一些dp的思想即可得到，对于二维，不过是在维度上对一维进行了扩展，本质上还是一维的思想。
即我们设hash[i][j]为从原点到坐标为（i-1,j-1）的数的总异或，那么我们利用dp思想可以得到：
hash[i][j] = hash[i-1][j-1] ^ hash[i-1][j] ^ hash[i][j-1] ^ matrix[i-1][j-1];

其思路为：

hash[i-1][j-1]为从原点到坐标（i-2,j-2）的总异或，其对于hash[i][j]还差matrix[i-1][j-1]对应的左边及上边的数，而我们使用 hash[i-1][j] ^ hash[i][j-1] 可以发现，他们包括了我们想要的“左边及上边的数”，并且由于他们其实也都包括了hash[i-1][j-1]，所以由于位运算的性质，两个都有异或后为0，所以可以起到剔除相同的元素作用，因此dp方程可以得到。

代码(c语言)：

int cmp(int*_x,int*_y){
    return *_x>*_y;
}
int kthLargestValue(int** matrix, int matrixSize, int* matrixColSize, int k){
    int m = matrixSize;
    int n = *matrixColSize;
    int hash[m+1][n+1];
    memset(hash,0,sizeof(hash));
    int res[m*n];
    int top = 0;

    for(int i=1;i<=m;i++){
        for(int j=1;j<=n;j++){
            hash[i][j] = hash[i-1][j-1] ^ hash[i-1][j] ^ hash[i][j-1] ^ matrix[i-1][j-1];
            res[top++] = hash[i][j];
        }
    }

    qsort(res,top,sizeof(int),cmp);
    return res[m*n-k];
}

代码（Java）:

class Solution {
    public int kthLargestValue(int[][] matrix, int k) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] hash = new int[m+1][n+1];
        int[] res = new int[m*n];
        int top = 0;

        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                hash[i][j] = hash[i-1][j-1] ^ hash[i-1][j] ^ hash[i][j-1] ^ matrix[i-1][j-1];
                res[top++] = hash[i][j];
            }
        }

        Arrays.sort(res);
        return res[m*n-k];
    }
}