Perfect Squares -- leetcode

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

.

算法一， 动态规划

从1到n逐个计算。

应用递推式： dp[i] = min(dp[i], 1+dp[i-j*j]);
即一个数是由 一个平方 + 另一个数 构成。 number1 = square + number2

而number2 结果已经计算过了。

在leetcode上实际执行时间为452ms。

class Solution {
public:
int numSquares(int n) {
vector<int> dp(n+1, INT_MAX);
dp[0] = 0;
for (int i=1; i<=n; i++) {
const int up = sqrt(i);
for (int j=1; j<=up; j++) {
dp[i] = min(dp[i], 1+dp[i-j*j]);
}
}
return dp
;
}
};

算法二，BFS

基本模型，仍是 number1 = square + number2

即，number1, number2当作节点，而他们之间的边，则是一个 平方。

即一个数，加上一个 平方， 从而得到另一个数。

从根结点整数0从发，进行广度优先搜索，直到节点n为止。

即，

 节点0加上一系列平方，得到一下层次的各个结点。

而对下一层次的结点，重复进行上面的步骤。

此处的visited数组很重要，否则会出现内存不足。

因为实际上这是一个图，而不是单纯的树。

在leetcode上实际执行时间为164ms。

class Solution {
public:
int numSquares(int n) {
const int up = sqrt(n);
vector<int> square(up);
for (int i=1; i<=up; i++)
square[i-1] = i*i;

vector<bool> visited(n+1, false);
queue<int> q;
q.push(0);
int level = 0;
while (!q.empty()) {
++level;
int size = q.size();
while (size--) {
auto node = q.front();
q.pop();
for (auto s: square) {
const auto child = s+node;
if (child == n)
return level;
else if (child < n && !visited[child]) {
q.push(child);
visited[child] = true;
}
else if (child > n)
break;
}
}
}
return level;
}
};

算法三，DFS

模型同上，进行深度优先搜索。

从n从发，减去一个平方，即得到下一层的一个节点。 直到找到节点0为止。

遍历所有路径，记录下最短的路径数。

1. 遍历时，使用变量level，限制递归的深度。以节省时间。

2. 先减去较大的平方，再减去较小的平方。 这样，当搜索到节点0时，所用的步数（即深度），不会特别大。从而用此深度，限制后续的搜索深度。

因为我们要找的是最短路径。

反之如果从1个平方开始递减的话，会出现大量的无用搜索。比如每次只减掉1，搜索n，将第一次会达到n层。

在leetcode上，实际执行时间为212ms。

class Solution {
public:
int numSquares(int n) {
vector<int> nums(n+1);
return helper(n, nums, n);
}

int helper(int n, vector<int>& nums, int level) {
if (!n)
return 0;
if (nums
)
return nums
;
if (!level)
return -1;

--level;
const int up = sqrt(n);
int ans = n;
int res = n;
for (int i=up; i>=1 && res; i--) {
res = helper(n-i*i, nums, min(ans, level));
if (res >= 0)
ans = min(ans, res);
}
nums
= ans + 1;
return nums
;
}
};

将此写法也贴在leetcode中的一个answer中了，不知道会收获赞不。
https://leetcode.com/discuss/58056/summary-of-different-solutions-bfs-static-and-mathematics

算法四，数学公式

此此略去。难点是要懂得数学Lagrange's Four Square theorem。

代码上倒是没有什么复杂的。