Maximum Subarray With Equal Products

Maximum Subarray With Equal Products - Problem

Array Math Sliding Window Enumeration Number Theory Easy

You are given an array of positive integers nums.

An array arr is called product equivalent if prod(arr) == lcm(arr) * gcd(arr), where:

prod(arr) is the product of all elements of arr
gcd(arr) is the GCD of all elements of arr
lcm(arr) is the LCM of all elements of arr

Return the length of the longest product equivalent subarray of nums.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Only single-element subarrays are product equivalent. For [1]: product=1, gcd=1, lcm=1, so 1 = 1×1 ✓. For [1,2]: product=2, gcd=1, lcm=2, so 2 ≠ 1×2 ✗.

Example 2 — Multiple Equal Elements

$ Input: nums = [6,6]

› Output: 2

💡 Note: The subarray [6,6] is product equivalent: product=36, gcd=6, lcm=6, so 36 = 6×6 ✓. Length is 2.

Example 3 — Single Element Only

$ Input: nums = [2,4,8]

› Output: 2

💡 Note: Single elements don't work since for [a]: product=a, gcd=a, lcm=a requires a=a×a (impossible for a>1). But [2,4] has product=8, gcd=2, lcm=4, so 8 = 2×4 ✓, giving length 2.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8

The key insight is that product equals GCD×LCM only in special mathematical cases, typically when elements are identical or have specific divisibility relationships. Best approach uses optimized enumeration with early termination. Time: O(n²), Space: O(1)

Common Approaches

✓ Brute Force - Check All Subarrays

⏱️ Time: O(n³) Space: O(1)

For each possible subarray, calculate the product, GCD, and LCM of all elements, then check if product equals GCD × LCM. Track the maximum length found.

Optimized - Early Mathematical Insights

⏱️ Time: O(n²) Space: O(1)

Recognize that product equals GCD×LCM only in special cases, like single elements or arrays where all elements share specific relationships. Use this insight to optimize checks.

Brute Force - Check All Subarrays — Algorithm Steps

Step 1: Generate all possible subarrays using nested loops
Step 2: For each subarray, calculate product, GCD, and LCM
Step 3: Check if product == GCD × LCM and update maximum length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible subarrays using nested loops

Calculate Values

For each subarray, compute product, GCD, and LCM

Check Condition

Verify if product equals GCD × LCM and track max length

Code -

solution.c — C

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

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

long long lcm(int a, int b) {
    return (long long)a * b / gcd(a, b);
}

int solution(int* nums, int numsSize) {
    int maxLength = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Calculate product
            long long product = 1;
            for (int k = i; k <= j; k++) {
                product *= nums[k];
            }
            
            // Calculate GCD
            int currentGcd = nums[i];
            for (int k = i + 1; k <= j; k++) {
                currentGcd = gcd(currentGcd, nums[k]);
            }
            
            // Calculate LCM
            long long currentLcm = nums[i];
            for (int k = i + 1; k <= j; k++) {
                currentLcm = lcm(currentLcm, nums[k]);
            }
            
            // Check if product equivalent
            if (product == (long long)currentGcd * currentLcm) {
                int length = j - i + 1;
                if (length > maxLength) {
                    maxLength = length;
                }
            }
        }
    }
    
    return maxLength;
}

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[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int count = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            nums[count++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, count);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested operations: O(n²) subarrays × O(n) to calculate GCD/LCM for each

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses variables to track current calculations and maximum length

✓ Linear Space

12.5K Views

Medium Frequency

~25 min Avg. Time

234 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 - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler