118 杨辉三角

木瓜煲鸡脚

发布于 2021-11-30 15:40:29

3680

发布于 2021-11-30 15:40:29

文章被收录于专栏：Jasper小笔记

题目信息

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

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

示例 1:

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

示例 2:

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

提示:

1 <= numRows <= 30

题解

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

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

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

题解如下：

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的设置。一个索引它不属于首尾位置，那么它所属的数组就一定是三排以下.

代码结构调整：

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;
}

或者说我们还是像之前一样把首尾的1拿出去，至于有木有上一层在循环取就好。这样的话我们可以在遍历元素时只遍历一半，毕竟另一半是对称的。

如下：

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];
        cur[0] = cur[i] = 1;
        for(int j = 1; j <= i/2; j++){
            List<Integer> pre = result.get(i-1);
            cur[j] = cur[i-j] = pre.get(j-1) + pre.get(j);
        }
        result.add(Arrays.stream( cur ).boxed().collect(Collectors.toList()));
    }
    return result;
}

总结

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

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2021-11-10，如有侵权请联系 cloudcommunity@tencent.com 删除

编程算法

本文分享自 IT那个小笔记微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

编程算法

登录后参与评论

0 条评论

热度