【LeetCode: 279. 完全平方数 | 暴力递归=＞记忆化搜索=＞动态规划 | 背包模型】

🚀 算法题 🚀

🌲 算法刷题专栏 | 面试必备算法 | 面试高频算法 🍀
🌲 越难的东西,越要努力坚持，因为它具有很高的价值，算法就是这样✨
🌲 作者简介：硕风和炜，优快云-Java领域优质创作者🏆，保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享💎💎💎
🌲 恭喜你发现一枚宝藏博主,赶快收入囊中吧🌻
🌲 人生如棋，我愿为卒，行动虽慢，可谁曾见我后退一步？🎯🎯

🚀 算法题 🚀

🚩 题目链接

• 279. 完全平方数

⛲ 题目描述

给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。

完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

示例 1：

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

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

提示：

1 <= n <= 104

🌟 求解思路&实现代码&运行结果

---

⚡ 暴力法

🥦 求解思路

1. 我们先来读一下题目的意思，题目让我们求的是和为 n 的完全平方数的最少数量是多少，那么我们怎么做呢？我们是不是可以先把所有小于n的所有完全平方数都存起来，然后从我们的容器中选择满足要求的完全平方数，并记录个数，最后返回满足题目要求最少的个数即可。
2. 如果之前对背包模型有印象的同学就可以很容易的看出来这是一个完全背包问题，稍微转换一下就可以做。
3. 有了基本的思路，接下来我们就来通过代码来实现一下。

🥦 实现代码

注意：这个递归函数为了大家更好理解，还有一个更好的递归函数就是省略我们的index位置，因为index状态是不影响我们最终的结果的，可以省略，此处大家需要注意，感兴趣的同学可以自行实现。

class Solution {
    public int numSquares(int n) {
        int m=(int)(Math.sqrt(n));
        int[] arr=new int[m];
        for(int i=1;i<=m;i++){
            arr[i-1]=i*i;
        }
        return process(0,n,arr);
    }

    public int process(int index,int sum,int[] arr){
        if(sum==0) return 0;
        if(index>=arr.length||sum<0){
            return Integer.MAX_VALUE;
        }
        int min=Integer.MAX_VALUE;
        for(int i=index;i<arr.length;i++){
            int temp=process(i,sum-arr[i],arr);
            if(temp!=Integer.MAX_VALUE){
                min=Math.min(min,process(i,sum-arr[i],arr)+1);
            }
        }
        return min;
    }
}

🥦 运行结果

时间超限了，不要紧张，我们来继续优化它！

---

⚡ 记忆化搜索

🥦 求解思路

1. 因为在递归的过程中，会重复的出现一些多次计算的结果，我们通过开辟一个数组，将结果提前缓存下来，算过的直接返回，避免重复计算，通过空间来去换我们的时间。

🥦 实现代码

class Solution {
    int[][] dp;
    public int numSquares(int n) {
        int m=(int)(Math.sqrt(n));
        int[] arr=new int[m];
        dp=new int[m+1][n+1];
        for(int i=0;i<dp.length;i++) Arrays.fill(dp[i],-1);
        for(int i=1;i<=m;i++){
            arr[i-1]=i*i;
        }
        return process(0,n,arr);
    }

    public int process(int index,int sum,int[] arr){
        if(sum==0) return 0;
        if(index>=arr.length||sum<0){
            return Integer.MAX_VALUE;
        }
        if(dp[index][sum]!=-1) return dp[index][sum];
        int min=Integer.MAX_VALUE;
        for(int i=index;i<arr.length;i++){
            int temp=process(i,sum-arr[i],arr);
            if(temp!=Integer.MAX_VALUE){
                min=Math.min(min,process(i,sum-arr[i],arr)+1);
            }
        }
        return dp[index][sum]=min;
    }
}

🥦 运行结果

依旧没有通过，此时我们有俩种选择，第一种是继续向下做，将记忆化搜索改为动态规划，第二种是修改我们的递归函数，递归函数的状态有设置的不好，可以继续修改。

---

⚡ 动态规划

🥦 求解思路

1. 有了递归，有了记忆化搜索，接下来就是动态规划了，直接上手。

🥦 实现代码

class Solution {
    int[] dp;
    public int numSquares(int n) {
        int m=(int)(Math.sqrt(n));
        int[] arr=new int[m];
        dp=new int[n+1];
        Arrays.fill(dp,Integer.MAX_VALUE);
        dp[0]=0;
        for(int i=1;i<=m;i++){
            arr[i-1]=i*i;
        }
        for(int i=0;i<arr.length;i++){
            for(int target=0;target<=n;target++){
                if(target>=arr[i]){
                    dp[target]=Math.min(dp[target-arr[i]]+1,dp[target]);
                }
            }
        }
        return dp[n];
    }
}

🥦 运行结果

---

💬 共勉

最后，我想和大家分享一句一直激励我的座右铭，希望可以与大家共勉！