20210716力扣119题：杨辉三角II(java)

系列文章目录

给定一个非负索引 k，其中 k ≤ 33，返回杨辉三角的第 k 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

示例:

输入: 3
输出: [1,3,3,1]
进阶：

你可以优化你的算法到 O(k) 空间复杂度吗？

来源：力扣（LeetCode）
链接：https

---

想法

想直接用上一个题118题的方法，想想算了，自己写吧，
但是写出来 感觉就是差了点，因为存在第0行。

class Solution {
    public List<Integer> getRow(int rowIndex) {
        int[][] yh = new int[rowIndex][rowIndex];
        int rowaddone = rowIndex+1;
        List<Integer>  list = new ArrayList<>();
        for(int i = 0 ; i <rowIndex;i++)
        {
            
            for(int j= 0 ; j<=i;j++)
            {
                if(j == 0 ||i==j)
                {
                    yh[i][j] = 1 ;
                }
                else
                {
                    yh[i][j] =  yh[i-1][j-1]+yh[i-1][j];
                }

                if(i==rowIndex-1)
             {
                list.add(yh[i][j]);
                }
            } 

        }

//比如输入3 得到的是[1,2,1]，不是[1,3,3,1]，所以多了这一步
        List<Integer>  list1 = new ArrayList<>();
        list1.add(1);
        for(int i = 1 ; i<list.size();i++)
        {
            list1.add(list.get(i)+list.get(i-1));
        }
        list1.add(1);


        return list1;
    }
}

如果i<rowaddone，还是出错。所以我加了下面的List1重新计算。
这个题 最终通过33/34，特殊情况0没有通过。

class Solution {
    public List<Integer> getRow(int rowIndex) {
        int[][] yh = new int[rowIndex+1][rowIndex+1];
        int rowaddone = rowIndex+1;
        List<Integer>  list = new ArrayList<>();
        for(int i = 0 ; i <rowaddone;i++)
        {
            
            for(int j= 0 ; j<=i;j++)
            {
                if(j == 0 ||i==j)
                {
                    yh[i][j] = 1 ;
                }
                else
                {
                    yh[i][j] =  yh[i-1][j-1]+yh[i-1][j];
                }

                if(i==rowIndex)
             {
                list.add(yh[i][j]);
                }
            } 

        }
        return list;
    }
}

这个应该算O(k的平方)空间复杂度，我看看有没有其他好的方法通过。

感觉这个代码好强。

class Solution {
    public List<Integer> getRow(int rowIndex) {
       Integer[] dp =new Integer[rowIndex+1];
       Arrays.fill(dp,1);
       for(int i = 2 ; i<rowIndex+1;i++)
       {
           for(int j = i-1 ;j>0;j-- )
           {
               dp[j] = dp[j]+dp[j-1];
           }
       }
       List<Integer> list = Arrays.asList(dp);
       return list;
    }
}

第二个for循环使用倒序更新。

使用倒序 ，倒序的时候后面的数字都是1，还没有变 ，正序的时候， 当前数改变之后，后面的数字再使用dp[j-1]就出错了。
因为每一行的dp[i]是取决于上一行的 j 位置和 j-1 位置，如果不倒着更新，在下一个j+1位置的时候，计算的 j -1 已经被改过了，就错了。

总结

第二个方法，从后往前，这点倒是很新颖，官方也是这种解法，使用一个数组，感觉自己还有些不理解。