【Leetcode】完全平方数+最长上升子序列

暴力法 枚举+dfs+递归

暴力枚举法，我们枚举所有可能的组合，并找到完全平方数的个数最小的一个。

$$numSquares(n)=min(numSquares(n-k)+1)b\forall k\in squarenumbers$$

import math
def numSquares(n):
    square_nums = [i**2 for i in range(1, int(math.sqrt(n))+1)]
    def minNumSquares(k):
        """ recursive solution """
        # bottom cases: find a square number
        if k in square_nums:
            return 1
        min_num = float('inf')

        # Find the minimal value among all possible solutions
        for square in square_nums:
            if k < square: break
            new_num = minNumSquares(k-square) + 1
            min_num = min(min_num, new_num)
        return min_num

    return minNumSquares(n)

方法二：动态规划

使用暴力枚举法会超出时间限制的原因很简单，因为我们重复的计算了中间解。我们以前的公式仍然是有效的。我们只需要一个更好的方法实现这个公式。

$$\text{numSquares}(n)=\min \left(\text{numSquares(n-k) + 1}\right)\forall k\in \text{square numbers}$$

你可能注意到从公式看来，这个问题和斐波那契数问题类似。和斐波那契数一样，我们由几种更有效的方法来计算解，而不是简单的递归。

解决递归中堆栈溢出的问题的一个思路就是使用动态规划（DP）技术，该技术建立在重用中间解的结果来计算终解的思想之上。

要计算$$\text{numSquares}(n)$$ 的值，首先要计算 nn 之前的所有值，即 $$\text{numSquares}(n-k)\forall k\in \text{square numbers}$$。如果我们已经在某个地方保留了数字 n-kn−k 的解，那么就不需要使用递归计算。

import math
def numSquares(n):
    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:
                break
            dp[i] = min(dp[i], dp[i-square] + 1) 
    return dp[-1]

方法四：贪心 + BFS（广度优先搜索）

正如上述贪心算法的复杂性分析种提到的，调用堆栈的轨迹形成一颗 N 元树，其中每个结点代表 is_divided_by(n, count) 函数的调用。基于上述想法，我们可以把原来的问题重新表述如下：

class Solution:
    def numSquares(self, n):

        # list of square numbers that are less than `n`
        square_nums = [i * i for i in range(1, int(n**0.5)+1)]
    
        level = 0
        queue = {n}
        while queue:
            level += 1
            #! Important: use set() instead of list() to eliminate the redundancy,
            # which would even provide a 5-times speedup, 200ms vs. 1000ms.
            next_queue = set()
            # construct the queue for the next level
            for remainder in queue:
                for square_num in square_nums:    
                    if remainder == square_num:
                        return level  # find the node!
                    elif remainder < square_num:
                        break
                    else:
                        next_queue.add(remainder - square_num)
            queue = next_queue
        return level

最长上升子序列