Maximum Number of Points From Grid Queries

Maximum Number of Points From Grid Queries - Problem

Array Two Pointers Breadth-First Search Union Find Sorting Heap (Priority Queue) Matrix Hard

Imagine you're an explorer trapped in a magical grid where each cell contains a danger level. You start at the top-left corner and want to collect as many points as possible by visiting new cells, but there's a catch: you can only move to adjacent cells (up, down, left, right) if your query power is strictly greater than the cell's danger level!

The Challenge: Given an m × n integer matrix grid and an array queries of size k, find the maximum number of points you can collect for each query.

Rules:

🎯 You get 1 point for each cell you visit for the first time
🚫 You can only enter a cell if queries[i] > grid[row][col]
🔄 You can revisit cells multiple times (but only get points once per cell)
📍 You always start from the top-left corner (0, 0)

Return an array answer where answer[i] is the maximum points for queries[i].

Input & Output

example_1.py — Basic Grid Exploration

$ Input: grid = [[1,2,3],[2,5,7],[3,5,1]], queries = [5,6,2]

› Output: [5, 8, 1]

💡 Note: For query 5: Can visit cells with values [1,2,3,2,3] = 5 points. For query 6: Can visit cells with values [1,2,3,2,5,3,5,1] = 8 points. For query 2: Can only visit cell [1] = 1 point.

example_2.py — Single Cell Grid

$ Input: grid = [[5]], queries = [4,6]

› Output: [0, 1]

💡 Note: For query 4: Cannot enter starting cell (5 >= 4) = 0 points. For query 6: Can enter starting cell (5 < 6) = 1 point.

example_3.py — Large Values Block Path

$ Input: grid = [[1,10,10],[10,1,10],[10,10,1]], queries = [2,10,11]

› Output: [1, 1, 9]

💡 Note: For queries 2 and 10: Blocked by large values, can only reach starting cell = 1 point each. For query 11: Can reach all cells = 9 points.

Constraints

m == grid.length
n == grid[i].length
2 ≤ m, n ≤ 1000
4 ≤ m × n ≤ 10⁵
1 ≤ grid[i][j], queries[j] ≤ 10⁶
1 ≤ queries.length ≤ 10⁴
You must start from grid[0][0]

Visualization

Tap to expand

Understanding the Visualization

Power Check

Can only enter rooms where your query power > room danger level

Connected Exploration

Move to adjacent rooms (up, down, left, right) that you can access

Point Collection

Get 1 point for each unique room visited, regardless of revisits

Smart Optimization

Sort queries and build reusable component maps instead of exploring separately

Key Takeaway

🎯 Key Insight: Instead of exploring the grid separately for each query, we can sort queries by power level and incrementally build connected components using Union-Find, reusing previous computations for maximum efficiency!

Asked in

G Google 42 f Meta 38 a Amazon 35 ⊞ Microsoft 28

The optimal approach uses Union-Find with sorted preprocessing to efficiently handle multiple queries. By sorting both grid cells and queries, we can incrementally build connected components and reuse computation across queries, achieving O((m×n + k) × α(m×n)) time complexity where α is the inverse Ackermann function.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force BFS for Each Query	O(k × m × n)	O(m × n)	Run separate BFS exploration for each query independently
Union-Find with Sorted Preprocessing	O((mn + k) α(m*n))	O(m*n + k)	Sort cells by value, sort queries, and use Union-Find to build connected components incrementally

Brute Force BFS for Each Query — Algorithm Steps

For each query value, initialize a fresh BFS queue with (0,0)
Use a visited set to track unique cells for this query
For each cell in queue, check all 4 adjacent cells
Add adjacent cells to queue only if query > cell_value and not visited
Count total unique visited cells for this query

Visualization

Tap to expand

Step-by-Step Walkthrough

Start BFS

Initialize queue with (0,0) if accessible

Explore Neighbors

Check all 4 adjacent cells for accessibility

Add Valid Cells

Add cells where query > cell_value to queue

Count Points

Increment counter for each unique cell visited

Code -

solution.c — C

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

typedef struct {
    int row, col;
} Point;

typedef struct {
    Point* data;
    int front, rear, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = malloc(sizeof(Queue));
    q->data = malloc(capacity * sizeof(Point));
    q->front = q->rear = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, int row, int col) {
    q->data[q->rear++] = (Point){row, col};
}

Point dequeue(Queue* q) {
    return q->data[q->front++];
}

bool isEmpty(Queue* q) {
    return q->front == q->rear;
}

int* maxPointsQueries(int** grid, int gridSize, int* gridColSize, int* queries, int queriesSize, int* returnSize) {
    int m = gridSize, n = gridColSize[0];
    int* result = malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int query = queries[i];
        if (grid[0][0] >= query) {
            result[i] = 0;
            continue;
        }
        
        bool** visited = malloc(m * sizeof(bool*));
        for (int j = 0; j < m; j++) {
            visited[j] = calloc(n, sizeof(bool));
        }
        
        Queue* queue = createQueue(m * n);
        enqueue(queue, 0, 0);
        visited[0][0] = true;
        int points = 0;
        
        int dirs[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        
        while (!isEmpty(queue)) {
            Point curr = dequeue(queue);
            points++;
            
            for (int d = 0; d < 4; d++) {
                int nr = curr.row + dirs[d][0], nc = curr.col + dirs[d][1];
                if (nr >= 0 && nr < m && nc >= 0 && nc < n && 
                    !visited[nr][nc] && grid[nr][nc] < query) {
                    visited[nr][nc] = true;
                    enqueue(queue, nr, nc);
                }
            }
        }
        
        result[i] = points;
        
        for (int j = 0; j < m; j++) {
            free(visited[j]);
        }
        free(visited);
        free(queue->data);
        free(queue);
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × m × n)

k queries, each potentially visiting all m×n cells in BFS

✓ Linear Growth

Space Complexity

O(m × n)

BFS queue and visited set can store up to m×n cells

⚡ Linearithmic Space

68.2K Views

Medium-High Frequency

~35 min Avg. Time

1.8K 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 BFS for Each Query — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler