---
tags: [算法/动态规划, 基础DP, 完全背包, 数学/数论]
create time: 2026-05-16 19:00
---

# 84. 完全平方数（Perfect Squares）

> [!quote] LeetCode 原题 · 中等
> 给你一个整数 `n`，返回**和为 n 的完全平方数的最少数量**。
>
> **完全平方数**是一个整数，其值等于另一个整数的平方。例如：1、4、9、16。
>
> - 输入范围：`1 <= n <= 10⁴`

## 题面

**示例 1：**

```
输入：n = 12
输出：3
解释：12 = 4 + 4 + 4
```

**示例 2：**

```
输入：n = 13
输出：2
解释：13 = 4 + 9
```

## 思路

### 第一步：把问题翻译成 DP 语言

> [!question] 💡 思考
> 如果要凑出数字 n，你手里有 {1, 4, 9, 16, ...} 这些面额无限的"硬币"——这和哪类经典模型一致？

没错，这就是一个**「最小硬币数」版本**的完全背包问题：

- **物品集合**：所有不超过 n 的完全平方数 → {1², 2², 3², ..., k²}，其中 k² ≤ n
- **每种物品可以无限使用**
- **目标**：选若干个物品使其总和恰好为 n，且物品个数最少

定义状态：

> `dp[i]` = 和为 i 的完全平方数的最少数量

那状态转移呢？想象你已经凑到了 i，最后一步一定是从某个 i - j² 加上一个 j² 过来的：

> `dp[i] = min(dp[i - j*j]) + 1`，对所有满足 j² ≤ i 的 j 取最小值

> [!tip] 🧠 直观理解
> 画个例子：`dp[12]` 考虑最后加入的完全平方数可能是 1, 4, 9：
> - 加 1：`dp[12] = dp[11] + 1`
> - 加 4：`dp[12] = dp[8] + 1`
> - 加 9：`dp[12] = dp[3] + 1`
>
> 三者取最小即可。

```mermaid
flowchart TD
    subgraph "dp[12] 的状态转移"
        A["dp[12]\n= min(...) + 1"] --> B["从 dp[11] + 1\n(最后加 1)"]
        A --> C["从 dp[8] + 1\n(最后加 4)"]
        A --> D["从 dp[3] + 1\n(最后加 9)"]
        B --> E["dp[11]=4 → ans=5"]
        C --> F["dp[8]=2 → ans=3 ✓最优"]
        D --> G["dp[3]=3 → ans=4"]
    end

    style A fill:#e7f3ff,stroke:#3b82f6
    style F fill:#dcfce7,stroke:#16a34a
```

### 第二步：确定边界条件

> [!question] 💡 思考
> dp[0] 应该是多少？为什么？

`dp[0] = 0` ——和为 0 不需要任何完全平方数，答案是 0。这是所有状态的"空起点"。没有它，整个递推就没有根基。

### 第三步：自底向上填表

以 `n = 12` 为例完整走一遍——

| i | dp[i] 计算过程 | dp[i] |
|---|--------------|-------|
| 0 | — | **0** |
| 1 | dp[0]+1 | **1** |
| 2 | dp[1]+1 | **2** |
| 3 | dp[2]+1 = dp[0]+1 | **2** |
| 4 | dp[3]+1, dp[0]+1 | **1** ← 本身就是平方数！ |
| 5 | dp[4]+1 = dp[1]+1 | **2** |
| 6 | dp[5]+1 = 3, dp[2]+1 = 3 | **3** |
| 7 | dp[6]+1 = dp[3]+1 | **3** |
| 8 | dp[7]+1 = dp[4]+1 | **2** ← 4+4 |
| 9 | dp[8]+1, dp[5]+1, dp[0]+1 | **1** ← 本身是平方数 |
| 10 | dp[9]+1 = dp[6]+1 | **3** |
| 11 | dp[10]+1 = dp[7]+1 | **3** |
| 12 | dp[11]+1 = dp[8]+1 = dp[3]+1 | **3** ← 4+4+4 |

```mermaid
flowchart LR
    subgraph "填表示意 n=12"
        A["i=0: 0"] --> B["i=1: 1"]
        B --> C["i=2: 2"]
        C --> D["i=3: 2"]
        D --> E["i=4: 1 ★"]
        E --> F["i=5: 2"]
        F --> G["i=6: 3"]
        G --> H["i=7: 3"]
        H --> I["i=8: 2 ★"]
        I --> J["i=9: 1 ★"]
        J --> K["i=10: 3"]
        K --> L["i=11: 3"]
        L --> M["i=12: 3 ★答案"]
    end

    style A fill:#f3f4f6,stroke:#6b7280
    style E fill:#fef3c7,stroke:#f59e0b
    style I fill:#fef3c7,stroke:#f59e0b
    style J fill:#fef3c7,stroke:#f59e0b
    style M fill:#dcfce7,stroke:#16a34a
```

> 表中 ★ 标记表示该位置本身就是一个完全平方数，直接取 1。

## 代码提示

在动手写代码之前，想一想这些关键决策点：

> [!question] 💡 思考 1
> 内层循环中，j 的范围应该是多少？怎么高效地枚举"所有不超过 i 的完全平方数"？

j 从 1 开始，只要 `j*j ≤ i` 就继续。这样 `dp[i - j*j]` 不会越界。每次循环只用一次乘法和一次比较，效率很高。

> [!question] 💡 思考 2
> Go 中没有内置的 min 对多个值取最小——你会怎么写？

可以先用一个变量 `ans` 初始化为无穷大（比如 `i` 本身，因为最坏情况是全用 1），然后在循环中逐个更新最小值。这样既简洁又避免了引入额外依赖。

