LeetCode--313--medium--SuperUglyNumber

package com.app.main.LeetCode.dynamic;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 313
 *
 * medium
 *
 * https://leetcode.com/problems/super-ugly-number/
 *
 * Write a program to find the nth super ugly number.
 *
 * Super ugly numbers are positive numbers whose all prime factors are in the given prime list primes of size k.
 *
 * Example:
 *
 * Input: n = 12, primes = [2,7,13,19]
 * Output: 32
 * Explanation: [1,2,4,7,8,13,14,16,19,26,28,32] is the sequence of the first 12
 *              super ugly numbers given primes = [2,7,13,19] of size 4.
 * Note:
 *
 * 1 is a super ugly number for any given primes.
 * The given numbers in primes are in ascending order.
 * 0 < k ≤ 100, 0 < n ≤ 106, 0 < primes[i] < 1000.
 *
 *
 * Created with IDEA
 * author:Dingsheng Huang
 * Date:2019/12/23
 * Time:下午8:05
 */
public class SuperUglyNumber {

    public int nthSuperUglyNumber(int n, int[] primes) {
        int[] dp1 = new int[n];
        dp1[0] = 1;
        int[] dp2 = new int[primes.length];
        int[] dp3 = new int[primes.length];
        for (int i = 0; i < primes.length; i++) {
            dp2[i] = 0;
            dp3[i] = primes[i];
        }
        List<Integer> list = new ArrayList<>();
        for (int i = 1; i < n; i++) {
            list.clear();
            int min = dp3[0];
            list.add(0);
            for (int j = 1; j < primes.length; j++) {
                if (dp3[j] < min) {
                    min = dp3[j];
                    list.clear();
                    list.add(j);
                } else if (dp3[j] == min) {
                    list.add(j);
                }
            }
            dp1[i] = min;
            for (int k : list) {
                dp2[k] = dp2[k] + 1;
                dp3[k] = dp1[dp2[k]] * primes[k];
            }

        }
        return dp1[n - 1];
    }
}