0
点赞
收藏
分享

微信扫一扫

LeetCode //C - 313. Super Ugly Number

Villagers 2024-08-16 阅读 28

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 t h n^{th} nth super ugly number.

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

Example 1:
Example 2:
Constraints:
  • 1 < = n < = 1 0 5 1 <= n <= 10^5 1<=n<=105
  • 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;
}
举报

相关推荐

0 条评论