## 技巧

### 剪枝：提前识别完全平方数

> [!tip] ⚡ 小优化
> 如果 i 本身就是一个完全平方数（即存在某个 j 使得 j*j = i），那么 `dp[i] = 1`，可以直接跳过内层循环。

这个判断只需一行：`if int(math.Sqrt(float64(i)))*int(math.Sqrt(float64(i))) == i { dp[i] = 1; continue }`。虽然不影响渐近复杂度，但能加速一半以上的填充。

### Lagrange 四平方定理（进阶）

> [!abstract] 🔢 数论彩蛋：Lagrange 四平方定理
> **任意正整数都可以表示为不超过 4 个完全平方数之和。**
>
> 这意味着答案永远 ∈ {1, 2, 3, 4}。配合 Legendre 三平方定理，可以做到 O(√n) 时间直接求解：
>
> 1. 先消去因子 4（反复除以 4）
> 2. 检查余数是否为 `4ᵏ(8m+7)`——如果是，答案就是 4
> 3. 否则尝试能否拆成两个平方数之和——能则是 2
> 4. 其余情况都是 3

这个数学解法速度极快，但在面试中可能不容易当场推导出来。掌握 DP 方法已足够通过绝大多数场景。

| 方法 | 时间 | 空间 | 评价 |
|------|------|------|------|
| DP 填表（推荐） | O(n√n) | O(n) | 通用易懂，面试首选 |
| BFS | O(n√n) | O(n) | 第一层到达的答案必是最优，同样高效 |
| 数学法（四平方定理） | O(√n) | O(1) | 最快，但需记忆定理 |

## 代码

### Go 语言实现

```go
// numSquares returns the minimum number of perfect squares that sum to n.
func numSquares(n int) int {
	// dp[i] = 和为 i 的完全平方数的最少数量
	dp := make([]int, n+1)

	for i := 1; i <= n; i++ {
		// 初始化：最坏情况是全用 1 来凑
		dp[i] = i

		// 尝试每一种可能的最后一步 j*j
		for j := 1; j*j <= i; j++ {
			sum := dp[i-j*j] + 1
			if sum < dp[i] {
				dp[i] = sum
			}
		}
	}

	return dp[n]
}
```

> [!summary] 💡 代码说明
> - **外层循环**：从左到右依次计算 dp[1], dp[2], ..., dp[n]，保证每个子问题在用到时已经被解决
> - **内层循环**：枚举所有可能的 j（1, 2, 3, ...），直到 j² > i 为止。每次考虑"最后一步加了 j²"这个选择
> - **初始值 dp[i] = i**：最坏情况是用 i 个 1 来凑（如 7 = 1+1+1+1+1+1+1）。内层循环一定能找到更优解

### 执行过程演示（n = 12）

```
i=1:  j=1: dp[0]+1=1     → dp[1]=1     ← 1=1
i=2:  j=1: dp[1]+1=2     → dp[2]=2     ← 2=1+1
i=3:  j=1: dp[2]+1=3     → dp[3]=3     ← 3=1+1+1 (j=2时 4>3，停止)
i=4:  j=1: dp[3]+1=4
       j=2: dp[0]+1=1    → dp[4]=1     ← 4=4 ★
i=5:  j=1: dp[4]+1=2
       j=2: dp[1]+1=2    → dp[5]=2     ← 5=4+1
i=6:  j=1: dp[5]+1=3
       j=2: dp[2]+1=3    → dp[6]=3     ← 6=4+1+1
i=7:  j=1: dp[6]+1=4
       j=2: dp[3]+1=4    → dp[7]=4     ← 7=4+1+1+1
i=8:  j=1: dp[7]+1=5
       j=2: dp[4]+1=2    → dp[8]=2     ← 8=4+4 ★
i=9:  j=1: dp[8]+1=3
       j=2: dp[5]+1=3
       j=3: dp[0]+1=1    → dp[9]=1     ← 9=9 ★
i=10: j=1: dp[9]+1=2
       j=2: dp[6]+1=4
       j=3: dp[1]+1=2    → dp[10]=2    ← 10=9+1
i=11: j=1: dp[10]+1=3
       j=2: dp[7]+1=5
       j=3: dp[2]+1=3    → dp[11]=3    ← 11=9+1+1
i=12: j=1: dp[11]+1=4
       j=2: dp[8]+1=3    → dp[12]=3    ← 12=4+4+4
     
答案：dp[12] = 3 ✅
```

### 复杂度分析

- **时间复杂度：O(n√n)** — 外层循环 n 次，内层循环最多 √n 次，总操作量约为 Σ(√i) ≈ (2/3)n^(3/2)
- **空间复杂度：O(n)** — dp 数组占用 n+1 个整型空间

## 举一反三

这道题是 **线性 DP + 枚举最后一项** 的典型范式，同时也是「完全背包」思想的第一道落地应用：

- [[81-爬楼梯]] — 同样是线性 DP，但这里的"选择"不是固定两种，而是从一组可选值中选
- [[83-打家劫舍]] — 同样是逐状态递推，但约束不同（不能相邻 vs 无约束）
- LeetCode 322. 零钱兑换 — 完全背包的标准题，模板几乎一模一样（只是面额换成 coin value）

> [!summary] 📌 本节要点
> 1. 定义 dp[i] = 和为 i 的完全平方数最少个数
> 2. 状态转移：dp[i] = min(dp[i - j²]) + 1，枚举所有 j² ≤ i
> 3. 边界 dp[0] = 0，初始值 dp[i] = i（全用 1）
> 4. 复杂度 O(n√n)，可以用 Lagrange 四平方定理做到 O(√n)