LeetCode279 完全平方数

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

示例 1：

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

示例 2：

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

提示：

  • 1 <= n <= 104

MySolution

采用回溯算法，爆内存了，寄！

 class Solution {
 ​
     int min_num;
 ​
     public int numSquares(int n) {
         this.min_num = n;
 ​
         int t = (int) Math.ceil(Math.sqrt(n));
         List<Integer> list = new ArrayList<>();
 ​
         for (int i = t; i >= 1; i--) {
             backtrack(n, i, list);
             list.clear();
         }
         return min_num;
     }
 ​
     public void backtrack(int n, int i, List<Integer> state) {
         if (n - i * i > 0) {
             state.add(i * i);
             n = n - i * i;
             for (int j = (int) Math.ceil(Math.sqrt(n)); j >= 1; j--) {
                 if (n - j * j >= 0) {
                     backtrack(n, j, state);
                 }
             }
         }
         if (n - i * i == 0) {
             state.add(i * i);
             System.out.println(state);
             min_num = Math.min(min_num, state.size());
         }
     }
 }

Solution

  1. 首先初始化长度为 n+1 的数组 dp，每个位置都为 0

  2. 如果 n 为 0，则结果为 0

  3. 对数组进行遍历，下标为 i，每次都将当前数字先更新为最大的结果，即 dp[i]=i，比如 i=4，最坏结果为 4=1+1+1+1 即为 4 个数字

  4. 动态转移方程为：dp[i] = MIN(dp[i], dp[i - j * j] + 1)，i 表示当前数字，j*j 表示平方数,时间复杂度：O(n∗sqrt(n))，sqrt 为平方根

 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];
     }
 }