Maximum Score from Performing Multiplication Operations

Maximum Score from Performing Multiplication Operations - Problem

You're given two arrays: nums (size n) and multipliers (size m), where n >= m. Your goal is to maximize your score by performing exactly m operations.

In each operation i (starting from 0):

Choose an element from either the start or end of the nums array
Multiply it by multipliers[i] and add to your score
Remove the chosen element from nums

The challenge is to decide whether to pick from the left or right end at each step to achieve the maximum possible score.

Example: If nums = [1,2,3] and multipliers = [3,2,1], you could pick 3 (right), then 2 (right), then 1 (left) for a score of 3×3 + 2×2 + 1×1 = 14.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,3], multipliers = [3,2,1]

› Output: 14

💡 Note: Choose 3 (right) → 3×3=9. Choose 2 (right) → 2×2=4. Choose 1 (left) → 1×1=1. Total: 9+4+1=14.

example_2.py — Larger Array

$ Input: nums = [-5,-3,-3,-2,7,1], multipliers = [-10,-5,3,4,6]

› Output: 102

💡 Note: Optimal sequence: take -5 (left), -3 (left), -3 (left), 1 (right), 7 (right). Score: (-5)×(-10) + (-3)×(-5) + (-3)×3 + 1×4 + 7×6 = 50+15-9+4+42 = 102.

example_3.py — Single Element

$ Input: nums = [1], multipliers = [1]

› Output: 1

💡 Note: Only one choice: take the single element 1 and multiply by 1, giving score 1.

Visualization

Tap to expand

Understanding the Visualization

Setup

Cards laid out in a line, multipliers determine round values

Decision Point

Each turn, choose from leftmost or rightmost card

DP State

Track: operations completed + cards taken from left

Optimal Choice

At each state, pick the choice that maximizes future score

Key Takeaway

🎯 Key Insight: We only need to track two dimensions in our DP state: the current operation number and how many cards we've taken from the left. The right position can always be calculated from these two values!

Time & Space Complexity

Time Complexity

⏱️

O(m²)

We fill an m×(m+1) DP table with constant work per cell

✓ Linear Growth

Space Complexity

O(m²)

DP table size, can be optimized to O(m) using rolling array

✓ Linear Space

Constraints

n == nums.length
m == multipliers.length
1 ≤ m ≤ min(10³, n)
1 ≤ n ≤ 10⁵
-1000 ≤ nums[i], multipliers[i] ≤ 1000

Asked in

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

The optimal solution uses bottom-up dynamic programming with O(m²) time complexity. Key insight: we only need to track how many elements we've taken from the left side and which operation we're on. The right index can be calculated as right = n - 1 - (operation - left_taken). Build the DP table backward from the base case.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Brute Force	O(2^m)	O(m)	Try all possible sequences of left/right choices recursively
Bottom-Up Dynamic Programming (Optimal)	O(m²)	O(m²)	Build solution iteratively from base cases to avoid recursion overhead
Memoized Dynamic Programming (Top-Down)	O(m²)	O(m²)	Use recursion with memoization to avoid recalculating subproblems

Recursive Brute Force — Algorithm Steps

For each operation, try picking from both left and right ends
Recursively solve for the remaining subproblem
Return the maximum of both choices
Base case: when all m operations are completed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with full array and first multiplier

Branch Decision

Create two branches for left and right choices

Recursive Exploration

Continue until all multipliers are used

Backtrack Maximum

Return the maximum score from all paths

Code -

solution.c — C

int solve(int* nums, int* multipliers, int left, int right, int op, int m) {
    if (op == m) {
        return 0;
    }
    
    int leftScore = nums[left] * multipliers[op] + solve(nums, multipliers, left + 1, right, op + 1, m);
    int rightScore = nums[right] * multipliers[op] + solve(nums, multipliers, left, right - 1, op + 1, m);
    
    return leftScore > rightScore ? leftScore : rightScore;
}

int maximumScore(int* nums, int numsSize, int* multipliers, int multipliersSize) {
    return solve(nums, multipliers, 0, numsSize - 1, 0, multipliersSize);
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m)

Each operation has 2 choices, leading to 2^m total combinations

✓ Linear Growth

Space Complexity

O(m)

Recursion depth is at most m operations

✓ Linear Space

Constraints

n == nums.length
m == multipliers.length
1 ≤ m ≤ min(10³, n)
1 ≤ n ≤ 10⁵
-1000 ≤ nums[i], multipliers[i] ≤ 1000

67.4K Views

High Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler