LeetCode Algorithms 279. Perfect Squares 题解

题目
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.

题目大意：输入一个正整数n，用最少的完美平方数相加得到n，输出所需的最少完美平方数的个数。

看到题目，首先想到的是先找到最大的符合条件的完美平方数，然后与n做差，对得到的余数再找一次最大的符合条件的数，直到差为0，但是这种方法会有问题，对于12这种数不适用，用刚刚描述的方法的话12=9+1+1+1，需要4次，而最少次数应该是12=4+4+4，3次。所以这个方法不行。

稍作思考后可以发现，最暴力的解法应该是遍历n的所有可能的平方数组合，得到最少的次数。但是这样当数比较大的时候，就需要很大的计算量，例如对于22这个数，22=16+4+1+1，22=9+9+4，22=9+4+9，22=4+16+1+1，……，可以发现有多个组合是已经计算过的，这时候可以使用动态规划的思想，记录已经计算过的最少次数，再分解到这个数的时候不需要再进行分解。

以下是使用没有优化过的动态规划代码：

int numSquares(int n) {
        if (n == 1) return 1;
        int* dp = new int[n + 1];
        for (int k = 0; k <= n; k++) {
            dp[k] = INT_MAX;
        }
        dp[0] = 0;// 初始化一个起始值
        /* i表示从0到n的数，j表示平方根 */
        for (int i = 0; i <= n; i++) {
            for (int j = 1; i + j * j <= n; j++) {
                /* 在dp数组里面找已经储存的最小值 */
                dp[i + j * j] = min(dp[i + j * j], dp[i] + 1); 
            }
        }
        return dp[n];
    }

提交后发现这个代码效率不高，观察后发现 i + j * j <= n这个操作会引起很多不必要的计算，比如i = 1的时候，需要遍历很多个j，实际上i = 1只需要1次遍历。
查看discussion后发现一个高效的做法，利用vector的push_back，提高数组遍历的效率，用j * j <= i作为判断条件，减掉多余的平方数的遍历。以下是修改后的代码：

int numSquares(int n) {
    if (n == 1) return 1;
    static vector<int> dp({ 0 });
    /* i表示从0到n的数，j表示平方根 */
    while(dp.size() <= n) {
        int i = dp.size();
        int perfect_nums = INT_MAX;
        // j * j <= i，剪枝操作，减少不必要的计算量
        for (int j = 1; j * j <= i; j++) {
            /* 在dp数组里面找已经储存的最小值 */
            perfect_nums = min(perfect_nums, dp[i - j * j] + 1);
        }
        dp.push_back(perfect_nums);
    }
    return dp[n];
}

到这里我的题解还没有结束，因为查看discussion的时候发现这个数论问题有纯数学的解法，完全不需要数组！

首先有一个四平方和定理Lagrange’s four-square theorem，这个定理说明每个正整数都能表示为4个整数的平方和，用到这个题目上，就是说可能的最少次数只有1，2，3，4四种可能。
然后还有一个定理Legendre’s three-square theorem ,该定理说明满足n = 4^k(8m + 7)的n，最少只能表示为4个整数的平方和。
剩下只需要对可能次数为1和2再作判断即可，以下是纯数学方法的代码：

int numSquares(int n) {
    int sqrt_n = sqrt(n);
    int _n = n;
    if (sqrt_n * sqrt_n == n) {
        return 1;
    }
    /* Legendre's three-square theorem 
     * 满足n = 4^k(8m + 7)的数
     * 能表示为4个数的平方和 
     */
    while (n % 4 == 0) {
        n /= 4;
    }
    if (n % 8 == 7) {
        return 4;
    }
    /* 是否能用两个数的平方和可以表示 */
    for (int i = 1; i <= sqrt_n; i++) {
        if ((int)pow((int)sqrt(_n - i * i), 2) == _n - i * i) {
            return 2;
        }
    }
    return 3;
}