Maximum Product of First and Last Elements of a Subsequence

Maximum Product of First and Last Elements of a Subsequence - Problem

You are given an integer array nums and an integer m. Your task is to find a subsequence of exactly m elements that maximizes the product of its first and last elements.

A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.

Goal: Return the maximum possible product of the first and last elements among all subsequences of size m.

Example: For nums = [1, 5, 3, 2, 4] and m = 3, one optimal subsequence is [5, 3, 4] where the product of first and last elements is 5 × 4 = 20.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 5, 3, 2, 4], m = 3

› Output: 20

💡 Note: We can choose subsequence [5, 3, 4] (indices 1, 2, 4). The product of first and last elements is 5 × 4 = 20, which is the maximum possible.

example_2.py — Single Element

$ Input: nums = [2, 4, 6], m = 1

› Output: 36

💡 Note: When m = 1, the subsequence contains only one element, so we multiply it by itself. The maximum element is 6, giving us 6 × 6 = 36.

example_3.py — Negative Numbers

$ Input: nums = [-2, 1, -3, 4, -1], m = 2

› Output: 6

💡 Note: The optimal subsequence is [-2, -3] with product (-2) × (-3) = 6. Two negative numbers give a positive product, which is better than any combination involving positive numbers here.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ m ≤ nums.length
-10⁴ ≤ nums[i] ≤ 10⁴
Subsequence must maintain relative order of elements

Visualization

Tap to expand

Understanding the Visualization

Rank All Players

Sort players by rating while remembering their original positions

Try Best Combinations

Consider pairs of high-rated players as potential first and last

Check Team Size

Verify we can fill the team with enough players between chosen first and last

Maximize Prize

Pick the combination that gives the highest product

Key Takeaway

🎯 Key Insight: Sort by value to prioritize high products, then verify feasibility by checking if enough positions exist between chosen first and last elements.

Asked in

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

The optimal approach uses sorting with two pointers to efficiently find the maximum product. By sorting elements by value while preserving indices, we can systematically check the most promising pairs as potential first and last elements. The key insight is that we only need to verify if enough elements exist between two indices to form a valid subsequence of size m.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(2^n × m)	O(2^n × m)	Generate all possible subsequences of size m and find maximum product
Two Pointers with Sorting	O(n² × m)	O(n)	Sort elements with indices, use two pointers to find optimal first/last pairs

Brute Force (Generate All Subsequences) — Algorithm Steps

Use recursion or bit manipulation to generate all subsequences
Filter subsequences that have exactly m elements
For each valid subsequence, calculate first × last
Return the maximum product found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subsequences

Use backtracking to generate every possible subsequence

Filter by Size

Keep only subsequences with exactly m elements

Calculate Products

Compute first × last for each valid subsequence

Track Maximum

Keep the highest product found so far

Code -

solution.c — C

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

long long maxProduct = LLONG_MIN;

void backtrack(int* nums, int numsSize, int index, int* subsequence, int subSize, int m) {
    if (subSize == m) {
        long long product;
        if (m == 1) {
            product = (long long)subsequence[0] * subsequence[0];
        } else {
            product = (long long)subsequence[0] * subsequence[subSize - 1];
        }
        if (product > maxProduct) {
            maxProduct = product;
        }
        return;
    }
    
    if (index >= numsSize || subSize + (numsSize - index) < m) {
        return;
    }
    
    subsequence[subSize] = nums[index];
    backtrack(nums, numsSize, index + 1, subsequence, subSize + 1, m);
    
    backtrack(nums, numsSize, index + 1, subsequence, subSize, m);
}

long long maxProductOfFirstAndLast(int* nums, int numsSize, int m) {
    maxProduct = LLONG_MIN;
    int* subsequence = (int*)malloc(m * sizeof(int));
    backtrack(nums, numsSize, 0, subsequence, 0, m);
    free(subsequence);
    return maxProduct;
}

int main() {
    int nums[] = {1, 5, 3, 2, 4};
    int m = 3;
    printf("%lld\n", maxProductOfFirstAndLast(nums, 5, m));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × m)

2^n possible subsequences, each taking O(m) time to validate and process

⚠ Quadratic Growth

Space Complexity

O(2^n × m)

Storing all possible subsequences in worst case

⚠ Quadratic Space

31.7K Views

Medium 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 Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler