[LeetCode]118. Pascal's Triangle&119. Pascal's Triangle II

118 . Pascal’s Triangle
Easy

Given numRows, generate the first numRows of Pascal’s triangle.

For example, given numRows = 5,
Return

[
[1],
[1,1],
[1,2,1],
[1,3,3,1],
[1,4,6,4,1]
]

1ms:

public List<List<Integer>> generate(int numRows) {
         List<List<Integer>> result = new ArrayList<List<Integer>>();
         if(numRows==0) return result;
         List<Integer> first = new ArrayList<Integer>();
         first.add(1);
         result.add(first);
         if(numRows==1) return result;
         List<Integer> second = new ArrayList<Integer>();
         second.add(1);second.add(1);
         result.add(second);
         if(numRows==2) return result;
         for(int i=2;i<numRows;i++){
             List<Integer> level = new ArrayList<Integer>();
             level.add(1);
             for(int j=1;j<i;j++){
                 level.add(result.get(i-1).get(j-1)+result.get(i-1).get(j));
             }
             level.add(1);
             result.add(level);
         }
         return result;
     }

119 . Pascal’s Triangle II
Easy
Given an index k, return the kth row of the Pascal’s triangle.

For example, given k = 3,
Return [1,3,3,1].

Note:
Could you optimize your algorithm to use only O(k) extra space?

2ms：

 public List<Integer> getRow(int rowIndex) {
        List<Integer> res = new ArrayList<>();
        if (rowIndex < 0) return res;
        // O(k) Memory
        int[] prevLevel = new int[rowIndex+1];
        for (int i = 0; i < rowIndex + 1; ++i) {
            int diff = 0;
            for (int index = 0; index <= i; ++index) {
                if (index == 0 || index == i) {
                    prevLevel[i] = 1;
                } else {
                    int newVal = prevLevel[index] + prevLevel[index-1] - diff;
                    diff = newVal - prevLevel[index];
                    prevLevel[index] =  newVal;
                }
            }
        }

        // Construct the result
        for (int num : prevLevel) {
            res.add(num);
        }
        return res;
    }

Based on rules:

row k of Pascal’s Triangle:

[C(k,0), C(k,1), …, C(k, k-1), C(k, k)]

and

C[k,i] = C[k,i-1]*(k-i+1)/i
1ms:

 public class Solution {
        public List<Integer> getRow(int rowIndex) {
            Integer[] rowList = new Integer[rowIndex+1];
            rowList[0] = 1;
            for(int i=1; i<rowList.length;i++) {
                rowList[i] = (int)((long)rowList[i-1]*(rowIndex-(i-1))/(i));
            }
            return Arrays.asList(rowList);
        }
    }