leetcode 279. Perfect Squares (python)

努利！奋斗！

已于 2022-06-24 12:52:59 修改

阅读量1.1k

点赞数

分类专栏： Leetcode DFS 文章标签： leetcode python 算法

于 2019-12-30 11:51:29 首次发布

本文链接：https://blog.youkuaiyun.com/qq_37821701/article/details/103762724

版权

Leetcode DFS 专栏收录该内容

31 篇文章

订阅专栏

该博客探讨了LeetCode第279题，即找到最少的完美平方数之和来表示给定正整数n。博主介绍了三种解法：动态规划(DP)、广度优先搜索(BFS)和拉格朗日四平方和定理。DP方法由于时间复杂度较高，效率较低；BFS方法在时间复杂度和空间复杂度上都有较好表现；而利用拉格朗日定理的方法在时间和空间上最优。每种解法都附有相应的c++实现和复杂度分析。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

Given a positive integer n, find the least number of perfect square numbers (for example, 1, 4, 9, 16, …) which sum to n.

Example 1:
Input: n = 12
Output: 3
Explanation: 12 = 4 + 4 + 4.

Example 2:
Input: n = 13
Output: 2
Explanation: 13 = 4 + 9.

解法1：DP

递推公式为：

while j**2<=i:	  
      dp[i] = min(dp[i],dp[i-j**2]+1)

代码

class Solution(object):
    def numSquares(self, n):
        """
        :type n: int
        :rtype: int
        """    
        if n == 0:
            return 0
        dp = [float('inf')]*(n+1)
        dp[0] = 0
        dp[1] = 1
        for i in range(2,n+1):
            j = 1
            while j**2<=i:
                dp[i] = min(dp[i],dp[i-j**2]+1)
                j+=1
        return dp[n]

c++版本

class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n+1,INT_MAX);
        dp[0] = 0;
        vector<int> square_num;
        for(int i=1;i<=n/2+1;i++){
            square_num.push_back(i*i);
        }
        // dp[1] = 1;
        for(int i=1;i<n+1;i++){
            for(int j=0;j<square_num.size();j++){
                if(i<square_num[j]) break;
                // cout << i << square_num[j] << endl;
                dp[i] = min(dp[i-square_num[j]]+1,dp[i]);
            }
        }
        return dp.back();
    }
};

时间复杂度：O(N^3/2), 循环N次，每次尝试N的根号次
空间复杂度：O(N)
这种方法在时间上只超过了%19的用户，证明这种方法速度并不理想

解法2：BFS

算法流程

将所有可能合成目标数的perfect square数存在一个base中
将现在剩下需要合成的sum，以及已经花掉的step数以pair的方式存到栈中
搜索base中可以作为candidate的perfect square数,并将形成的符合条件的pair压入堆栈
注意为了得到的结果一定是最短的步数，需要从大到小搜索base，并且以队列方式先进先出FIFO
为了进一步加快速度，构建一个visited集合，储存所有已经出现过的curr_left,就是剩下需要被合成的sum
当curr_left存在与base中时，证明需要step最少的合成方式已经找到

class Solution(object):
    def numSquares(self, n):
        """
        :type n: int
        :rtype: int
        """    
        if n<1:
            return 0
        
        base = [i**2 for i in range(1,int(math.floor(math.sqrt(n))+1))]
        stack = collections.deque()
        stack.append((n,0))
        visited = set()
        visited.add(n)
        while stack:
            curr_left,curr_step = stack.popleft()
            if curr_left in base:
                return curr_step+1
            for j in reversed(base):
                if curr_left-j>0 and curr_left-j not in visited:
                    stack.append((curr_left-j,curr_step+1))
                    visited.add(curr_left-j)

时间复杂度：O(N)
空间复杂度：O(N)
这种方法超过了%92.5的用户

c++版本

class Solution {
public:
    int numSquares(int n) {
        vector<int> square_num;
        unordered_map<int,bool> memo;
        for(int i=n/2+1;i>=1;i--){
            square_num.push_back(i*i);
            memo[i*i] = true;
        }
        
        vector<int> visited(n+1,0);
        queue<pair<int,int>> q;
        q.push(make_pair(n,0));
        visited[n] = 1;
        while(!q.empty()){
            int curr_left = q.front().first, curr_step = q.front().second;
            q.pop();
            if(memo.count(curr_left)) return curr_step+1;
            for(auto& num : square_num){
                if(curr_left > num && visited[curr_left-num]==0){
                    q.push(make_pair(curr_left-num,curr_step+1));
                    visited[curr_left-num] = 1;
                }
            }
        }
        return -1;
    }
};

解法3：lagrange四平方和定理

四平方和定理如下：

class Solution(object):
    def numSquares(self, n):
        """
        :type n: int
        :rtype: int
        """
        while n%4 == 0:
            n//=4
        #case 1
        if n%8 == 7:
            return 4
        #case 2
        if int(n**0.5)**2 == n:
            return 1
        #case 3
        i = 1
        while i**2 < n:
            left = n-i**2
            if int(left**0.5)**2 == left:
                return 2
            i+=1
        #case 4
        return 3

时间复杂度：O(N^1/2)
空间复杂度：O(1)这种解法从时间和空间上都是最优的，超过了%99的用户
注意这边判断一个数是否能开平方的方法
参考：
https://blog.youkuaiyun.com/l_mark/article/details/89044137
https://blog.youkuaiyun.com/huhehaotechangsha/article/details/86597713