Maximum Score from Performing Multiplication Operations

Maximum Score from Performing Multiplication Operations - Problem

You are given two 0-indexed integer arrays nums and multipliers of size n and m respectively, where n >= m.

You begin with a score of 0. You want to perform exactly m operations. On the i-th operation (0-indexed) you will:

Choose one integer x from either the start or the end of the array nums.
Add multipliers[i] * x to your score.
Remove x from nums.

Return the maximum score after performing m operations.

Input & Output

Example 1 — Basic Case

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

› Output: 14

💡 Note: Optimal picks: Take 3 (right) → score = 3×3 = 9. Take 2 (right) → score = 9 + 2×2 = 13. Take 1 (left) → score = 13 + 1×1 = 14. Total: 14

Example 2 — All From Left

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

› Output: 102

💡 Note: Take from left: -5×(-10)=50, -3×(-5)=15, -3×3=-9, -2×4=-8, 7×6=42. Total: 50+15-9-8+42 = 90. But optimal strategy gives 102.

Example 3 — Mixed Strategy

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

› Output: 5

💡 Note: Only one element and one multiplier: 1×5 = 5

Constraints

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

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 12 a Amazon 8

The key insight is that we can only pick from the ends of the array, creating overlapping subproblems perfect for dynamic programming. Best approach uses memoization with O(m²) time and space complexity, where each state is defined by (left_picks, operation_number).

Common Approaches

✓ Bottom-Up 2D DP

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

Create a DP table where dp[i][j] represents the maximum score when we've taken i elements from left and j elements from right, having used i+j multipliers total.

Recursive Brute Force

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

For each operation, recursively try picking from both the left and right ends of the remaining array. Choose the path that gives maximum score.

Top-Down DP with Memoization

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

Use the same recursive approach but store results in a memo table. Since we can represent any state with (left_index, operation_number), we can cache and reuse results.

Bottom-Up 2D DP — Algorithm Steps

Initialize DP table with base cases
Fill table iteratively for each operation
Consider picking from left or right at each step
Return maximum score after all operations

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Create DP table for all (left, right) combinations

Fill Backwards

Start from last operation, work backwards

Final Answer

dp[0][0] contains maximum score

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int **dp_table;

int dfs(int* nums, int numsSize, int* multipliers, int multipliersSize, int left, int op) {
    if (op == multipliersSize) return 0;
    if (dp_table[left][op] != INT_MIN) return dp_table[left][op];

    int rightIdx = numsSize - 1 - (op - left);
    int pickLeft = multipliers[op] * nums[left] + dfs(nums, numsSize, multipliers, multipliersSize, left + 1, op + 1);
    int pickRight = multipliers[op] * nums[rightIdx] + dfs(nums, numsSize, multipliers, multipliersSize, left, op + 1);

    dp_table[left][op] = max(pickLeft, pickRight);
    return dp_table[left][op];
}

int solution(int* nums, int numsSize, int* multipliers, int multipliersSize) {
    dp_table = (int**)malloc((multipliersSize + 1) * sizeof(int*));
    for (int i = 0; i <= multipliersSize; i++) {
        dp_table[i] = (int*)malloc((multipliersSize + 1) * sizeof(int));
        for (int j = 0; j <= multipliersSize; j++) {
            dp_table[i][j] = INT_MIN;
        }
    }
    int result = dfs(nums, numsSize, multipliers, multipliersSize, 0, 0);
    for (int i = 0; i <= multipliersSize; i++) free(dp_table[i]);
    free(dp_table);
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    int nums[100000], numsSize = 0;
    parseArray(line, nums, &numsSize);

    fgets(line, sizeof(line), stdin);
    int multipliers[1000], multipliersSize = 0;
    parseArray(line, multipliers, &multipliersSize);

    printf("%d\n", solution(nums, numsSize, multipliers, multipliersSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²)

Nested loops iterate through m×m DP states, each taking O(1) time

✓ Linear Growth

Space Complexity

O(m²)

2D DP table stores m×m states for all possible left/right combinations

✓ Linear Space

98.0K Views

Medium 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

Bottom-Up 2D DP — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler