Optimal Matrix Game - Problem

Two players are playing an optimal strategy game with a row of numbers. Players take turns picking numbers from either end of the row. Each player tries to maximize their own score.

Given an array nums representing the row of numbers, return the maximum score that the first player can obtain, assuming both players play optimally.

Note: The first player always goes first. Both players have perfect information and play to maximize their own score.

Input & Output

Example 1 — Basic Game

$ Input: nums = [1,5,2]

› Output: 6

💡 Note: First player picks 2, second player picks 5, first player picks 1. First player gets 2 + 1 = 3, but optimal play gives first player 6 total by picking 1 first, forcing second player to pick optimally from [5,2].

Example 2 — Larger Array

$ Input: nums = [1,5,233,7]

› Output: 240

💡 Note: First player can pick 7, then after second player's optimal move, pick 233. Total: 233 + 7 = 240.

Example 3 — Equal Elements

$ Input: nums = [3,3,3,3]

› Output: 6

💡 Note: Players alternate picking 3s. First player gets first and third picks: 3 + 3 = 6.

Constraints

1 ≤ nums.length ≤ 20
0 ≤ nums[i] ≤ 10⁷

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

The optimal matrix game uses dynamic programming to find the maximum score for the first player. The key insight is that each player makes optimal moves to maximize their own advantage. The best approach uses a 2D DP table where dp[i][j] represents the maximum advantage when playing on subarray from index i to j. Time: O(n²), Space: O(n²).

Common Approaches

✓ 2D Dynamic Programming

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

Build a 2D table where dp[i][j] represents the maximum advantage (first player score minus second player score) when the game is played on subarray from index i to j.

Memoization (Top-Down DP)

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

Same recursive approach as brute force, but store results of subproblems in a cache to avoid recalculating the same game states multiple times.

Recursive Brute Force

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

For each turn, try picking from both ends and recursively calculate the optimal score for the remaining array. The first player tries to maximize their score while the second player tries to minimize the first player's score.

2D Dynamic Programming — Algorithm Steps

Initialize DP table with base cases (single elements)
Fill table for increasing subarray lengths
For each subarray, choose better option: pick left or pick right

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Cases

Fill diagonal with single element values

Build Up

Fill table for increasing subarray lengths

Final Answer

dp[0][n-1] gives the maximum advantage

Code -

solution.c — C

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

int solution(int* nums, int size) {
    int n = size;
    if (n == 0) return 0;
    if (n == 1) return nums[0];
    
    int** dp = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = calloc(n, sizeof(int));
    }
    
    for (int i = 0; i < n; i++) {
        dp[i][i] = nums[i];
    }
    
    for (int length = 2; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            int pickLeft = nums[i] - dp[i + 1][j];
            int pickRight = nums[j] - dp[i][j - 1];
            dp[i][j] = pickLeft > pickRight ? pickLeft : pickRight;
        }
    }
    
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += nums[i];
    }
    
    int result = (total + dp[0][n - 1]) / 2;
    
    for (int i = 0; i < n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops iterate through all possible subarrays

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table stores results for all n² subarrays

⚠ Quadratic Space

23.5K Views

Medium Frequency

~35 min Avg. Time

892 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

Optimal Matrix Game - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler