LeetCode刷题——279. 完全平方数

题目

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

示例 1:

  输入: n = 12
  输出: 3 
  解释: 12 = 4 + 4 + 4.
示例 2:

  输入: n = 13
  输出: 2
  解释: 13 = 4 + 9.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/perfect-squares

思路

这个题目和整数拆分类似，也是需要分割整数，不过要求不同。

与整数拆分一样，我们先来看一个简单的数字12。自顶向下的考虑问题，画出它的递归树。

这里主要画了9+1+1+1=12 和 4+4+4=12这两个路径。这里的递归终止条件是遇到了完全平方数(1,4,9…)。 虽然这里没有画出重叠子问题，但是显然是存在的，比如左边求解3和最右边的求解3(省略了，没画出来)。

基于此就可以开始实现递归版的代码了。

代码

递归

import math
class Solution:
    # 返回次数
    def num(self,n):
        # 递归终止条件，任何完全平方数都可以。如果对开根号的结果取整后等于取整前，说明是一个完全平方数。
        if math.sqrt(n) == int(math.sqrt(n)):
            return 1 # 返回次数1
        cur_min = n  # 当前最小次数，初始化为n

        # 从int(math.sqrt(n))到1进行拆分
        for i in range(int(math.sqrt(n)), 0, -1):
            # 递归计算不同平方数的拆分次数，并找到最小的
            cur_min = min(1 + self.num(n - (i ** 2)), cur_min)
        return cur_min

    def numSquares(self, n: int) -> int:
        return self.num(n)

代码很简单，来看下结果吧。

下面改成记忆化搜索的方式。

记忆化搜索

dp = {1:1}

class Solution(object):
    # 返回次数
    def num(self,n):
        # 递归返回条件，任何完全平方数都可以
        if n not in dp:
            if math.sqrt(n) == int(math.sqrt(n)):
                dp[n] = 1
                return 1

            cur_min = n  # 当前最小次数

            for i in range(int(math.sqrt(n)), 0, -1):
                cur_min = min(1 + self.num(n - (i ** 2)), cur_min)
            dp[n] = cur_min

        return dp[n]

    def numSquares(self, n):
        return self.num(n)

和递归的代码差不多，增加了一个​​dp​​字典来保存之前计算过的值。

此时代码就能通过了，最后改成动态规划。

动态规划

动态规划的写法和整数拆分类似。

class Solution(object):
    def numSquares(self, n):
        """
        :type n: int
        :rtype: int
        """
        # #dp[0]表示刚好分割结束，此时不占用分割次数。
        dp = [0] + [1] + [n] * (n-1)
        # 从2到n
        for i in range(2,n+1):
            #  依次计算dp[i]
            for j in range(int(math.sqrt(i)), 0, -1):
                dp[i] = min(1 + dp[i - (j ** 2)], dp[i])
        return dp[n]

第一次看到这个结果以为代码哪里写错了，然后去看了一下官方解析。改成了以下写法：

class Solution(object):
    def numSquares(self, n):
        """
        :type n: int
        :rtype: int
        """
        # 先计算出所有可能的平方数
        square_nums = [i**2 for i in range(0, int(math.sqrt(n))+1)]
        
        dp = [float('inf')] * (n+1) #初始化
        # bottom case
        dp[0] = 0
        
        for i in range(1, n+1):
            for square in square_nums:
                if i < square: #如果i - square < 0则终止
                    break
                dp[i] = min(dp[i], dp[i-square] + 1)
        
        return dp[-1]

这样确实快了一点，但还没有记忆化搜索快。

而且在Python3中都通不过，但是可以充分说明了动态规划的自底向上的思路是怎样的。