Maximize Number of Nice Divisors

Maximize Number of Nice Divisors - Problem

You are given a positive integer primeFactors. You need to construct a positive integer n that satisfies the following conditions:

The number of prime factors of n (not necessarily distinct) is at most primeFactors.
The number of nice divisors of n is maximized.

Note: A divisor of n is nice if it is divisible by every prime factor of n. For example, if n = 12, then its prime factors are [2,2,3], so 6 and 12 are nice divisors, while 3 and 4 are not.

Return the number of nice divisors of n. Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: primeFactors = 5

› Output: 6

💡 Note: Optimal partition is [3,2] giving us nice divisors = 3 × 2 = 6. The number could be 2³×3² with nice divisors being multiples of 2×3=6.

Example 2 — All 3s

$ Input: primeFactors = 8

› Output: 18

💡 Note: 8 % 3 = 2, so we use [3,3,2] partition. Nice divisors = 3 × 3 × 2 = 18.

Example 3 — Small Input

$ Input: primeFactors = 4

› Output: 4

💡 Note: For small inputs ≤ 4, the answer is the number itself. Partition [4] or [2,2] both give 4.

Constraints

1 ≤ primeFactors ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The key insight is that to maximize the product of exponents with a fixed sum, we should use as many 3s as possible in our partition, with special handling for remainders. The optimal approach uses mathematical optimization achieving O(log n) time complexity by recognizing that 3^(n/3) maximizes the product for large sums.

Common Approaches

✓ Brute Force - Try All Partitions

⏱️ Time: O(2^n) Space: O(2^n)

Generate all possible partitions of primeFactors into positive integers, construct the corresponding number n for each partition, and count nice divisors. This approach explores every possible way to distribute the prime factors.

Mathematical Optimization

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

Apply the mathematical principle that to maximize a product with a fixed sum, we should use as many 3s as possible, with special handling for remainders. This is based on the fact that 3^(n/3) > 2^(n/2) for large n.

Brute Force - Try All Partitions — Algorithm Steps

Generate all partitions of primeFactors
For each partition, construct number n
Count nice divisors for each n
Return maximum count

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Create all ways to split primeFactors into positive integers

Count Nice Divisors

For each partition, calculate the product of exponents

Find Maximum

Return the partition with maximum nice divisors

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_PARTITIONS 10000

int partitions[MAX_PARTITIONS][100];
int partitionSizes[MAX_PARTITIONS];
int numPartitions;

void generatePartitions(int n, int maxVal, int current[], int currentSize, int index) {
    if (n == 0) {
        for (int i = 0; i < currentSize; i++) {
            partitions[numPartitions][i] = current[i];
        }
        partitionSizes[numPartitions] = currentSize;
        numPartitions++;
        return;
    }
    
    for (int i = 1; i <= (n < maxVal ? n : maxVal); i++) {
        current[currentSize] = i;
        generatePartitions(n - i, i, current, currentSize + 1, index + 1);
    }
}

long long countNiceDivisors(int partition[], int size) {
    long long result = 1;
    for (int i = 0; i < size; i++) {
        result = (result * partition[i]) % MOD;
    }
    return result;
}

int solution(int primeFactors) {
    numPartitions = 0;
    int current[100];
    generatePartitions(primeFactors, primeFactors, current, 0, 0);
    
    long long maxDivisors = 0;
    for (int i = 0; i < numPartitions; i++) {
        long long divisors = countNiceDivisors(partitions[i], partitionSizes[i]);
        if (divisors > maxDivisors) {
            maxDivisors = divisors;
        }
    }
    
    return (int) maxDivisors;
}

int main() {
    int primeFactors;
    scanf("%d", &primeFactors);
    printf("%d\n", solution(primeFactors));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Generating all partitions takes exponential time in primeFactors

⚡ Linearithmic

Space Complexity

O(2^n)

Storing all partitions requires exponential space

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

567 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 - Try All Partitions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler