<think>我们被要求回答数字三角形问题的两种实现方式：
递推和记忆化搜索。
根据引用[1][2][3]提供的资料，数字三角形是一个经典的
动态规划问题，问题描述如下：
给定一个由数字组成的三角形，从顶部出发，每次只能移动到下一行相邻的节点（即下一行的正下方或右下方的节点），求从顶部到底部的路径中，数字之
和最大的路径
和。
两种方法：
1.
递推（自底向上）：从三角形的底部开始，逐层向上计算每个节点到底部的最大路径
和，最终顶部节点即为所求。
2. 记忆化搜索（自顶向下）：从顶部节点开始，
递归地计算每个节点到底部的最大路径
和，同时使用一个记忆数组存储已经计算过的节点，避免重复计算。
我们将分别介绍这两种方法的实现。
首先，假设数字三角形存储在一个二维数组`arr`中，其中第i行有i个元素（行数从1开始）。为了方便，我们通常使用二维数组，行
和列都从0开始存储。
方法一：
递推（
动态规划）
递推公式：
dp[i][j] = arr[i][j] + max(dp[i+1][j], dp[i+1][j+1]) (当i从n-2到0)
其中，dp[i][j]表示从第i行第j列节点出发，到底部的路径的最大
和。
我们初始化最后一行的dp值为三角形最后一行的值，然后从倒数第二行开始向上
递推。
方法二：记忆化搜索
我们使用
递归函数dfs(i, j)表示从(i,j)节点到底部的最大路径
和。
如果已经计算过dfs(i, j)，则直接返回结果（存储在记忆数组rec中）；
否则，
递归计算：
rec[i][j] = arr[i][j] + max(dfs(i+1, j), dfs(i+1, j+1))
注意：
递归的边界条件是当i为最后一行时，直接返回arr[i][j]。
下面我们分别用代码展示这两种方法（使用C++
和Java，根据引用中的示例选择一种语言，但用户没有指定语言，我们可以用两种语言分别展示，但为了简洁，这里选择一种，比如C++用于记忆化搜索，Java用于
递推，但为了统一，我们使用C++展示两种方法？）
不过，用户要求使用中文回答，且需要生成相关问题，并且注意代码格式。
考虑到引用中提供了C++的记忆化搜索
和Java的
递推，我们可以分别用C++展示记忆化搜索，用C++展示
递推（因为引用[2]是C++记忆化搜索，引用[3]是
递推但用Java，我们可以用C++写
递推）。
但是，为了统一，我们这里都使用C++来实现，因为引用[2]中已经有一个C++的记忆化搜索，而
递推方法在引用[3]中是Java，我们可以将其转换为C++。
注意：数字三角形的输入格式，第一行是行数n，然后n行，第i行有i个数字。
递推方法（C++）：
步骤：
1. 读入n
和三角形数据，存储到二维数组arr中（行从1到n，列从1到行号）。
2. 初始化一个dp数组（大小
和arr一样），将最后一行的dp值设为三角形的最后一行。
3. 从倒数第二行开始，向上遍历，对于每一行的每个位置j，计算：
dp[i][j] = arr[i][j] + max(dp[i+1][j], dp[i+1][j+1]);
4. 最终dp[1][1]（或dp[0][0]如果从0开始）就是答案。
记忆化搜索（C++）：
步骤：
1. 读入n
和三角形数据，存储到二维数组arr中。
2. 初始化一个记忆数组rec，大小
和arr一样，初始化为一个不可能的值（比如-1，如果三角形中可能有负数，我们可以用memset初始化为-1，因为题目中数字范围未知，但通常可以这样处理，或者用其他特殊值，但引用[2]中用了-1）。
3. 编写
递归函数dfs(i, j)：
如果i是最后一行（即i==n），则返回arr[i][j]。
如果rec[i][j]不等于初始值（比如-1），则返回rec[i][j]。
否则，计算rec[i][j] = arr[i][j] + max(dfs(i+1, j), dfs(i+1, j+1))，并返回rec[i][j]。
4. 调用dfs(1,1)（如果从1开始索引）或dfs(0,0)（如果从0开始索引），并输出结果。
注意：引用[2]中的代码是从第1行到第n行，且行内索引从1开始，而输入时j行有j个元素，所以内层循环j从1到i（行号）。我们在写代码时也要注意索引。
下面我们分别给出两种方法的C++代码实现（注意：为了清晰，我们假设数组索引从1开始，但C++数组默认从0开始，所以我们可以调整数组大小为n+1，然后使用1到n的索引）。
递推方法（自底向上）C++代码：
```cpp
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int n;
cin >> n;
int arr[1005][1005] = {0}; // 初始化数组为0
int dp[1005][1005] = {0};
// 输入数字三角形
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
cin >> arr[i][j];
}
}
// 初始化dp数组的最后一行
for (int j = 1; j <= n; j++) {
dp[n][j] = arr[n][j];
}
// 从倒数第二行开始向上
递推
for (int i = n-1; i >= 1; i--) {
for (int j = 1; j <= i; j++) {
dp[i][j] = arr[i][j] + max(dp[i+1][j], dp[i+1][j+1]);
}
}
cout << dp[1][1] << endl;
return 0;
}
```
记忆化搜索（自顶向下）C++代码（参考引用[2]）：
```cpp
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int n;
int arr[1005][1005]; // 存储三角形
int rec[1005][1005]; // 记忆数组，记录从(i,j)出发到底部的最大
和
int dfs(int i, int j) {
if (i == n) {
return arr[i][j];
}
if (rec[i][j] != -1) {
return rec[i][j];
}
// 计算并保存到rec[i][j]
rec[i][j] = arr[i][j] + max(dfs(i+1, j), dfs(i+1, j+1));
return rec[i][j];
}
int main() {
memset(rec, -1, sizeof(rec)); // 初始化记忆数组为-1
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
cin >> arr[i][j];
}
}
int ans = dfs(1, 1);
cout << ans << endl;
return 0;
}
```
注意：以上代码中，我们假设三角形最多1000行，所以数组大小设为1005。实际使用中，如果n很大，可以考虑动态分配数组。
现在，我们按照要求生成相关问题：
§§相关问题§§
1. 数字三角形问题中，
递推和记忆化搜索的时间复杂度分别是多少？
2. 数字三角形问题中，如何优化
递推方法的空间复杂度？
3. 除了
递推和记忆化搜索，还有哪些方法可以解决数字三角形问题？
4. 如果数字三角形中的路径要求是相邻节点只能往左下或右下走，那么如果允许往正下方、左下方
和右下方走，该如何修改算法？</think>### 数字三角形问题的
递推与记忆化搜索实现
#### 问题描述
给定一个由数字组成的三角形（如引用[1]中的示例），从顶部到底部寻找一条路径，使路径上的数字之
和最大。路径规则：每一步只能移动到下一行相邻节点（正下方或右下方）。
#### 1.
递推实现（自底向上）
**核心思想**：从三角形底部向上逐层计算每个节点到底部的最大路径
和，最终顶部节点的值即为全局最优解[^1][^3]。
**
递推公式**：
$$ dp[i][j] = arr[i][j] + \max(dp[i+1][j],\ dp[i+1][j+1]) $$
**C++ 实现**：
```cpp
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int n;
cin >> n;
int arr[1005][1005] = {0}, dp[1005][1005] = {0};
// 输入数字三角形
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++)
cin >> arr[i][j];
// 初始化最后一行
for (int j = 1; j <= n; j++)
dp[n][j] = arr[n][j];
// 自底向上
递推
for (int i = n-1; i >= 1; i--)
for (int j = 1; j <= i; j++)
dp[i][j] = arr[i][j] + max(dp[i+1][j], dp[i+1][j+1]);
cout << dp[1][1] << endl;
return 0;
}
```
**特点**：
- 时间复杂度：$O(n^2)$
- 空间复杂度：$O(n^2)$
- 无需
递归栈，避免栈溢出风险[^3]
#### 2. 记忆化搜索实现（自顶向下）
**核心思想**：
递归计算每个节点到底部的最大路径
和，通过记忆数组`rec[][]`避免重复计算[^1][^2]。
**
递归公式**：
$$ rec[i][j] = arr[i][j] + \max(dfs(i+1,j),\ dfs(i+1,j+1)) $$
**C++ 实现**：
```cpp
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int n, arr[1005][1005], rec[1005][1005];
int dfs(int i, int j) {
if (i == n) return arr[i][j]; // 到达最后一行
if (rec[i][j] != -1) return rec[i][j]; // 已计算则直接返回
rec[i][j] = arr[i][j] + max(dfs(i+1, j), dfs(i+1, j+1)); //
递归计算并存储
return rec[i][j];
}
int main() {
memset(rec, -1, sizeof(rec)); // 初始化记忆数组
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++)
cin >> arr[i][j];
cout << dfs(1, 1) << endl; // 从顶部开始搜索
return 0;
}
```
**特点**：
- 时间复杂度：$O(n^2)$
- 空间复杂度：$O(n^2)$（含
递归栈）
- 逻辑更符合问题描述，但
递归深度大时可能栈溢出[^2]
#### 关键对比
| **特性** |
递推实现 | 记忆化搜索 |
|------------------|------------------------|-----------------------|
| **计算方向** | 自底向上 | 自顶向下 |
| **空间优化** | 可优化为$O(n)$[^1] | 需$O(n^2)$存储状态 |
| **栈溢出风险** | 无 |
递归深度大时存在 |
| **代码逻辑** | 顺序迭代 |
递归+记忆化 |
---
本文介绍了动态规划的基本概念，包括其作为优化问题的解决方案，并通过斐波那契数列和数塔问题展示了动态规划的递归和递推写法。递归写法利用记忆化搜索避免重复计算，递推写法自底向上求解。动态规划解决问题的关键在于重叠子问题和最优子结构。
最低0.47元/天 解锁文章
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
