Max Dot Product of Two Subsequences

Max Dot Product of Two Subsequences - Problem

Given two arrays nums1 and nums2, find the maximum dot product between non-empty subsequences of the same length.

The dot product of two sequences is the sum of products of corresponding elements. For example, the dot product of [2, 3] and [1, 4] is 2×1 + 3×4 = 14.

A subsequence is formed by deleting some (possibly zero) elements from the original array while maintaining the relative order. For instance, [2, 5] is a valid subsequence of [1, 2, 3, 5], but [5, 2] is not.

Goal: Return the maximum possible dot product between equal-length subsequences from both arrays.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [2,1,-2,5], nums2 = [3,0,-1]

› Output: 15

💡 Note: Take subsequence [5] from nums1 and [3] from nums2. Dot product = 5 × 3 = 15, which is the maximum possible.

example_2.py — Multiple Elements

$ Input: nums1 = [3,-2], nums2 = [2,-6,7]

› Output: 21

💡 Note: Take subsequence [3,-2] from nums1 and [2,7] from nums2 (skipping -6). Dot product = 3×2 + (-2)×7 = 6 - 14 = -8. Wait, better choice: take [3] and [7] for 3×7 = 21.

example_3.py — All Negative

$ Input: nums1 = [-1,-1], nums2 = [-1,-1]

› Output: 1

💡 Note: When all numbers are negative, the best strategy is to take the single largest (least negative) element from each array: (-1) × (-1) = 1.

Constraints

1 ≤ nums1.length, nums2.length ≤ 500
-1000 ≤ nums1[i], nums2[i] ≤ 1000
Both subsequences must be non-empty
Subsequences must have the same length

Visualization

Tap to expand

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 18 Apple 15

The optimal approach uses dynamic programming with memoization to efficiently explore all possible subsequence combinations. At each position (i,j), we have three choices: take both elements (adding their product), skip the first element, or skip the second element. The key insight is that we can build the optimal solution incrementally while avoiding redundant calculations through memoization, achieving O(m×n) time complexity.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Memoization

⏱️ Time: N/A Space: N/A

Brute Force (Generate All Subsequences)

⏱️ Time: O(2^(m+n) × min(m,n)) Space: O(2^(m+n))

Generate all possible non-empty subsequences from both arrays, then for each pair of subsequences with the same length, calculate their dot product and keep track of the maximum.

Dynamic Programming (Optimal)

⏱️ Time: O(m × n) Space: O(m × n)

Use dynamic programming with memoization to explore all possible subsequence combinations efficiently. At each position, we decide whether to include elements from both arrays, skip the first array element, or skip the second array element.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int power3(int exp) {
    int result = 1;
    for (int i = 0; i < exp; i++) {
        result *= 3;
    }
    return result;
}

int solution(int* nums, int n, int numSlots) {
    int maxMask = power3(numSlots);
    
    int* dp = (int*)malloc(maxMask * sizeof(int));
    for (int i = 0; i < maxMask; i++) {
        dp[i] = -1;
    }
    dp[0] = 0;
    
    for (int i = 0; i < n; i++) {
        int num = nums[i];
        int* newDp = (int*)malloc(maxMask * sizeof(int));
        for (int j = 0; j < maxMask; j++) {
            newDp[j] = -1;
        }
        
        for (int mask = 0; mask < maxMask; mask++) {
            if (dp[mask] == -1) continue;
            
            int tempMask = mask;
            for (int slot = 0; slot < numSlots; slot++) {
                int slotCount = tempMask % 3;
                tempMask /= 3;
                
                if (slotCount < 2) {
                    int newMask = mask + power3(slot);
                    int slotNum = slot + 1;
                    int newSum = dp[mask] + (num & slotNum);
                    if (newDp[newMask] < newSum) {
                        newDp[newMask] = newSum;
                    }
                }
            }
        }
        
        free(dp);
        dp = newDp;
    }
    
    int result = 0;
    for (int i = 0; i < maxMask; i++) {
        if (dp[i] != -1 && dp[i] > result) {
            result = dp[i];
        }
    }
    
    free(dp);
    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[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[20];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int numSlots;
    scanf("%d", &numSlots);
    
    printf("%d\n", solution(nums, n, numSlots));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

29.1K Views

Medium Frequency

~25 min Avg. Time

1.2K 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