完全平方数

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, ...）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。 

示例 1:

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

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

解题思路

 

当每一次都可以判断出多种情况，有多次的时候就适合用BFS-广度优先遍历
使用BFS应注意：
队列：用来存储每一轮遍历得到的节点；
标记：对于遍历过的节点，应该将它标记，防止重复遍历。

我们将它第一个平方数可能出现的情况做分析 只要 i * i < n 就行
再在此基础上进行二次可能出现的平方数分析
注意：为了节省遍历的时间，曾经（ n - 以前出现的平方数） 这个值出现过，则在此出现这样的数时直接忽略。

 

 

static class Node {
        int val;
        int step;

        public Node(int val, int step) {
            this.val = val;
            this.step = step;
        }
    }

    // 将问题转化成图论
    // 该算法在往队列里面添加节点的时候会 add 很多重复的节点，导致超时，
    // 优化办法是，加入 visited 数组，检查要 add 的数据是否已经出现过了，防止数据重复出现，从而影响图的遍历
    // 同时优化：num - i * i 表达式，只让他计算一次
    // 同时在循环体里面判断退出或返回的条件，而不是在循环体外
    public int numSquares(int n) {
        Queue<Node> queue = new LinkedList<>();
        queue.add(new Node(n, 0));
        // 其实一个真正的图的 BSF 是一定会加上 visited 数组来过滤元素的
        boolean[] visited = new boolean[n+1];
        while (!queue.isEmpty()) {
            int num = queue.peek().val;
            int step = queue.peek().step;
            queue.remove();

            for (int i = 1; ; i++) {
                int a = num - i * i;
                if (a < 0) {
                    break;
                }
                // 若 a 已经计算到 0 了，就不必再往下执行了
                if (a == 0) {
                    return step + 1;
                }
                if (!visited[a]) {
                    queue.add(new Node(a, step + 1));
                    visited[a] = true;
                }
            }
        }
        return -1;
    }

动态规划

 /**
     * 直接思路：找出N最接近的平方数，再循环找出剩余最接近的平方数集合（结果可能不是最优）
     * 比如：12->9+1+1+1，最优的是12->4+4+4
     * 所以，上面的思路还得把所有的情况都求出来，再选出最少的，性能较差
     * <p>
     * 优化思路：利用之前计算的步数，转换为动态规划方程
     * dp[i]代表第i需要的最少步骤，遍历所有的情况，从而找出最优解
     * for (int j = 1; i - j * j >= 0; j++) {
     *   dp[i] = Math.min(dp[i], dp[i - j * j] + 1);
     * }
     *
     *
     * @param n
     * @return
     */


public int numSquares(int n) {
        //利用动态规划 定义长度为n+1的数组 对应索引所对应的数装最少的步数
        int[] dp = new int[n + 1];
        dp[0] = 0;
        for (int i = 1; i <= n; i++) {
            dp[i] = i; //先假设到这一步的最大的步数为每次+1
            for (int j = 1; i - j * j >= 0; j++) { 
                //i-j*j>=0 找到最大的j j*j就是i里面最大的完全平方数
                //dp[i-j*j]+1 表示d[i-j*j]的步数＋1 1即j*j这个完全平方数只需要一步
                dp[i] = Math.min(dp[i], dp[i - j * j] + 1);
            }
        }
        return dp[n];
    }