Super Ugly Number

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
        int k = primes.size();
        vector<int> dp(n);
        vector<int> idx(k, 0);
        dp[0] = 1;
        for (int i = 1; i < n; ++i) {
            int next = INT_MAX;
            for (int j = 0; j < k; ++j)
                next = min(next, primes[j] * dp[idx[j]]);
            dp[i] = next;
            for (int j = 0; j < k; ++j)
                if (primes[j] * dp[idx[j]] == next) ++idx[j];
        }
        return dp[n - 1];
    }
};

import "math"

func nthSuperUglyNumber(n int, primes []int) int {
  k := len(primes)
  dp := make([]int, n)
  idx := make([]int, k)
  dp[0] = 1
  for i := 1; i < n; i++ {
    next := math.MaxInt32
    for j := 0; j < k; j++ {
      v := primes[j] * dp[idx[j]]
      if v < next {
        next = v
      }
    }
    dp[i] = next
    for j := 0; j < k; j++ {
      if primes[j]*dp[idx[j]] == next {
        idx[j]++
      }
    }
  }
  return dp[n-1]
}

from typing import List

class Solution:
    def nthSuperUglyNumber(self, n: int, primes: List[int]) -> int:
        k = len(primes)
        dp = [0] * n
        idx = [0] * k
        dp[0] = 1
        for i in range(1, n):
            nxt = min(primes[j] * dp[idx[j]] for j in range(k))
            dp[i] = nxt
            for j in range(k):
                if primes[j] * dp[idx[j]] == nxt:
                    idx[j] += 1
        return dp[n - 1]

var nthSuperUglyNumber = function(n, primes) {
    const k = primes.length;
    const dp = new Array(n).fill(0);
    const idx = new Array(k).fill(0);
    dp[0] = 1;
    for (let i = 1; i < n; i++) {
        let next = Infinity;
        for (let j = 0; j < k; j++) {
            next = Math.min(next, primes[j] * dp[idx[j]]);
        }
        dp[i] = next;
        for (let j = 0; j < k; j++) {
            if (primes[j] * dp[idx[j]] === next) idx[j]++;
        }
    }
    return dp[n - 1];
};

class Solution {
    public int nthSuperUglyNumber(int n, int[] primes) {
        int k = primes.length;
        int[] dp = new int[n];
        int[] idx = new int[k];
        dp[0] = 1;
        for (int i = 1; i < n; i++) {
            int next = Integer.MAX_VALUE;
            for (int j = 0; j < k; j++) {
                next = Math.min(next, primes[j] * dp[idx[j]]);
            }
            dp[i] = next;
            for (int j = 0; j < k; j++) {
                if (primes[j] * dp[idx[j]] == next) idx[j]++;
            }
        }
        return dp[n - 1];
    }
}

function nthSuperUglyNumber(n: number, primes: number[]): number {
    const k: number = primes.length;
    const dp: number[] = new Array(n).fill(0);
    const idx: number[] = new Array(k).fill(0);
    dp[0] = 1;
    for (let i = 1; i < n; i++) {
        let next: number = Infinity;
        for (let j = 0; j < k; j++) {
            next = Math.min(next, primes[j] * dp[idx[j]]);
        }
        dp[i] = next;
        for (let j = 0; j < k; j++) {
            if (primes[j] * dp[idx[j]] === next) idx[j]++;
        }
    }
    return dp[n - 1];
}