(笔记自用)leetcode动态规划进阶二题

题目一:最小花费爬楼梯

（一）题目描述:

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

示例 1：

输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
- 支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。

示例 2：

输入：cost = [1,100,1,1,1,100,1,1,100,1]
输出：6
解释：你将从下标为 0 的台阶开始。
- 支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。
- 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。
- 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。
- 支付 1 ，向上爬一个台阶，到达楼梯顶部。
总花费为 6 。

提示：

• 2 <= cost.length <= 1000
• 0 <= cost[i] <= 999

（二）解题代码:

int min(int a,int b)
{
    return a < b ? a : b ;
}

int minCostClimbingStairs(int* cost, int costSize) {
    //分析:题意为 cost[i]是你站在第i个台阶往上爬需要的花费(无论你爬一步还是两步都花费cost[i]),即做出行动的花费
    //     顶楼为costSize,可以在第0个台阶开始,也可以在第1个台阶开始
    //递推公式: dp[i]=min{dp[i-1]+cost[i-1], dp[i-2]+cost[i-2]}
    //解释: dp[i]:爬上第i个台阶的花费, 取它们的最小值即最小花费
    //      dp[i-1]:爬上第i-1个台阶的花费   cost[i-1]:从第i-1个台阶行动的花费
    //      dp[i-2]:爬上第i-2个台阶的花费   cost[i-2]:从第i-2个台阶行动的花费
    int* dp=(int*)malloc(sizeof(int)*(costSize+1));
    dp[0]=0;
    dp[1]=0;    //因为到达第0个台阶和第1个台阶不需要花费
    for(int i=2;i<=costSize;i++)
        dp[i]= min( dp[i-1]+cost[i-1] , dp[i-2]+cost[i-2] );
    return dp[costSize];
}

题目二：杨辉三角

（一）题目描述：

给定一个非负整数 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

（二）解答代码：

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */

int** generate(int numRows, int* returnSize, int** returnColumnSizes)
{
    *returnSize = numRows;

    //创建一个numRows*numRows的二维数组
    int** dp = (int ** ) malloc(sizeof(int *) * numRows);   //创建一个numRows行的二维数组
    *returnColumnSizes = malloc(sizeof(int) * numRows);     //为每个二维数组的行分配内存空间


    for( int i = 0; i < numRows; i++)     //遍历行
    {
        dp[i] = (int *) malloc(sizeof(int ) * (i + 1));
        (*returnColumnSizes)[i] = i+ 1;
        for(int j = 0; j < i + 1 ; j++ )   //遍历列
        {
            if(j == 0 || j==i )  //当j为行首或行尾时置1
            {
                dp[i][j] = 1;
            }
            else
            {
                dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
            }
        }
    }
   
    return dp;
}