LeetCode-119

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

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

示例:

输入: 3
输出: [1,3,3,1]

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

//较高空间复杂度O(k2)
    /*public List<Integer> getRow(int rowIndex) {
        if (rowIndex < 0) {
            return new ArrayList<>();
        }
        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        List<Integer> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(1);

        List<List<Integer>> list = new ArrayList<>();
        if (rowIndex == 0) {
            return list1;
        }
        if (rowIndex == 1) {
            return list2;
        }
        list.add(list1);
        list.add(list2);
        for (int i = 2; i <= rowIndex; i++) {
            List<Integer> addlist = new ArrayList<>();
            for (int j = 0; j <= i; j++) {
                if (j == 0) {
                    addlist.add(1);
                } else if (j <= i / 2) {
                    addlist.add(list.get(i - 1).get(j - 1) + list.get(i - 1).get(j));
                } else addlist.add(addlist.get(i - j));
            }
            list.add(addlist);
        }
        return list.get(rowIndex);*/

    //这个方法利用动态规划思想，由数组两端向内不断进行自运算
    public List<Integer> getRow(int rowIndex) {
        List<Integer> list = new ArrayList<>();
        Integer[] nums = new Integer[rowIndex + 1];
        Arrays.fill(nums, 1);
        for (int i = 1; i < rowIndex; i++) {
            for (int j = i; j > 0; j--) {
                nums[j] = nums[j] + nums[j - 1];
            }
        }
        return Arrays.asList(nums);
    }

第一种暴力解法，开辟大量空间，存放杨辉三角的每一层内容，最后直接查找。空间复杂度较高
第二中采用了动态规划的思想，非常巧妙的在每一层循环中进行自后向前的自运算。先开辟k大小的空间，并填入1，第i次循环时使用空间中前i项进行自运算。