Maximum Element-Sum of a Complete Subset of Indices

Maximum Element-Sum of a Complete Subset of Indices - Problem

You are given a 1-indexed array nums. Your task is to find the complete subset with the maximum sum, where a complete subset is defined as a collection of indices where every pair of indices when multiplied results in a perfect square.

More formally, if you select indices i and j in your subset, then i * j must be a perfect square (like 1, 4, 9, 16, 25, etc.).

Goal: Return the maximum sum of elements from such a complete subset.

Example: For array [8, 7, 3, 5, 7, 2, 4, 9], indices 1 and 4 can be selected together because 1 * 4 = 4 (perfect square), giving us elements 8 + 5 = 13.

Input & Output

example_1.py — Python

$ Input: [8, 7, 3, 5, 7, 2, 4, 9]

› Output: 35

💡 Note: The indices are grouped by square-free signatures: {1,4} have signature 1, {2,8} have signature 2, {3} has signature 3, etc. The complete subsets are {1,4}, {2,8}, {3}, {5}, {6}, {7}. Maximum sum = 8+5 + 7+9 + 3 + 7 + 2 + 4 = 35.

example_2.py — Python

$ Input: [5, 10, 3, 10, 1, 13, 7, 9, 4]

› Output: 50

💡 Note: Grouping by square-free signatures: indices {1,4,9} all have signature 1 (since 1×1=1, 1×4=4, 1×9=9, 4×4=16, 4×9=36, 9×9=81 are all perfect squares). Sum = 5+10+4 = 19 for this group, plus individual elements from other groups.

example_3.py — Python

$ Input: [1]

› Output: 1

💡 Note: Edge case with single element. Index 1 forms a complete subset by itself (no pairs to check). Answer is simply nums[0] = 1.

Visualization

Tap to expand

Understanding the Visualization

Identify Harmony Groups

Seats 1,4,9,16... have harmony signature 1 and can all sit together

Group by Signature

Seats 2,8,18,32... have harmony signature 2 and form another group

Calculate Group Values

Sum the ticket prices within each harmony group

Maximize Revenue

Add up all group totals for maximum theater revenue

Key Takeaway

🎯 Key Insight: Indices with the same square-free factorization signature can all be selected together, forming complete subsets where every pair multiplies to a perfect square. This mathematical property allows us to group indices efficiently and sum their corresponding array elements for the optimal solution.

Time & Space Complexity

Time Complexity

⏱️

O(n√m)

We process each of n indices, and computing square-free part takes O(√m) where m is the maximum index value

✓ Linear Growth

Space Complexity

O(n)

Space for hash map to store groups of indices by their square-free signature

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ nums[i] ≤ 10⁹
Array is 1-indexed for the purpose of computing products

Asked in

G Google 23 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses square-free factorization to group indices. The key insight is that two numbers multiply to form a perfect square if and only if they have the same square-free part in their prime factorization. We compute the square-free signature for each index and group them accordingly, then sum all elements within each group for the maximum result in O(n√m) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Square-Free Factorization (Optimal)	O(n√m)	O(n)	Group indices by their square-free part and sum the maximum from each group
Brute Force (Check All Subsets)	O(n * 2^n)	O(n)	Generate all possible subsets and verify each one forms a complete subset

Square-Free Factorization (Optimal) — Algorithm Steps

For each index, compute its square-free part (remove perfect square factors)
Group indices that have the same square-free part
For each group, sum all corresponding array elements
Return the sum across all groups as the maximum possible sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Compute Square-Free

For each index, remove perfect square factors to get square-free part

Group by Signature

Group indices with the same square-free signature together

Sum Groups

Sum array elements within each group

Total Result

Add up sums from all groups for final answer

Code -

solution.c — C

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

typedef struct {
    int key;
    long long value;
} Group;

int getSquareFree(int n) {
    int result = 1;
    for (int i = 2; i * i <= n; i++) {
        int count = 0;
        while (n % i == 0) {
            n /= i;
            count++;
        }
        if (count % 2 == 1) {
            result *= i;
        }
    }
    if (n > 1) {
        result *= n;
    }
    return result;
}

long long maximumSum(int* nums, int n) {
    Group groups[1000];
    int groupCount = 0;
    
    for (int i = 0; i < n; i++) {
        int index = i + 1; // 1-indexed
        int squareFree = getSquareFree(index);
        
        // Find or create group
        int found = -1;
        for (int j = 0; j < groupCount; j++) {
            if (groups[j].key == squareFree) {
                found = j;
                break;
            }
        }
        
        if (found == -1) {
            groups[groupCount].key = squareFree;
            groups[groupCount].value = nums[i];
            groupCount++;
        } else {
            groups[found].value += nums[i];
        }
    }
    
    long long total = 0;
    for (int i = 0; i < groupCount; i++) {
        total += groups[i].value;
    }
    
    return total;
}

int main() {
    int nums[100];
    int n = 0;
    char c;
    
    scanf("%c", &c); // Read '['
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    printf("%lld\n", maximumSum(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n√m)

We process each of n indices, and computing square-free part takes O(√m) where m is the maximum index value

✓ Linear Growth

Space Complexity

O(n)

Space for hash map to store groups of indices by their square-free signature

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ nums[i] ≤ 10⁹
Array is 1-indexed for the purpose of computing products

54.0K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Square-Free Factorization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler