0动态规划中等 leetcode279. 完全平方数

import java.util.LinkedList;
import java.util.HashSet;
import java.lang.Math;
class Solution {
    /*
    因为结果可以同前面的结果计算得到，复杂度低，所以可以使用动态规划
    dp[i]：组合成i的完全平方数的最小个数
    组合成n的完全平方数一定包含：1，2*2，3*3，...j*j（j*j<=n且j取最大值）中的一个。
    因此可以认为dp[n]等于dp[n-1],dp[n-2*2],dp[n-3*3],...dp[n-j*j]中最小的一个加一。
    而要知道dp[n-1],dp[n-2*2],...dp[n-j*j]，就需要从头遍历。
    动态方程dp[n]的求解代码是个for循环:
 	for(int j=1;j*j<=i;j++){
        dp[i]=Math.min(dp[i],dp[i-j*j]+1);
    }
    */
    public int numSquares(int n) {
        int []dp=new int[n+1];
        for(int i=1;i<n+1;i++){
            dp[i]=Integer.MAX_VALUE;
            for(int j=1;j*j<=i;j++){
                dp[i]=Math.min(dp[i],dp[i-j*j]+1);
            }
        }
        return dp[n];
    }
}
/*
n每次减去最大的比她小的完全平方数，剩下的数依旧如此，直到为零，记录次数。
这种解法有时候求出的结果不是最优，如12的最优是3，用上面的解法求到的是4.
class Solution {
    int res=0;
    public int numSquares(int n) {
        if(n==0){
            return res;
        }
        res++;
        int i=1;
        while(i*i<=n){
            i++;
        }
        i--;
        return numSquares(n-i*i);
    }
}
*/
/*
BFS广度优先搜索解法
class Solution {
    public int numSquares(int n) {
        HashSet<Integer> set=new HashSet<>();
        Queue<Integer> que=new LinkedList<>();
        que.offer(n);
        int step=0;
        int tmp=0;
        while(!que.isEmpty()){
            step++;
            int len=que.size();//计算一层的个数。
            for(int i=0;i<len;i++){
                int rest=que.poll();
                for(int j=1;j*j<=rest;j++){
                    tmp=rest-j*j;
                    if(tmp==0){
                        return step;
                    }
                    if(!set.contains(tmp)){//避免重复计算。
                        que.offer(tmp);
                        set.add(tmp);
                    }
                }
            }
            
        }
        return step;
    }
}
*/