Maximum Multiplication Score

Maximum Multiplication Score - Problem

You are given an integer array a of size 4 and another integer array b of size at least 4.

You need to choose 4 indices i₀, i₁, i₂, i₃ from array b such that i₀ < i₁ < i₂ < i₃.

Your score will be equal to a[0] * b[i₀] + a[1] * b[i₁] + a[2] * b[i₂] + a[3] * b[i₃].

Return the maximum score you can achieve.

Input & Output

Example 1 — Basic Case

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

› Output: 26

💡 Note: Choose indices [0,3,4,5]: 3×5 + 2×2 + (-1)×(-1) + 1×6 = 15 + 4 + 1 + 6 = 26

Example 2 — Negative Values

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

› Output: 68

💡 Note: Choose indices [1,2,3,4]: (-1)×1 + 4×8 + 5×3 + 2×6 = -1 + 32 + 15 + 12 = 58

Example 3 — Minimum Size

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

› Output: 70

💡 Note: Must use all indices [0,1,2,3]: 1×5 + 2×6 + 3×7 + 4×8 = 5 + 12 + 21 + 32 = 70

Constraints

a.length == 4
4 ≤ b.length ≤ 10⁵
-10⁵ ≤ a[i], b[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

The key insight is to use dynamic programming where each state represents the maximum score achievable using the first i elements from array a. The optimal approach builds solutions incrementally, deciding at each step whether to include or skip the current element from array b. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Try All Combinations	O(n⁴)	O(1)	Generate all possible combinations of 4 indices and find maximum score
Dynamic Programming - 2D Table	O(n)	O(n)	Build optimal solutions using a 2D DP table where dp[i][j] represents max score using first i elements from a and j elements from b

Brute Force - Try All Combinations — Algorithm Steps

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

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Try all combinations where i0 < i1 < i2 < i3

Calculate Scores

For each combination, compute a[0]*b[i0] + a[1]*b[i1] + a[2]*b[i2] + a[3]*b[i3]

Find Maximum

Track and return the highest score found

Code -

solution.c — C

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

long long solution(int* a, int* b, int b_size) {
    long long maxScore = LLONG_MIN;
    
    // Try all combinations of 4 indices
    for (int i0 = 0; i0 < b_size; i0++) {
        for (int i1 = i0 + 1; i1 < b_size; i1++) {
            for (int i2 = i1 + 1; i2 < b_size; i2++) {
                for (int i3 = i2 + 1; i3 < b_size; 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;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int a[4], b[100], b_size = 0;
    
    // Parse array a
    char* token = strtok(line1, "[],\n");
    for (int i = 0; i < 4; i++) {
        a[i] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    // Parse array b
    token = strtok(line2, "[],\n");
    while (token != NULL) {
        b[b_size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%lld\n", solution(a, b, b_size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

Four nested loops to try all combinations of 4 indices

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

32.8K Views

Medium Frequency

~25 min Avg. Time

840 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 Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler