279. Perfect Squares-Leetcode(关于DP的再深入研究)

本文链接：https://blog.csdn.net/WALLEZhe/article/details/50391647

先上题目：

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

For example, given n = 12, return 3 because 12 = 4 + 4 + 4; given n = 13, return 2 because 13 = 4 + 9.

Credits:
Special thanks to @jianchao.li.fighter for adding this problem and creating all test cases.

Subscribe to see which companies asked this question
一开始直接想到了递归的DP算法，一些用例通过，整体测试的时候超时。

（最最一开始我把题目理解错了，以为用尽可能大的平方数之和来表示所给给数n，后来发现使用最大的得出的平方数个数并不是最小的。如12=9+1+1+1；而正确的结果应该是12=4+4+4；最小的平方数个数是3而不是4。）

使用的还是分铁棒的办法进行分割，i++每一个单位长度都进行遍历。这是我代码的重大缺陷。因为题目中要求所有的组成部分都是平方数。

public class Solution {
    int [] list;
    public int numSquares(int n) {
        list=new int [n+1];        
        list[0]=0;
        int bound=(int)Math.sqrt(n);

        for(int i=1;i<=n;i++){
            list[i]=-1;

        }
        for(int i=1;i<=bound;i++){
            list[(int)Math.pow(i,2)]=1;
        }
        return getNum(n);
    }
    private int getNum(int n){
        if(list[n]!=-1){
            return list[n];
        }
        int min=n;
        for(int i=1;i<(n/2+1);i++){
            int temp=getNum(i)+getNum(n-i);
            if(min>temp){
                min=temp;
            }
        }
        list[n]=min;
        return min;
       // return 1+getNum(n-(int)Math.pow(getLessSquares(n),2));
    }
    private int getLessSquares(int n){
        for(int i=0;;i++){
            if(Math.pow(i,2)>n){
                System.out.println("squars:"+(i-1));

                return i-1;
            }
        }
    }
}

一开始找不到超时的原因。于是在网上看前辈的算法：

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

其使用的是自底向上的dp，最后返回数组的最后一位。其运行效率也很客观。
下图中左侧是他的代码，右侧是我改良过以后的递归DP。

改到最后出了上下的方向不一样，我是递归它是双重循环以外，其余的都一样，可是我们的时间复杂度还是有很大差距。按照算法导论上说应该相差一个常数。这里先不去验证，因为相差的不是不可接受。
下面是右侧的算法代码：

public class Solution {
    int [] list;
    public int numSquares(int n) {
        list=new int [n+1];        

        //int bound=(int)Math.sqrt(n);

       /* for(int i=1;i<=n;i++){
            list[i]=-1;

        }*/
        Arrays.fill(list, -1); 
        list[0]=0;
       /* for(int i=1;i<=bound;i++){
            list[i*i]=1;
        }*/
        return getNum(n);
    }
    private int getNum(int n){
        if(list[n]!=-1){
           // System.out.format("list[%d] have directly returned %d\n",n,list[n]);
            return list[n];

        }
        int min=n;
        for(int i=1;i*i<=n;i++){

           min=Math.min(min,getNum(n-i*i)+1);
            //int temp=getNum(n-i*i)+1;

          //  System.out.format("getNum(i:%d)+getNum(n-i:%d)=%d+%d=%d\n",i,n-i,getNum(i),getNum(n-i),temp);
           // if(min>temp){
            //    min=temp;
            //}
        }
        list[n]=min;
        //for(int i=0;i<n;i++){
          //  System.out.format("%d ",list[i]);
       //}
      //  System.out.format("\n");
        return min;
       // return 1+getNum(n-(int)Math.pow(getLessSquares(n),2));
    }
    /*private int getLessSquares(int n){
        for(int i=0;;i++){
            if(Math.pow(i,2)>n){
            //    System.out.println("squars:"+(i-1));

                return i-1;
            }
        }
    }*/
}