313. Super Ugly Number

A super ugly number is a positive integer whose prime factors are in the array primes.

Given an integer n and an array of integers primes, return the $n^{th}$ super ugly number.

The $n^{th}$ super ugly number is guaranteed to fit in a 32-bit signed integer.
 

Example 1:

Example 2:

Constraints:

• $1<=n<=10^5$
• 1 <= primes.length <= 100
• 2 <= primes[i] <= 1000
• primes[i] is guaranteed to be a prime number.
• All the values of primes are unique and sorted in ascending order.

From: LeetCode
Link: 313. Super Ugly Number

Solution:

Ideas:

• nextUgly: Changed the type from int to long long to prevent overflow when calculating the next ugly number.
• Casting: When assigning the value back to the ugly array, cast the result to int to match the expected return type and prevent further issues.

Code:

// Function to find the n-th super ugly number
int nthSuperUglyNumber(int n, int* primes, int primesSize) {
    int* ugly = (int*)malloc(n * sizeof(int));
    int* index = (int*)malloc(primesSize * sizeof(int));
    long long* nextUgly = (long long*)malloc(primesSize * sizeof(long long));
    
    ugly[0] = 1;
    
    for (int i = 0; i < primesSize; i++) {
        index[i] = 0;
        nextUgly[i] = primes[i];
    }
    
    for (int i = 1; i < n; i++) {
        long long next = nextUgly[0];
        for (int j = 1; j < primesSize; j++) {
            if (nextUgly[j] < next) {
                next = nextUgly[j];
            }
        }
        ugly[i] = (int)next;
        
        for (int j = 0; j < primesSize; j++) {
            if (nextUgly[j] == next) {
                index[j]++;
                nextUgly[j] = (long long)ugly[index[j]] * primes[j];
            }
        }
    }
    
    int result = ugly[n - 1];
    free(ugly);
    free(index);
    free(nextUgly);
    return result;
}