杨辉三角II问题解析与最优解法实现

1. 杨辉三角II问题解析

杨辉三角是算法学习中的经典问题，在LeetCode上被标记为简单难度（编号119）。题目要求给定一个非负索引rowIndex，返回杨辉三角的第rowIndex行。例如输入3，需要返回[1,3,3,1]。

这个问题的关键在于理解杨辉三角的数学性质：

• 每行首尾元素都是1
• 中间每个元素等于其正上方元素与左上方元素之和
• 第n行恰好有n+1个元素

注意：题目要求空间复杂度优化到O(rowIndex)，这意味着不能存储整个杨辉三角，只能使用线性空间。

2. 解法思路与优化策略

2.1 基础递归解法

最直观的解法是递归生成整个杨辉三角直到目标行：

java复制public List<Integer> getRow(int rowIndex) {
    if(rowIndex == 0) return Arrays.asList(1);
    List<Integer> prev = getRow(rowIndex - 1);
    List<Integer> curr = new ArrayList<>();
    curr.add(1);
    for(int i = 1; i < rowIndex; i++){
        curr.add(prev.get(i-1) + prev.get(i));
    }
    curr.add(1);
    return curr;
}

这种方法虽然直观，但存在两个明显问题：

1. 时间复杂度O(n²) - 存在大量重复计算
2. 空间复杂度O(n²) - 需要存储所有中间行

2.2 动态规划优化

我们可以使用动态规划来优化空间复杂度。观察到每行只依赖前一行，因此只需要维护前一行即可：

java复制public List<Integer> getRow(int rowIndex) {
    List<Integer> row = new ArrayList<>();
    for(int i = 0; i <= rowIndex; i++) {
        row.add(1);
        for(int j = i-1; j > 0; j--) {
            row.set(j, row.get(j) + row.get(j-1));
        }
    }
    return row;
}

这个版本的空间复杂度降到了O(n)，但仍有优化空间。

3. 最优解法实现

3.1 原地修改技巧

最优雅的解法是原地修改列表，从后向前更新元素：

java复制public List<Integer> getRow(int rowIndex) {
    List<Integer> currentRow = new ArrayList<>();
    currentRow.add(1);
    for(int i = 1; i <= rowIndex; i++){
        currentRow.add(1);
        for(int j = i - 1; j > 0; j--){
            currentRow.set(j, currentRow.get(j) + currentRow.get(j - 1));
        }
    }
    return currentRow;
}

关键点在于内层循环必须从后向前遍历。如果从前向后计算，会导致使用的"左邻居"已经是更新后的值，破坏了计算逻辑。

3.2 数学公式解法

杨辉三角的第n行第k个元素实际上是组合数C(n,k)。因此可以直接计算：

java复制public List<Integer> getRow(int rowIndex) {
    List<Integer> row = new ArrayList<>();
    row.add(1);
    for(int k = 1; k <= rowIndex; k++){
        long val = row.get(k-1) * (rowIndex - k + 1L) / k;
        row.add((int)val);
    }
    return row;
}

这种方法时间复杂度O(n)，空间复杂度O(1)（不考虑返回列表），但需要注意整数溢出问题。

4. 关键细节与边界处理

4.1 遍历方向的重要性

为什么必须从后向前更新？来看一个具体例子：

假设当前行是[1,3,3,1]，要计算下一行：

1. 先追加1得到[1,3,3,1,1]
2. 如果从前向后更新：
   • j=1: [1,4,3,1,1] (3+1)
   • j=2: [1,4,7,1,1] (3+4) → 错误
3. 从后向前更新：
   • j=3: [1,3,3,4,1] (1+3)
   • j=2: [1,3,6,4,1] (3+3)
   • j=1: [1,4,6,4,1] (3+1) → 正确

4.2 空间复杂度分析

最优解法的空间复杂度是O(n)：

• 只使用一个列表存储当前行
• 每次迭代在原地修改这个列表
• 最终结果就是这个列表，无需额外空间

4.3 边界条件处理

需要特别注意的边界情况：

• rowIndex=0 → 返回[1]
• rowIndex=1 → 返回[1,1]
• 大数情况（特别是数学公式解法要注意溢出）

5. 实际编码中的常见问题

5.1 初始化错误

常见错误是忘记初始化第一行的1：

java复制// 错误示例
List<Integer> row = new ArrayList<>(); 
// 直接开始循环，缺少初始1

5.2 索引越界

在内层循环中容易出现的索引错误：

java复制// 错误示例
for(int j = i; j > 0; j--){  // j应该从i-1开始
    row.set(j, row.get(j) + row.get(j-1));
}

5.3 遍历方向错误

最常见的错误就是从前向后更新：

java复制// 错误示例
for(int j = 1; j < i; j++){  // 应该从后向前
    row.set(j, row.get(j) + row.get(j-1));
}

5.4 数学解法的溢出问题

使用组合数公式时，中间计算结果可能超出int范围：

java复制// 不安全实现
int val = row.get(k-1) * (rowIndex - k + 1) / k;  // 可能溢出

应该使用long类型：

java复制long val = row.get(k-1) * (rowIndex - k + 1L) / k;
row.add((int)val);

6. 性能对比与测试

6.1 时间复杂度比较

6.2 实际运行测试

对rowIndex=30的测试结果（Java，平均5次运行）：

数学解法虽然理论复杂度最优，但在实际中小规模数据中优势不明显，且需要考虑溢出问题。

7. 扩展思考与应用

7.1 杨辉三角的性质应用

杨辉三角在编程中有多种应用场景：

• 组合数学计算
• 概率统计
• 多项式展开系数
• 动态规划中的状态转移

7.2 类似问题练习

掌握这个解法后，可以尝试解决以下类似问题：

• 生成整个杨辉三角（LeetCode 118）
• 二维矩阵中的最小路径和
• 三角形的最小路径和（LeetCode 120）

7.3 多语言实现比较

不同语言实现时需要注意的特性：

Python利用列表推导式的简洁实现：

python复制def getRow(rowIndex):
    row = [1]
    for _ in range(rowIndex):
        row = [x + y for x, y in zip([0]+row, row+[0])]
    return row

C++利用vector的高效实现：

cpp复制vector<int> getRow(int rowIndex) {
    vector<int> row(rowIndex+1, 1);
    for(int i=1; i<rowIndex; ++i) {
        for(int j=i; j>0; --j) {
            row[j] += row[j-1];
        }
    }
    return row;
}

8. 面试技巧与注意事项

在面试中遇到这个问题时，建议采取以下策略：

1. 先明确问题要求和边界条件
2. 从暴力解法开始，逐步优化
3. 重点解释为什么需要从后向前更新
4. 讨论时间空间复杂度的优化过程
5. 考虑可能的数学解法及其限制

常见面试问题：

• 为什么不能从前向后更新？
• 如何优化空间复杂度？
• 数学解法的优缺点是什么？
• 如何处理大数情况下的溢出问题？

在实际编码时，我通常会先写出基础DP解法，然后观察是否可以优化空间，最后考虑数学解法。这种循序渐进的方法能展示出解决问题的完整思路。