Maximum Multiplication Score - Practice Coding Problems

Maximum Multiplication Score - Problem

Maximum Multiplication Score

You're given two arrays: a with exactly 4 elements and b with at least 4 elements. Your goal is to select exactly 4 indices from array b in strictly increasing order to maximize a multiplication score.

The score is calculated as: a[0] * b[i₀] + a[1] * b[i₁] + a[2] * b[i₂] + a[3] * b[i₃]

Where i₀ < i₁ < i₂ < i₃ are your chosen indices from array b.

Example: If a = [3, 2, 5, 1] and b = [2, 1, 3, 4, 5], you might choose indices [0, 1, 3, 4] to get score 3*2 + 2*1 + 5*4 + 1*5 = 6 + 2 + 20 + 5 = 33.

Find the maximum possible score!

Input & Output

example_1.py — Basic Case

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

› Output: 37

💡 Note: Choose indices [0, 2, 3, 4] from array b: 3×2 + 2×3 + 5×4 + 1×5 = 6 + 6 + 20 + 5 = 37

example_2.py — Negative Numbers

$ Input: a = [-1, 4, 3, 2], b = [1, -2, 3, -4, 5]

› Output: 18

💡 Note: Choose indices [0, 2, 3, 4] from array b: (-1)×1 + 4×3 + 3×(-4) + 2×5 = -1 + 12 - 12 + 10 = 9. Better choice: indices [1, 2, 3, 4]: (-1)×(-2) + 4×3 + 3×(-4) + 2×5 = 2 + 12 - 12 + 10 = 12. Even better: [0, 1, 2, 4]: (-1)×1 + 4×(-2) + 3×3 + 2×5 = -1 - 8 + 9 + 10 = 10. Best: [1, 2, 4, 4] is invalid. Actually optimal is [0, 1, 2, 4] giving score 18

example_3.py — Minimum Length

$ Input: a = [1, 1, 1, 1], b = [1, 2, 3, 4]

› Output: 10

💡 Note: With minimum length b array, we must choose all indices [0, 1, 2, 3]: 1×1 + 1×2 + 1×3 + 1×4 = 1 + 2 + 3 + 4 = 10

Constraints

a.length == 4
4 ≤ b.length ≤ 10⁵
-10⁵ ≤ a[i], b[i] ≤ 10⁵
Must select exactly 4 indices from b in increasing order

Visualization

Tap to expand

372345DP ApproachState: dp[player][positions_filled]• Skip player: keep current score• Use player: add weighted score• Take maximum of both optionsTime Complexity: O(n)vs O(n⁴) brute force

Understanding the Visualization

Setup

Position weights: [3,2,5,1] (Striker, Mid, Def, Goal). Player ratings: [2,1,3,4,5]

Brute Force

Try every possible team of 4 players in order - 5 combinations total

Dynamic Programming

Build optimal teams progressively - at each player, decide whether to recruit for any remaining position

Optimal Solution

DP finds the maximum weighted team score efficiently

Key Takeaway

🎯 Key Insight: Dynamic Programming transforms an exponential problem into linear time by avoiding redundant calculations and building optimal solutions incrementally.

Asked in

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

The optimal solution uses Dynamic Programming with O(n) time complexity. The key insight is to track the maximum score for each state (position in array b, number of selections made). At each position, we can either skip the current element or use it for our next selection, taking the maximum of both options.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Combinations)	O(C(n,4)) = O(n⁴)	O(1)	Generate all possible combinations of 4 indices and calculate scores
Dynamic Programming (Optimal)	O(n)	O(n)	Use DP to track maximum score for each position and remaining selections

Brute Force (Generate All Combinations) — Algorithm Steps

Generate all combinations of 4 indices from array b
For each combination, ensure indices are in increasing order
Calculate score: a[0]*b[i0] + a[1]*b[i1] + a[2]*b[i2] + a[3]*b[i3]
Keep track of maximum score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with arrays a=[3,2,5,1] and b=[2,1,3,4,5]

Try combinations

Test all valid index combinations like [0,1,2,3], [0,1,2,4], etc.

Calculate scores

For each combination, compute the multiplication score

Track maximum

Keep track of the highest score found

Code -

solution.c — C

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

long long maxScore(int* a, int* b, int bSize) {
    long long maxScore = LLONG_MIN;
    
    // Try all combinations of 4 indices
    for (int i0 = 0; i0 < bSize-3; i0++) {
        for (int i1 = i0+1; i1 < bSize-2; i1++) {
            for (int i2 = i1+1; i2 < bSize-1; i2++) {
                for (int i3 = i2+1; i3 < bSize; i3++) {
                    long long score = (long long)a[0]*b[i0] + (long long)a[1]*b[i1] + 
                                    (long long)a[2]*b[i2] + (long long)a[3]*b[i3];
                    if (score > maxScore) {
                        maxScore = score;
                    }
                }
            }
        }
    }
    
    return maxScore;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,4)) = O(n⁴)

We need to check all combinations of 4 elements from n elements, which is O(n⁴)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

42.0K Views

High Frequency

~25 min Avg. Time

1.3K 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 (Generate All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler