313. 超级丑数 力扣（中等） 动态规划，不会做

313. 超级丑数

超级丑数 是一个正整数，并满足其所有质因数都出现在质数数组 primes 中。

给你一个整数 n 和一个整数数组 primes ，返回第 n 个 超级丑数 。

题目数据保证第 n 个 超级丑数 在 32-bit 带符号整数范围内。

示例 1：

输入：n = 12, primes = [2,7,13,19]
输出：32
解释：给定长度为 4 的质数数组 primes = [2,7,13,19]，前 12 个超级丑数序列为：[1,2,4,7,8,13,14,16,19,26,28,32] 。

题解：

法一：优先队列，耗时，耗内存

法二：利用指针，动态规划，（建议先看 264. 丑数 II ），本博客：https://www.cnblogs.com/stepping/p/15120427.html

代码改进：

tle写法：

class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
     set<long long> s,ts;
     s.insert(1);
     ts.insert(1);
     for(int i=1;i<n;i++)
     {
         long long x=*s.begin();
         s.erase(x);
         for(auto j:primes)
         {
             if(ts.count(x*j)>0) continue;
             ts.insert(x*j);
             s.insert(x*j);
         }
     }
    return (int)(*s.begin());
    }
};

将ts改成map函数，来充当hash还是tle。

改进后：

//时间消耗：1688ms  内存消耗：116M
class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
     set<long long> s;
     s.insert(1);
     for(int i=1;i<n;i++)
     {
         long long x=*s.begin();
         s.erase(x);
         for(auto j:primes)
             s.insert(x*j);
     }
    return (int)(*s.begin());
    }
};

将s改成优先队列，过了，但是时间还是很长，优先队列默认从大到小！！priority_queue 比 set 高效！

//  消耗时长：1932ms， 消耗内存：144.3M
class Solution {
public:
    struct cmp{
        bool operator()(long long a,long long b)
        {
            return a>b;
        }
    };
    int nthSuperUglyNumber(int n, vector<int>& primes) {
     priority_queue<long long,vector<long long>,cmp> s;
     map<long long,bool> ts;
     s.push(1);
     ts[1]=1;
     for(int i=1;i<n;i++)
     {
         long long x=s.top();
         s.pop();
         for(auto j:primes)
         {
             if(ts.find(x*j)!=ts.end()) continue;
             ts[x*j]=1;
             s.push(x*j);
         }
     }
    return (int)(s.top());
    }
};

动态规划版本：

官方：

//执行用时：60 ms,内存消耗：8.7 MB,
class Solution {
public:
    int nthSuperUglyNumber(int n, vector<int>& primes) {
     int m=primes.size();
     vector<int> p(m,1);  // 全部赋值为1，也就是指向dp数组第一位
     int dp[1000005];
     dp[1]=1;  // 第一位丑数是1
     for(int i=2;i<=n;i++)
     {
         int minn=0x7fffffff;
         for(int j=0;j<m;j++)
             if (dp[p[j]]*primes[j]<minn) minn=dp[p[j]]*primes[j];
         dp[i]=minn;
         for(int j=0;j<m;j++)
             if (dp[p[j]]*primes[j]==dp[i]) p[j]++;
     }
     return dp[n];
    }
};