Grid Game - Practice Coding Problems

Grid Game - Problem

Grid Game is a fascinating competitive strategy problem where two robots navigate a 2 × n grid to collect points.

🎮 The Setup: You have a grid with 2 rows and n columns, where each cell contains points. Two robots start at the top-left corner (0, 0) and must reach the bottom-right corner (1, n-1).

📋 Movement Rules:

Robots can only move right or down
The first robot moves first, collecting all points on its path
After the first robot finishes, all visited cells become 0
The second robot then takes its turn on the modified grid

🧠 Strategic Twist: The first robot wants to minimize the second robot's score, while the second robot wants to maximize its own score. Both play optimally!

Goal: Determine how many points the second robot will collect when both robots play their best strategy.

Input & Output

example_1.py — Basic Grid

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

› Output: 4

💡 Note: The first robot can turn down at column 1, leaving top region [4] and bottom region [1]. Second robot gets max(4,1) = 4. This is actually not optimal - turning at column 2 gives max(0,3) = 3.

example_2.py — Smaller Grid

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

› Output: 4

💡 Note: Turn options: Column 0→max(4,0)=4, Column 1→max(1,8)=8, Column 2→max(0,13)=13. Minimum is 4.

example_3.py — Edge Case

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

› Output: 2

💡 Note: All turn columns give the same result due to uniform distribution. Turn at any middle column gives balanced regions.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Every path creates exactly two uncollected regions

Mathematical Insight

The regions are always top-right and bottom-left of the turn point

Optimization

Second robot picks the better region, first robot minimizes this choice

Key Takeaway

🎯 Key Insight: The problem reduces to finding the optimal turn column that minimizes the maximum of two complementary regions, transforming a complex path problem into an elegant O(n) optimization.

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses prefix sums to recognize that the first robot essentially chooses a turn column, creating two regions for the second robot. The key insight is to minimize the maximum of these two regions, leading to an elegant O(n) solution.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Paths)	O(2^n × n)	O(n)	Generate all possible paths for the first robot and find the one that minimizes the second robot's score
Prefix Sum Optimization (Optimal)	O(n)	O(1)	Recognize that the first robot just chooses a turn-down column, creating two regions for the second robot

Brute Force (Try All Paths) — Algorithm Steps

Generate all valid paths from (0,0) to (1,n-1) using DFS/backtracking
For each first robot path, simulate point collection and mark visited cells as 0
Find the maximum points the second robot can collect on the modified grid
Track the minimum across all possible first robot paths
Return the minimum second robot score

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Paths

Use backtracking to find every possible path from (0,0) to (1,n-1)

Simulate First Robot

For each path, mark visited cells as 0

Find Second Robot Optimal

Use dynamic programming to find maximum points on modified grid

Track Minimum

Keep track of the minimum second robot score across all paths

Code -

solution.c — C

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

long long getMaxPoints(int** modifiedGrid, int rows, int cols) {
    long long** dp = (long long**)malloc(rows * sizeof(long long*));
    for (int i = 0; i < rows; i++) {
        dp[i] = (long long*)malloc(cols * sizeof(long long));
    }
    
    dp[0][0] = modifiedGrid[0][0];
    
    for (int c = 1; c < cols; c++) {
        dp[0][c] = dp[0][c-1] + modifiedGrid[0][c];
    }
    
    for (int r = 1; r < rows; r++) {
        dp[r][0] = dp[r-1][0] + modifiedGrid[r][0];
    }
    
    for (int r = 1; r < rows; r++) {
        for (int c = 1; c < cols; c++) {
            long long fromUp = dp[r-1][c];
            long long fromLeft = dp[r][c-1];
            dp[r][c] = (fromUp > fromLeft ? fromUp : fromLeft) + modifiedGrid[r][c];
        }
    }
    
    long long result = dp[rows-1][cols-1];
    
    for (int i = 0; i < rows; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

void getAllPathsHelper(int r, int c, int** grid, int rows, int cols, 
                       int* path, int pathLen, int*** allPaths, 
                       int* pathLens, int* numPaths, int* capacity) {
    if (r == 1 && c == cols - 1) {
        if (*numPaths >= *capacity) {
            *capacity *= 2;
            *allPaths = (int**)realloc(*allPaths, (*capacity) * sizeof(int*));
            pathLens = (int*)realloc(pathLens, (*capacity) * sizeof(int));
        }
        
        (*allPaths)[*numPaths] = (int*)malloc(pathLen * 2 * sizeof(int));
        for (int i = 0; i < pathLen * 2; i++) {
            (*allPaths)[*numPaths][i] = path[i];
        }
        pathLens[*numPaths] = pathLen;
        (*numPaths)++;
        return;
    }
    
    if (c + 1 < cols) {
        path[pathLen * 2] = r;
        path[pathLen * 2 + 1] = c + 1;
        getAllPathsHelper(r, c + 1, grid, rows, cols, path, pathLen + 1, 
                          allPaths, pathLens, numPaths, capacity);
    }
    
    if (r + 1 < 2) {
        path[pathLen * 2] = r + 1;
        path[pathLen * 2 + 1] = c;
        getAllPathsHelper(r + 1, c, grid, rows, cols, path, pathLen + 1, 
                          allPaths, pathLens, numPaths, capacity);
    }
}

long long gridGame(int** grid, int gridSize, int* gridColSize) {
    int rows = gridSize, cols = gridColSize[0];
    
    int** allPaths;
    int* pathLens;
    int numPaths = 0;
    int capacity = 100;
    
    allPaths = (int**)malloc(capacity * sizeof(int*));
    pathLens = (int*)malloc(capacity * sizeof(int));
    
    int* currentPath = (int*)malloc(2 * (rows + cols) * sizeof(int));
    currentPath[0] = 0;
    currentPath[1] = 0;
    
    getAllPathsHelper(0, 0, grid, rows, cols, currentPath, 1, 
                      &allPaths, pathLens, &numPaths, &capacity);
    
    long long minSecondRobotPoints = LLONG_MAX;
    
    for (int p = 0; p < numPaths; p++) {
        int** modifiedGrid = (int**)malloc(rows * sizeof(int*));
        for (int i = 0; i < rows; i++) {
            modifiedGrid[i] = (int*)malloc(cols * sizeof(int));
            for (int j = 0; j < cols; j++) {
                modifiedGrid[i][j] = grid[i][j];
            }
        }
        
        for (int i = 0; i < pathLens[p]; i++) {
            int r = allPaths[p][i * 2];
            int c = allPaths[p][i * 2 + 1];
            modifiedGrid[r][c] = 0;
        }
        
        long long secondRobotPoints = getMaxPoints(modifiedGrid, rows, cols);
        if (secondRobotPoints < minSecondRobotPoints) {
            minSecondRobotPoints = secondRobotPoints;
        }
        
        for (int i = 0; i < rows; i++) {
            free(modifiedGrid[i]);
        }
        free(modifiedGrid);
    }
    
    for (int i = 0; i < numPaths; i++) {
        free(allPaths[i]);
    }
    free(allPaths);
    free(pathLens);
    free(currentPath);
    
    return minSecondRobotPoints;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

There are roughly 2^n possible paths to enumerate, and for each path we need O(n) time to simulate both robots

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and path storage require O(n) space

⚡ Linearithmic Space

32.8K Views

Medium-High Frequency

~18 min Avg. Time

1.5K 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 (Try All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler