【动态规划】力扣650：只有两个键的键盘

最初记事本上只有一个字符 'A' 。你每次可以对这个记事本进行两种操作：
Copy All（复制全部）：复制这个记事本中的所有字符（不允许仅复制部分字符）。
Paste（粘贴）：粘贴 上一次 复制的字符。
给你一个数字 n ，你需要使用最少的操作次数，在记事本上输出 恰好 n 个 'A' 。返回能够打印出 n 个 'A' 的最少操作次数。
示例：

输入：3
输出：3
解释：
最初, 只有一个字符 'A'。
第 1 步, 使用 Copy All 操作。
第 2 步, 使用 Paste 操作来获得 'AA'。
第 3 步, 使用 Paste 操作来获得 'AAA'。

方法1：数学
首先写前几个函数值并观察规律：
1 2 3 4 5 6 7 8 9 10
| | | | | | | | | |
0 2 3 4 5 5 7 6 6 7

• 结论 1 ：f(2 * n) = f(n) + 2.
  这是因为我们需要先通过 f(n) 次操作得到 n，再复制粘贴(2步)得到 2 * n.
• 结论 2 ：对于质数 p，f(p) = p.
  这是因为要达到 p，只有复制 1，再粘贴 p - 1 次.
  从以上两个结论得到启发，我们考虑一个合数 n = p1 * p2 的达到方式，有三种途径可以达到 n:
  1 -> p1 * p2
  1 -> p1 -> p1 * p2
  1 -> p2 -> p1 * p2
  这些途径的步数分别为 p1 * p2, p1 + 1(复制) + (p2 - 1)(粘贴) = p1 + p2, p2 + 1(复制) + (p1 - 1)(粘贴) = p1 + p2.
  所以，f(p1 * p2) = p1 + p2.
  从而很容易推导出，若 n = p1 * p2 * ... * pi，其中 pi 为质数，则
  f(n) = p1 + p2 + ... + pi.
  进一步地，若 n = p1^r1 * p2^r2 * ... * pi^ri，其中 pi 为质数，ri >= 1，则
  f(n) = p1 * r1 + p2 * r2 + ... + pi * ri.
  也就是对 n 做质因数分解，并将所有质因数乘以它的幂次并相加即可。

class Solution:
    def minSteps(self, n: int) -> int:
        '''
        if n = 1:
            return 0
        '''
        res = 0 # n = 1 时返回 0，规律从 n = 2 开始
        m = n
        for i in range(2, n + 1):
            while m % i == 0:
                res += i
                m //= i
                # 可以加一个判断：当n为合数，m = 1时说明已经分解完成，不需要继续。但是由于若n为质数，i要循环到n才能停止，因此i的范围为[2, n]，而不能提前。（不加这一句不影响）
                if m == 1:
                    break
        return res

时间复杂度：O(n)。
空间复杂度：O(1)。

由于n为合数时i不需要遍历完，可以在这方面优化时间复杂度，但思路较复杂。

class Solution:
    def minSteps(self, n: int) -> int:
        ans = 0
        # 若n为合数，进入循环结束时n已经改变，是一个质数，进入质数阶段
        i = 2
        while i * i <= n:
            while n % i == 0:
                ans += i
                n //= i
            i += 1
        # 若n为质数，操作次数就是n，直接返回n。但若此时的n是循环结束来的，则结果为ans+n
        if n > 1:
            ans += n
        return ans

时间复杂度：O(sqrt(n))，即为质因数分解的时间复杂度。
空间复杂度：O(1)。

方法2：动态规划
也可以用动态规划根据上面的数学思路实现。
不同于以往通过加减实现的动态规划，这里需要乘除法来计算位置，因为粘贴操作是倍数增加的。我们使用一个一维数组 dp，其中位置 i 表示延展到长度 i 的最少操作次数。对于每个位置j，如果 j 可以被 i 整除，那么长度 i 就可以由长度 j 操作得到，其操作次数等价于把一个长度为 1的 A 延展到长度为 i/j。因此可以得到递推公式 dp[i] = dp[j] + dp[i/j]。

class Solution:
    def minSteps(self, n: int) -> int:
        dp = [0] * (n + 1)
        m = int(sqrt(n))
        for i in range(2, n + 1):
            dp[i] = i # 因为结果取min，初始的dp[i]就要尽量大，根据枚举发现dp[n]最大为n，所以可以初始化为而不是`inf`
            for j in range(2, m + 1):
                if i % j == 0:
                    dp[i] = dp[j] + dp[i//j]
                    break
        return dp[n]

时间复杂度：O(n×sqrt(n))，即为质因数分解的时间复杂度。
空间复杂度：O(n)。

标签：p2,键盘,p1,int,复杂度,力扣,650,质数,dp
来源： https://www.cnblogs.com/Jojo-L/p/16194186.html