Grid Game

Grid Game - Problem

You are given a 0-indexed 2D array grid of size 2 x n, where grid[r][c] represents the number of points at position (r, c) on the matrix.

Two robots are playing a game on this matrix. Both robots initially start at (0, 0) and want to reach (1, n-1). Each robot may only move right ((r, c) to (r, c + 1)) or down ((r, c) to (r + 1, c)).

At the start of the game, the first robot moves from (0, 0) to (1, n-1), collecting all the points from the cells on its path. For all cells (r, c) traversed on the path, grid[r][c] is set to 0. Then, the second robot moves from (0, 0) to (1, n-1), collecting the points on its path.

The first robot wants to minimize the number of points collected by the second robot. In contrast, the second robot wants to maximize the number of points it collects. If both robots play optimally, return the number of points collected by the second robot.

Input & Output

Example 1 — Basic Grid

$ Input: grid = [[2,5,4],[8,10,3]]

› Output: 8

💡 Note: The first robot goes down at position 1, taking path (0,0)→(0,1)→(1,1)→(1,2), collecting 2+5+10+3=20 points and removing those cells. The second robot then has two remaining path options: top path with 0+0+4=4 points or bottom path with 8+0+0=8 points. The second robot chooses the bottom path to get 8 points.

Example 2 — Better Bottom Path

$ Input: grid = [[1,3,1,15],[1,3,3,1]]

› Output: 7

💡 Note: The first robot goes down at position 2, collecting 1+3+1+3+1=9 points. The remaining points allow the second robot to collect max(0+0+15, 1+3+0) = max(15,4) = 15. But the optimal first robot strategy gives second robot only 7.

Example 3 — Equal Rows

$ Input: grid = [[1,1,1],[1,1,1]]

› Output: 1

💡 Note: With identical rows, the first robot can force the second robot to get at most 1 point regardless of strategy.

Constraints

grid.length == 2
n == grid[r].length
1 ≤ n ≤ 5 × 10⁴
1 ≤ grid[r][c] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that the first robot must go down exactly once, creating two segments. The optimal strategy uses prefix sums to efficiently evaluate each possible down position. Best approach: Prefix Sum - Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Path Enumeration

⏱️ Time: O(2^n) Space: O(n)

Generate all valid paths from (0,0) to (1,n-1), simulate the first robot taking each path, then find the second robot's optimal path on the remaining grid.

Prefix Sum Optimization

⏱️ Time: O(n) Space: O(1)

The key insight is that the first robot must go down exactly once, creating two segments. We can use prefix sums to quickly calculate what the second robot can collect from each row.

Brute Force Path Enumeration — Algorithm Steps

Generate all valid paths for first robot
For each path, simulate point collection and grid clearing
Find optimal path for second robot on remaining grid
Return minimum of all second robot scores

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Paths

Find all valid paths from (0,0) to (1,n-1)

Simulate Each

For each path, clear those cells and find second robot's best score

Find Minimum

Return the minimum second robot score across all paths

Code -

solution.c — C

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

#define MAX_N 100
#define MAX_PATHS 1000

static int n;
static int paths[MAX_PATHS][MAX_N][2];
static int pathLengths[MAX_PATHS];
static int numPaths = 0;
static int memo[2][MAX_N];
static int memoValid[2][MAX_N];

void generatePaths(int r, int c, int currentPath[][2], int pathLen) {
    currentPath[pathLen][0] = r;
    currentPath[pathLen][1] = c;
    pathLen++;
    
    if (r == 1 && c == n - 1) {
        for (int i = 0; i < pathLen; i++) {
            paths[numPaths][i][0] = currentPath[i][0];
            paths[numPaths][i][1] = currentPath[i][1];
        }
        pathLengths[numPaths] = pathLen;
        numPaths++;
        return;
    }
    
    if (r < 1) {
        generatePaths(r + 1, c, currentPath, pathLen);
    }
    if (c < n - 1) {
        generatePaths(r, c + 1, currentPath, pathLen);
    }
}

int findMaxPath(int grid[2][MAX_N], int r, int c) {
    if (r == 1 && c == n - 1) {
        return grid[r][c];
    }
    
    if (memoValid[r][c]) {
        return memo[r][c];
    }
    
    int maxScore = 0;
    if (r < 1) {
        int score = findMaxPath(grid, r + 1, c);
        if (score > maxScore) maxScore = score;
    }
    if (c < n - 1) {
        int score = findMaxPath(grid, r, c + 1);
        if (score > maxScore) maxScore = score;
    }
    
    int result = grid[r][c] + maxScore;
    memo[r][c] = result;
    memoValid[r][c] = 1;
    return result;
}

int solution(int grid[2][MAX_N]) {
    int currentPath[MAX_N][2];
    numPaths = 0;
    generatePaths(0, 0, currentPath, 0);
    
    int minSecondScore = INT_MAX;
    
    for (int i = 0; i < numPaths; i++) {
        int gridCopy[2][MAX_N];
        for (int r = 0; r < 2; r++) {
            for (int c = 0; c < n; c++) {
                gridCopy[r][c] = grid[r][c];
            }
        }
        
        for (int j = 0; j < pathLengths[i]; j++) {
            int r = paths[i][j][0];
            int c = paths[i][j][1];
            gridCopy[r][c] = 0;
        }
        
        // Clear memoization
        memset(memoValid, 0, sizeof(memoValid));
        
        int secondScore = findMaxPath(gridCopy, 0, 0);
        if (secondScore < minSecondScore) {
            minSecondScore = secondScore;
        }
    }
    
    return minSecondScore;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    static int grid[2][MAX_N];
    
    // Parse [[a,b,c],[d,e,f]] format
    char *p = line;
    while (*p && *p != '[') p++; // Find first [
    p++; // Skip [
    
    for (int row = 0; row < 2; row++) {
        while (*p && *p != '[') p++; // Find row start
        p++; // Skip [
        
        int col = 0;
        while (*p && *p != ']') {
            if (*p >= '0' && *p <= '9') {
                int num = 0;
                while (*p >= '0' && *p <= '9') {
                    num = num * 10 + (*p - '0');
                    p++;
                }
                grid[row][col++] = num;
            } else {
                p++;
            }
        }
        if (row == 0) n = col;
        p++; // Skip ]
    }
    
    printf("%d\n", solution(grid));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

There are exponentially many paths from (0,0) to (1,n-1) to enumerate

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and path storage

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

890 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 Path Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler