题目信息

题目地址：https://leetcode-cn.com/problems/pascals-triangle/

给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。在「杨辉三角」中，每个数是它左上方和右上方的数的和。

示例 1:

java
1
2
输入: numRows = 5
输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]

示例 2:

java
1
2
输入: numRows = 1
输出: [[1]]

提示:

  • 1 <= numRows <= 30

题解

依题意知道当前数组的第j个值等于前一个数组的j-1的值加上j位的值，也就是

java
1
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];

也就是通过双循环，第一层遍历各个数组，第二层遍历当前数组各个元素，中间元素的每个值通过上述公式计算

题解如下：

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public List<List<Integer>> generate(int numRows) {
    // 结果集
    List<List<Integer>> result = new ArrayList<>();
    //遍历每层数组
    for(int i = 0; i < numRows; i++){
        // 第一层和第二层的边界情况
        if(i == 0) {
            result.add(Arrays.asList(1));
            continue;
        }
        if(i == 1) {
            result.add(Arrays.asList(1,1));
            continue;
        }
        // 获取上一层数组
        List<Integer> pre = result.get(i-1);
        //数组边界值
        int[] cur = new int[i+1];
        cur[0] = 1;
        cur[i] = 1;
        // 通过上一层数组的左右元素求当前元素
        for(int j = 1; j < i; j++){
            cur[j] = pre.get(j-1) + pre.get(j);
        }
        // 数组转list
        result.add(Arrays.stream( cur ).boxed().collect(Collectors.toList()));
    }
    return result;
}

依题意书写而成,边界处理需要优化,时间复杂度n^2是避免不了的。

边界的判断有点重复了。在开局两个判断第一个数组和第二个数组的特殊情况，又在循环中添加了每个数组头尾都是1的设置。一个索引它不属于首尾位置，那么它所属的数组就一定是三排以下.

代码结构调整：

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public List<List<Integer>> generate(int numRows) {
    // 结果集
    List<List<Integer>> result = new ArrayList<>();
    //遍历每层数组
    for(int i = 0; i < numRows; i++){
        // 定义当前数组
        int[] cur = new int[i+1];
        // 首位设置1，中间pre计算
        for(int j = 0; j <= i; j++){
            if(j == 0 || j == i){
                cur[j] = 1;
                continue;
            }
            // 获取上一层数组
            List<Integer> pre = result.get(i-1);
            cur[j] = pre.get(j-1) + pre.get(j);
        }
        // 数组转list
        result.add(Arrays.stream( cur ).boxed().collect(Collectors.toList()));
    }
    return result;
}

总结

本题的话难度倒是没有什么，逻辑梳理完实现完，考虑下是否有冗余的情况。可能主要出现在各个算法课程里的前面章节用来熟悉代码实现的。