动态规划 | 堆：力扣264. 丑数 II

1、题目描述：

2、题解：

方法1：动态规划

动态规划问题，弄清楚三点：

1、重复子问题；
2、最优子结构；
3、无后效性。
动态规划：

1、状态定义；
2、状态转移方程；
3、初始化；base case
4、输出；
5、思考状态压缩。
可以用递归去求，但是会存在重叠子问题，加个备忘录可以解决重复问题。

 一个十分巧妙的动态规划问题
 1.我们将前面求得的丑数记录下来，后面的丑数就是前面的丑数*2，*3，*5
 2.但是问题来了，我怎么确定已知前面k-1个丑数，我怎么确定第k个丑数呢
 3.采取用三个指针的方法，p2,p3,p5
 4.index2指向的数字下一次永远*2，p3指向的数字下一次永远*3，p5指向的数字永远*5
 5.我们从2*p2 3*p3 5*p5选取最小的一个数字，作为第k个丑数
 6.如果第K个丑数==2*p2，也就是说前面0-p2个丑数*2不可能产生比第K个丑数更大的丑数了，所以p2++
 7.p3,p5同理
 8.返回第n个丑数

状态定义:dp[i] 为第i + 1个丑数
状态转移方程：dp[i] = min(dp[p2] * 2,dp[p3] * 3,dp[p5] * 5)
初始化：dp[0,...,n] = 0 dp[0] = 1
输出：dp[n - 1]

python 代码：

class Solution:
    def nthUglyNumber(self, n: int) -> int:
        #动态规划
        p2,p3,p5 = 0,0,0 
        dp = [0] * n 
        dp[0] = 1
        i = 1
        while i != n:
            dp[i] = min(dp[p2] * 2,dp[p3] * 3,dp[p5] * 5)
            if dp[i] == dp[p2] * 2:p2 += 1
            if dp[i] == dp[p3] * 3:p3 += 1
            if dp[i] == dp[p5] * 5:p5 += 1
            i += 1
        return dp[n-1]

C++代码如下：

class Solution {
public:
    int nthUglyNumber(int n) {
        // 动态规划
        int p2 = 0,p3 = 0,p5 = 0;
        vector<int> dp(n);
        dp[0] = 1;
        for (int i = 1;i < n ;i++)
        {
            dp[i] = min(min(dp[p2] * 2,dp[p3] * 3),dp[p5] * 5 );
            if(dp[i] == dp[p2] * 2) p2 ++;
            if (dp[i] == dp[p3] * 3) p3++;
            if (dp[i] == dp[p5] * 5) p5++;
        }
        return dp[n - 1];
    }
};

方法2：堆

从堆中取值，依次把2,3，5的倍数放进堆里，还要注意去重。
python 代码：

class Solution:
    def nthUglyNumber(self, n: int) -> int:
        #堆
        import heapq 
        heap = [1]
        res = 0
        for _ in range(n):
            res = heapq.heappop(heap)
            while heap and res == heap[0]:
                res = heapq.heappop(heap)
            for i in [2,3,5]:
                temp = res * i 
                heapq.heappush(heap,temp)
        return res

3、复杂度分析：

时间复杂度：O（1），时间检索答案和大约1690×5=8450 次的预计算操作。
空间复杂度：O(1)，常数空间
这个分析做的不是太好，之后再次分析