Find Kth Largest XOR Coordinate Value - Practice Coding Problems

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 containing non-negative integers, along with an integer k. Your task is to find the kth largest XOR coordinate value in the matrix.

The coordinate value at position (a, b) is defined as the XOR of all elements in the submatrix from (0, 0) to (a, b) inclusive. In other words, it's the XOR of all matrix[i][j] where 0 ≤ i ≤ a and 0 ≤ j ≤ b.

For example, if we have a 3x3 matrix, there are 9 coordinate values (one for each position), and you need to find the kth largest among these values.

Goal: Return the kth largest coordinate value (1-indexed) among all possible coordinate positions in the matrix.

Input & Output

example_1.py — Basic Example

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

› Output: 7

💡 Note: Coordinate values are: (0,0)=5, (0,1)=5⊕2=7, (1,0)=5⊕1=4, (1,1)=5⊕2⊕1⊕6=2. The largest value is 7.

example_2.py — Larger Matrix

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

› Output: 4

💡 Note: All coordinate values: [5,7,4,4,2,0]. Sorted descending: [7,5,4,4,2,0]. The 3rd largest is 4.

example_3.py — Single Element

$ Input: matrix = [[10]], k = 1

› Output: 10

💡 Note: Only one coordinate (0,0) with value 10, so the 1st largest is 10.

Visualization

Tap to expand

Understanding the Visualization

Understand the Problem

Each coordinate (a,b) has a value = XOR of all elements from (0,0) to (a,b)

Build Prefix XOR

Use 2D prefix XOR where prefixXor[i][j] = XOR of all elements from (0,0) to (i,j)

Apply XOR Properties

Use formula: prefixXor[i][j] = matrix[i][j] ⊕ prefixXor[i-1][j] ⊕ prefixXor[i][j-1] ⊕ prefixXor[i-1][j-1]

Track K Largest

Use min heap to efficiently maintain only the k largest coordinate values

Return Result

The top of the min heap is the kth largest value

Key Takeaway

🎯 Key Insight: XOR prefix sums combined with min heap optimization gives us the most efficient solution, especially when k is much smaller than the total number of coordinates.

Time & Space Complexity

Time Complexity

⏱️

O(mn log k)

O(mn) to build prefix XOR matrix, O(log k) for each heap operation, total O(mn log k)

⚡ Linearithmic

Space Complexity

O(mn + k)

O(mn) for prefix XOR matrix, O(k) for the min heap

⚡ Linearithmic Space

Constraints

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

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses prefix XOR technique to efficiently calculate all coordinate values in O(mn) time, combined with a min heap of size k to track only the k largest values. This avoids sorting all mn values and achieves O(mn log k) time complexity, which is much better than O(mn log(mn)) when k is small.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix XOR + Min Heap (Optimal)	O(mn log k)	O(mn + k)	Build prefix XOR matrix while maintaining a min heap of size k to track the k largest values efficiently
Prefix XOR + Sorting	O(mn + mn log(mn))	O(mn)	Use prefix XOR to efficiently calculate all coordinate values, then sort to find kth largest

Prefix XOR + Min Heap (Optimal) — Algorithm Steps

Initialize a min heap of size k
Build prefix XOR matrix row by row
For each coordinate value calculated:
- If heap size < k, add the value
- If heap size = k and current value > heap top, remove heap top and add current value
Return the top of the heap (kth largest)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Heap

Start with empty min heap of capacity k

Process Values

For each coordinate value calculated

Heap Management

If heap size < k, add value. If value > heap minimum, replace minimum

Maintain K Largest

Heap always contains the k largest values seen so far

Return Minimum

The minimum in the heap is the kth largest overall

Code -

solution.c — C

typedef struct {
    int* data;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = malloc(sizeof(MinHeap));
    heap->data = malloc(capacity * sizeof(int));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(MinHeap* heap, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (heap->data[idx] >= heap->data[parent]) break;
        swap(&heap->data[idx], &heap->data[parent]);
        idx = parent;
    }
}

void heapifyDown(MinHeap* heap, int idx) {
    while (true) {
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        int smallest = idx;
        
        if (left < heap->size && heap->data[left] < heap->data[smallest])
            smallest = left;
        if (right < heap->size && heap->data[right] < heap->data[smallest])
            smallest = right;
        
        if (smallest == idx) break;
        swap(&heap->data[idx], &heap->data[smallest]);
        idx = smallest;
    }
}

void push(MinHeap* heap, int val) {
    heap->data[heap->size++] = val;
    heapifyUp(heap, heap->size - 1);
}

int pop(MinHeap* heap) {
    int min = heap->data[0];
    heap->data[0] = heap->data[--heap->size];
    heapifyDown(heap, 0);
    return min;
}

int kthLargestValue(int** matrix, int matrixSize, int* matrixColSize, int k) {
    int m = matrixSize, n = matrixColSize[0];
    int** prefixXor = malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        prefixXor[i] = malloc(n * sizeof(int));
    }
    
    MinHeap* minHeap = createHeap(k);
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Calculate prefix XOR
            prefixXor[i][j] = matrix[i][j];
            if (i > 0) prefixXor[i][j] ^= prefixXor[i-1][j];
            if (j > 0) prefixXor[i][j] ^= prefixXor[i][j-1];
            if (i > 0 && j > 0) prefixXor[i][j] ^= prefixXor[i-1][j-1];
            
            // Maintain min heap of size k
            if (minHeap->size < k) {
                push(minHeap, prefixXor[i][j]);
            } else if (prefixXor[i][j] > minHeap->data[0]) {
                pop(minHeap);
                push(minHeap, prefixXor[i][j]);
            }
        }
    }
    
    int result = minHeap->data[0];
    
    // Free memory
    for (int i = 0; i < m; i++) free(prefixXor[i]);
    free(prefixXor);
    free(minHeap->data);
    free(minHeap);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn log k)

O(mn) to build prefix XOR matrix, O(log k) for each heap operation, total O(mn log k)

⚡ Linearithmic

Space Complexity

O(mn + k)

O(mn) for prefix XOR matrix, O(k) for the min heap

⚡ Linearithmic Space

Constraints

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

35.4K Views

Medium-High Frequency

~25 min Avg. Time

1.2K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Prefix XOR + Min Heap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler