LeetCode Top 100 Liked Questions 279. Perfect Squares (Java版； Medium)

welcome to my blog

LeetCode Top 100 Liked Questions 279. Perfect Squares (Java版; Medium)

题目描述

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.

class Solution {
    public int numSquares(int n) {
        //dp[i]表示目标值为i时对应的最小值
        //dp[i] = 1 + min(dp[i-1], dp[i-4], ...)
        int[] dp = new int[n+1];
        for(int i=1; i<=n; i++){
            dp[i] = i;
            for(int j=1; i-j*j>=0; j++){
                dp[i] = Math.min(dp[i], 1 + dp[i-j*j]);
            }
        }
        return dp[n];
    }
}

第二次做; 暴力递归改动态规划; 核心: 1)dp数组整体初始化参考递归函数中的初始条件, 2) 单独初始化参考递归函数中的base case 3)递推公式参考递归函数中的"当前条件"和"新条件新递归"的关系

class Solution {
    public int numSquares(int n) {
        if(n<=0)
            return 0;
        /*
        dp[i]表示: 目标值为i时最少由几个完全平方数构成
        递推公式: dp[i] = min(dp[i], dp[i-a*a]+1)
        */
        int[] dp = new int[n+1];
        //对应递归函数中每个res的初始值
        for(int i=1; i<=n; i++){
            dp[i] = i;
        }
        //对应递归函数中的base case, 但是不用单独写出来了, 上面的循环已经实现了
        // dp[1]=1;
        
        //dp主体循环
        for(int i=2; i<=n; i++){
            int up = (int)Math.sqrt(i);
            for(int j=1; j<=up; j++){
                //1表示当前条件下使用了1个完全平方数
                dp[i] = Math.min(dp[i], dp[i-j*j]+1);
            }
        }
        return dp[n];
    }
}

第二次做; 暴力递归, 超时; 核心: 1)不要把最终结果当做递归函数的参数!!

class Solution {
    //暴力递归
    public int numSquares(int n) {
        if(n<=0)
            return 0;
        if(n==1)
            return 1;
        int up = (int)Math.sqrt(n);
        int res = n;//最差的情况是由n个1相加得到
        for(int i=1; i<=up; i++){
            int cur = numSquares(n-i*i);
            //1表示当前的情况
            res = Math.min(res, cur+1);
        }
        return res;
    }
}

/*
一开始的错误贪心思路
找到距离n最近的完全平方数
或者说找到小于等于n的完全平方数中最大的那个完全平方数
上面的逻辑是错误的!
比如说12
按上面的逻辑, 答案会是9 1 1 1
但正确答案是4 4 4 
*/

第一次做; 将暴力递归改成动态规划; 递归函数中的可变参数有两个, 但是其中一个是另一个的结果, 所以动态规划的数组是一维的; 本题是带枚举的动态规划

/*
用暴力递归写的时候没有意识到rest的最大值就是rest, 相当于rest个1相加得到rest
*/
class Solution {
    public int numSquares(int n) {
        if(n<1)
            return 0;
        int[] dp = new int[n+1];
        for(int i=1; i<=n; i++){
            //核心: dp[i]的最大值是i, 相当于i个1相加得到i
            dp[i] = i;
            //核心: j*j <= i, 要尝试各个可能的j, 因为有可能j*j==i
            for(int j=1; j*j <= i; j++){
                dp[i] = Math.min(dp[i], dp[i-j*j]+1);
            }
        }
        return dp[n];
    }
}

第一次做; 暴力递归, 第53个例子运行超时; 需要将暴力递归改成动态规划, gogogo!

class Solution {
    public int numSquares(int n) {
        //input check
        if(n<1)
            return 0;
        //
        int upper = (int)(Math.sqrt(n));
        int res = Core(upper, n, 0);
        return res;
    }
    public int Core(int upper, int rest, int count){
        //base case
        if(rest==0)
            return count;
        if(rest<0)
            return Integer.MAX_VALUE;
        //
        int res = rest;
        for(int i=upper; i>0; i--){
            if(i*i <= rest){
                res = Math.min(res, Core(upper, rest-i*i, count+1));
            }
        }
        return res;
    }
}

力扣优秀题解 内循环的逻辑判断条件很好; for(int j=1; i-j*j>=0; j++)

class Solution {
    public int numSquares(int n) {
        int[] dp = new int[n + 1]; // 默认初始化值都为0
        for (int i = 1; i <= n; i++) {
            dp[i] = i; // 最坏的情况就是每次+1
            for (int j = 1; i - j * j >= 0; j++) { 
                dp[i] = Math.min(dp[i], dp[i - j * j] + 1); // 动态转移方程
            }
        }
        return dp[n];
    }
}