Max Dot Product of Two Subsequences - Practice Coding Problems

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

Understanding the Visualization

Evaluate Each Position

At each stock pair, decide: buy both, skip first period, or skip second period

Calculate Profit

If buying both stocks, multiply their values (dot product)

Explore All Combinations

Use memoization to efficiently try all valid portfolio combinations

Find Maximum

Return the portfolio combination with the highest total value

Key Takeaway

🎯 Key Insight: Use dynamic programming to systematically explore all portfolio combinations while avoiding redundant calculations through memoization, achieving optimal O(m×n) performance.

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

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(2^(m+n) × min(m,n))	O(2^(m+n))	Generate all possible subsequences and compute dot products
Dynamic Programming (Optimal)	O(m × n)	O(m × n)	Build optimal solution incrementally using memoization

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all non-empty subsequences of nums1
Generate all non-empty subsequences of nums2
For each pair of subsequences with equal length, calculate dot product
Return the maximum dot product found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsequences

Generate all possible non-empty subsequences from both arrays

Compare Lengths

Only compare subsequences of equal length

Calculate Dot Products

Compute dot product for each valid pair

Find Maximum

Return the maximum dot product found

Code -

solution.c — C

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

typedef struct {
    int* arr;
    int size;
} Subsequence;

typedef struct {
    Subsequence* subseqs;
    int count;
    int capacity;
} SubseqList;

int dotProduct(int* a, int* b, int len) {
    int sum = 0;
    for (int i = 0; i < len; i++) {
        sum += a[i] * b[i];
    }
    return sum;
}

void generateSubsequences(int* arr, int n, int index, int* current, int currentSize, SubseqList* list) {
    if (currentSize > 0) {
        if (list->count >= list->capacity) {
            list->capacity *= 2;
            list->subseqs = realloc(list->subseqs, list->capacity * sizeof(Subsequence));
        }
        
        list->subseqs[list->count].arr = malloc(currentSize * sizeof(int));
        list->subseqs[list->count].size = currentSize;
        for (int i = 0; i < currentSize; i++) {
            list->subseqs[list->count].arr[i] = current[i];
        }
        list->count++;
    }
    
    for (int i = index; i < n; i++) {
        current[currentSize] = arr[i];
        generateSubsequences(arr, n, i + 1, current, currentSize + 1, list);
    }
}

int maxDotProduct(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    SubseqList list1 = {malloc(10 * sizeof(Subsequence)), 0, 10};
    SubseqList list2 = {malloc(10 * sizeof(Subsequence)), 0, 10};
    
    int* current1 = malloc(nums1Size * sizeof(int));
    int* current2 = malloc(nums2Size * sizeof(int));
    
    generateSubsequences(nums1, nums1Size, 0, current1, 0, &list1);
    generateSubsequences(nums2, nums2Size, 0, current2, 0, &list2);
    
    int maxDot = INT_MIN;
    
    for (int i = 0; i < list1.count; i++) {
        for (int j = 0; j < list2.count; j++) {
            if (list1.subseqs[i].size == list2.subseqs[j].size) {
                int dot = dotProduct(list1.subseqs[i].arr, list2.subseqs[j].arr, list1.subseqs[i].size);
                if (dot > maxDot) {
                    maxDot = dot;
                }
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < list1.count; i++) free(list1.subseqs[i].arr);
    for (int i = 0; i < list2.count; i++) free(list2.subseqs[i].arr);
    free(list1.subseqs);
    free(list2.subseqs);
    free(current1);
    free(current2);
    
    return maxDot;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n) × min(m,n))

2^m subsequences from first array, 2^n from second, and min(m,n) to calculate dot product

✓ Linear Growth

Space Complexity

O(2^(m+n))

Store all possible subsequences

⚡ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler