Find the Maximum Number of Elements in Subset

Find the Maximum Number of Elements in Subset - Problem

You are given an array of positive integers nums. You need to select a subset of nums which satisfies the following condition:

You can place the selected elements in a 0-indexed array such that it follows the pattern: [x, x², x⁴, ..., x^(k/2), x^k, x^(k/2), ..., x⁴, x², x] where k can be any non-negative power of 2.

Note: The pattern forms a symmetric sequence where powers increase to the middle then decrease.

Examples of valid patterns:

[2, 4, 16, 4, 2] follows the pattern (x=2, k=4)
[3, 9, 3] follows the pattern (x=3, k=2)
[5] follows the pattern (x=5, k=0)

Invalid pattern: [2, 4, 8, 4, 2] does not follow the pattern because 8 ≠ 2⁴

Return the maximum number of elements in a subset that satisfies these conditions.

Input & Output

Example 1 — Valid Symmetric Pattern

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

› Output: 5

💡 Note: All elements can form pattern [2,4,16,4,2] where x=2, powers are [2¹,2²,2⁴,2²,2¹] - perfectly symmetric

Example 2 — Multiple Options

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

› Output: 3

💡 Note: Can form [2,4,2] using x=2 (length 3) or [4,16,4] using x=4 (length 3). Cannot use 8 as 8≠2⁴

Example 3 — Single Element

$ Input: nums = [5]

› Output: 1

💡 Note: Pattern [5] with x=5, k=0 is valid - single element always forms valid pattern

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15

The key insight is that valid subsets form symmetric patterns based on power sequences of base numbers. Count frequencies of each number, then for each potential base, try to build the longest power chain (base, base², base⁴, ...) and check if we have enough elements to form a symmetric pattern. Best approach uses frequency counting with chain building. Time: O(n × log(log(max_val))), Space: O(n)

Common Approaches

✓ Binary Search Answer

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

Brute Force - Try All Subsets

⏱️ Time: O(2ⁿ × n) Space: O(n)

For each subset, verify if it can be arranged in the required symmetric pattern [x, x², x⁴, ..., x^k, ..., x⁴, x², x]. This requires checking if elements form perfect square chains and can be arranged symmetrically.

Frequency Count with Chain Building

⏱️ Time: O(n × log(log(max_val))) Space: O(n)

Count frequency of each number, then for each potential base number, try to build the longest possible symmetric chain by following the power sequence. Use greedy approach to maximize chain length.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int threshold) {
    int left = 1;
    int right = nums[0];
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > right) {
            right = nums[i];
        }
    }
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        long long total = 0;
        
        for (int i = 0; i < numsSize; i++) {
            total += (long long)(nums[i] + mid - 1) / mid;  // ceiling division
        }
        
        if (total <= threshold) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

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[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n' && token[0] != ']') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int threshold;
    scanf("%d", &threshold);
    
    int result = solution(nums, numsSize, threshold);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

26.8K Views

Medium Frequency

~25 min Avg. Time

892 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