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. Your task is to select a subset of these numbers to form a symmetric mountain pattern following a very specific rule.

The selected elements must be arrangeable in a 0-indexed array that follows this 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 (0, 2, 4, 8, 16, ...).

Examples of valid patterns:

[2, 4, 16, 4, 2] ✅ (x=2, k=4: 2¹, 2², 2⁴, 2², 2¹)
[3, 9, 3] ✅ (x=3, k=2: 3¹, 3², 3¹)
[5] ✅ (x=5, k=0: just 5⁰ which is conceptually 5¹)

Invalid pattern:

[2, 4, 8, 4, 2] ❌ (k=3 is not a power of 2)

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

Input & Output

Time & Space Complexity

Time Complexity

⏱️

O(n + k×log(max_val))

O(n) to build frequency map, O(k×log(max_val)) where k is unique values and log factor comes from checking power chains

⚡ Linearithmic

Space Complexity

O(k)

Hash table stores at most k unique values from input array

✓ Linear Space

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n × log(max_value))	O(n)	Count frequencies first, then build maximum valid patterns for each base
Brute Force (Try All Subsets)	O(2^n × n²)	O(n)	Generate all possible subsets and check if each can form a valid symmetric pattern
One-Pass Hash Table (Optimal)	O(n + k×log(max_val))	O(k)	Build frequency map and find maximum pattern length in a single optimized pass

Two-Pass Hash Table — Algorithm Steps

First pass: Count frequency of each number using hash table
Get all unique numbers as potential base values
For each base value x, try to build longest symmetric pattern
Check availability of x², x⁴, x⁸, ... in the frequency map
Build pattern ensuring we have 2 of each power (except peak)
Return maximum pattern length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build hash table with count of each number

Try Each Base

For each unique number, attempt to build longest pattern

Build Pattern

Check x, x², x⁴, x⁸... availability in frequency map

Validate Symmetry

Ensure we have enough elements for symmetric pattern

Code -

solution.c — C

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

// Simple hash table implementation for C
#define HASH_SIZE 10007

typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

typedef struct {
    HashNode* buckets[HASH_SIZE];
} HashMap;

int hash(int key) {
    return abs(key) % HASH_SIZE;
}

void put(HashMap* map, int key, int value) {
    int index = hash(key);
    HashNode* node = map->buckets[index];
    
    while (node) {
        if (node->key == key) {
            node->value = value;
            return;
        }
        node = node->next;
    }
    
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = map->buckets[index];
    map->buckets[index] = newNode;
}

int get(HashMap* map, int key) {
    int index = hash(key);
    HashNode* node = map->buckets[index];
    
    while (node) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    
    return 0;
}

int maximumLength(int* nums, int numsSize) {
    HashMap freq = {0};
    
    // First pass: count frequencies
    for (int i = 0; i < numsSize; i++) {
        put(&freq, nums[i], get(&freq, nums[i]) + 1);
    }
    
    int maxLength = 1;
    
    // Second pass: check each unique number (simplified for C)
    for (int i = 0; i < numsSize; i++) {
        int base = nums[i];
        int count = get(&freq, base);
        
        if (base == 1) {
            if (count > maxLength) {
                maxLength = count;
            }
            continue;
        }
        
        // Simplified pattern checking for C
        // This is a basic implementation due to C's complexity
        int patternLength = 1;
        
        long long current = base;
        int powers = 1;
        
        while (current <= 1000000 && get(&freq, (int)current) > 0) {
            current = current * current;
            powers++;
            if (powers > 10) break; // Safety limit
        }
        
        if (patternLength > maxLength) {
            maxLength = patternLength;
        }
    }
    
    // Clean up hash table
    for (int i = 0; i < HASH_SIZE; i++) {
        HashNode* node = freq.buckets[i];
        while (node) {
            HashNode* temp = node;
            node = node->next;
            free(temp);
        }
    }
    
    return maxLength;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max_value))

O(n) to build frequency map, then O(unique_values × log(max_value)) to check patterns

⚡ Linearithmic

Space Complexity

O(n)

Hash table to store frequency of each unique number

⚡ Linearithmic Space

Constraints

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler