杨辉三角1，2

1.给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。
在「杨辉三角」中，每个数是它左上方和右上方的数的和。
示例 1:
输入: numRows = 5
输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]

转化为二维数组：

动态规划思路：
不断在前面的基础之上更新下一层的数值，一层层往下算。
核心算法：dp[i][j]=dp[i-1][j-1]+dp[i-1][j]
（当然此题能用滑动窗口来优化动态规划，最后给出）

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>> dp(numRows,vector<int>(numRows,0));
        for(int i=0;i<numRows;i++)
        {
            dp[i].resize(i+1);
            dp[i][0]=1;
            dp[i][i]=1;
        }
        for(int i=2;i<numRows;i++)
        {
            for(int j=1;j<i;j++)
            {
                dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
            }
        }
        return dp;
    }
};

2.给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。
在「杨辉三角」中，每个数是它左上方和右上方的数的和。
示例 1:
输入: rowIndex = 3
输出: [1,3,3,1]

此题思路和前面一题基本类似，就不说了。

class Solution {
public:
    vector<int> getRow(int rowIndex) {
        vector<vector<int>> dp(rowIndex+1);
        for(int i=0;i<rowIndex+1;i++)
        {
            dp[i].resize(i+1);
            dp[i][0]=1;
            dp[i][i]=1;
        }
        for(int i=2;i<rowIndex+1;i++)
        {
            for(int j=1;j<i;j++)
            {
                dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
            }
        }
        vector<int> temp = dp[rowIndex];
        return temp;
    }
};

拓展：可以用动态窗口来优化动态规划
以第二题为例:（代码贴的一位力扣大佬的）

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

补充，为啥要倒着更新？
因为每一行的dp值都是由上一行求出，如果正序更新的话，在求下一行的dp值时，前面的dp值已经改变了，就错了。