Find Kth Largest XOR Coordinate Value

Find Kth Largest XOR Coordinate Value - Problem

Array Divide and Conquer Bit Manipulation Sorting Heap (Priority Queue) Matrix Prefix Sum Quickselect Medium

You are given a 2D matrix of size m x n, consisting of non-negative integers. You are also given an integer k.

The value of coordinate (a, b) of the matrix is the XOR of all matrix[i][j] where 0 <= i <= a < m and 0 <= j <= b < n (0-indexed).

Find the kth largest value (1-indexed) of all the coordinates of matrix.

Input & Output

Example 1 — Basic 2x2 Matrix

$ Input: matrix = [[5,2],[1,6]], k = 1

› Output: 7

💡 Note: Coordinate values: (0,0)=5, (0,1)=5⊕2=7, (1,0)=5⊕1=4, (1,1)=5⊕2⊕1⊕6=2. Sorted: [7,5,4,2]. 1st largest is 7.

Example 2 — Same Matrix, Different k

$ Input: matrix = [[5,2],[1,6]], k = 2

› Output: 5

💡 Note: Same coordinate values [7,5,4,2]. 2nd largest is 5.

Example 3 — Single Row Matrix

$ Input: matrix = [[1,0,3,2]], k = 3

› Output: 2

💡 Note: Coordinate values: (0,0)=1, (0,1)=1⊕0=1, (0,2)=1⊕0⊕3=2, (0,3)=1⊕0⊕3⊕2=0. Sorted: [2,1,1,0]. 3rd largest is 1.

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 1000
0 ≤ matrix[i][j] ≤ 10⁶
1 ≤ k ≤ m * n

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 M Microsoft 22

The key insight is to use 2D prefix XOR arrays to calculate coordinate values efficiently in O(1) time. The optimal approach builds the prefix array in O(mn) time, then collects and sorts all coordinate values. Time: O(mn log(mn)), Space: O(mn). For small k values, a heap-based approach can be more efficient.

Common Approaches

✓ Brute Force with Direct XOR Calculation

⏱️ Time: O(m²n² + mn log(mn)) Space: O(mn)

For each coordinate (i,j), calculate the XOR of all elements from (0,0) to (i,j) by iterating through the submatrix. Store all values and sort to find the kth largest.

Heap-based Selection (QuickSelect Alternative)

⏱️ Time: O(mn + mn log k) Space: O(mn + k)

Build the prefix XOR array first, then use a min-heap of size k to track the k largest values seen so far. This avoids sorting all mn values when k is small.

Optimized with 2D Prefix XOR

⏱️ Time: O(mn + mn log(mn)) Space: O(mn)

Create a 2D prefix XOR array where prefix[i][j] represents XOR of all elements from (0,0) to (i,j). This allows O(1) lookup for any coordinate value, then collect all values and sort to find kth largest.

Brute Force with Direct XOR Calculation — Algorithm Steps

Iterate through each coordinate (i,j)
For each coordinate, calculate XOR of submatrix from (0,0) to (i,j)
Store all coordinate values
Sort values in descending order
Return kth element

Visualization

Tap to expand

Step-by-Step Walkthrough

For Each Coordinate

Visit each position (i,j) in the matrix

Calculate XOR

XOR all elements from (0,0) to (i,j)

Sort and Find Kth

Sort all values and return kth largest

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a); // Descending order
}

int solution(int matrix[100][100], int m, int n, int k) {
    int values[10000];
    int count = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int xorVal = 0;
            for (int x = 0; x <= i; x++) {
                for (int y = 0; y <= j; y++) {
                    xorVal ^= matrix[x][y];
                }
            }
            values[count++] = xorVal;
        }
    }
    
    qsort(values, count, sizeof(int), compare);
    return values[k - 1];
}

int main() {
    int matrix[100][100];
    int m = 0, n = 0;
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple matrix parsing
    char *ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            n = 0;
            while (*ptr && *ptr != ']') {
                matrix[m][n++] = strtol(ptr, &ptr, 10);
                if (*ptr == ',') ptr++;
            }
            if (*ptr == ']') ptr++;
            m++;
        } else {
            ptr++;
        }
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(matrix, m, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n² + mn log(mn))

O(mn) coordinates × O(mn) XOR calculation + O(mn log(mn)) sorting

⚠ Quadratic Growth

Space Complexity

O(mn)

Array to store all mn coordinate values

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

854 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Direct XOR Calculation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler