leetcode：279.完全平方数

题目来源

• leetcode：279. 完全平方数
• lintcode：513 · 完美平方

题目描述

class Solution {
public:
    int numSquares(int n) {

    }
};

题目解析

题意

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

分析

• 什么是完全平方数？完全平方数是一个整数，其值等于另一个整数的平方。也就是说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。
• 首先【完全平方数】有无限个，但是要凑齐的数字是给定的。
• 在给定了一个N之后，我们就可以知道，可以选择哪些数去凑。因此，第一步我们可以将范围在[1, n]内的[完全平方数]预处理出来，这样问题就转换为了：给定若干个数字，每个数字可以用无限次，求凑齐n所需要的最少的数字个数是多少。
• 问题就转换了完全背包问题（本质上是一个找零钱问题，要求用一堆硬币凑齐n，哪个方案用的硬币最少。）

暴力回溯

n = 12

• 先把n减去一个平方数，然后求剩下的数分解成平方和所需的最少个数
  • 把 n 减去 1, 然后求出 11 分解成平方数和所需的最小个数,记做 n1，那么当前方案总共需要 n1 + 1 个平方数
  • 把 n 减去 4, 然后求出 8 分解成平方数和所需的最小个数,记做 n2，那么当前方案总共需要 n2 + 1 个平方数
  • 把 n 减去 9, 然后求出 3 分解成平方数和所需的最小个数,记做 n3，那么当前方案总共需要 n3 + 1 个平方数
  • 下一个平方数是 16, 大于 12, 不能再分了。
• 接下来我们只需要从 (n1 + 1), (n2 + 1), (n3 + 1) 三种方案中选择最小的个数，此时就是 12 分解成平方数和所需的最小个数了
• 至于求 11、8、3 分解成最小平方数和所需的最小个数继续用上边的方法去求
• 直到如果求 0 分解成最小平方数的和的个数, 返回 0 即可

代码：

class Solution {
    int process(int n){
        if(n == 0){
            return 0;
        }

        int count = INT32_MAX;

        // //依次减去一个平方数
        for (int i = 1; i * i <=  n; ++i) {
            int p = process(n - i * i);
            p = p == INT32_MAX ? INT32_MAX : p + 1;
            count = std::min(count, p);
        }
        return count;
    }
public:
    int numSquares(int n) {
        return process(n);
    }
};

会超时，将它改成动态规划

class Solution {
public:
    int numSquares(int n) {
        std::vector<int> dp(n + 1, INT32_MAX);
        dp[0] = 0;

        //依次求出 1, 2... 直到 n 的解
        for (int i = 1; i <= n; ++i) {
            //依次减去一个平方数
            for (int j = 1; j * j <= i; ++j) {
                dp[i] = std::min(dp[i], dp[i - j * j] + 1);
            }
        }
        return dp[n];
    }
};

BFS

相当于上面解法DFS，也可以用BFS

DFS是一直做减法，然后一直减一直减，直到减到0算作找到一个解。属于一个解一个解的寻找。

BFS的话，是一层一层的算，第一层减去一个平方数得到第二层，第二层减去一个平方数得到第三层。直到某一层出现了0，此时的层数就是我们要找的平方和的最小个数。

举个例子，n = 12，每层的话每个节点依次减 1, 4, 9…。如下图，灰色表示当前层重复的节点，不需要处理。

如上图，当出现 0 的时候遍历就可以停止，此时是第 3 层（从 0 计数），所以最终答案就是 3。

class Solution {
public:
    int numSquares(int n) {
        std::queue<int> queue;
        std::set<int> visited;
        int level = 0;
        queue.push(n);
        visited.emplace(n);
        while (!queue.empty()){
            int size = queue.size();
            level++;
            for (int i = 0; i < size; ++i) {
                int curr = queue.front(); queue.pop();
                //依次减 1, 4, 9... 生成下一层的节点
                for (int j = 1; j * j <= curr; ++j) {
                    int next = curr - j * j;
                    if(next == 0){
                        return level;
                    }
                    if(!visited.count(next)){
                        queue.push(next);
                        visited.emplace(next);
                    }
                }
            }
        }
        return level;
    }
};

二维背包

背包问题的原始状态一般定义为两位：

• 第一维$i$表示物体编号
• 第二维$j$表示容器

其中第二维$j$又有[不超过$j$]和[刚好等于$j$]两种定义。本题要求刚好凑齐n。

因此状态定义：$f[i][j]$为考虑前i个数字，凑齐数字总和$j$所需要用到的最少数字数量。

不失一般性的分析 $f[i][j]$，对于第$i$个数字（假设数值为$t$），我们有如下选择：

class Solution {
public:
    int numSquares(int n) {
        std::vector<int> vec;
        int t = 1;
        while (t * t <= n){
            vec.push_back(t * t);
            t++;
        }
        
        int m = vec.size();

        // f[i][j] 代表考虑前 i 个物品，凑出 j 所使用到的最小元素个数
        std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1));

        // 当没有任何数时，除了 f[0][0] 为 0（花费 0 个数值凑出 0），其他均为无效值
        std::fill(dp[0].begin(), dp[1].end(), INT32_MAX);
        dp[0][0] = 0;

        // 处理剩余数的情况
        for (int i = 1; i <= m; ++i) {
            int x = vec[i - 1];
            for (int j = 0; j <= n; ++j) {
                // 对于不选第 i 个数的情况
                dp[i][j] = dp[i - 1][j];
                // 对于选 k 次第 i 个数的情况
                for (int k = 0; k * x <= j; ++k) {
                    // 能够选择 k 个 x 的前提是剩余的数字 j - k * x 也能被凑出
                    if(dp[i - 1][j - k * x] != INT32_MAX){
                        dp[i][j] = std::min(dp[i][j],
                                dp[i - 1][j - k * k] + k);
                    }
                }
            }
        }
        
        return dp[m][n];
    }
};