代码随想录-动态规划18

leetcode-509-斐波那契数

int fib(int n) {
    if(n <= 1)
        return n;
    int* dp = (int*)malloc(sizeof(int)*(n+1));
    dp[0] = 0, dp[1] = 1;
    for(int i = 2 ; i <= n ; i++){
        dp[i] = dp[i-1] + dp[i-2];
    }
    return dp[n];
}

leetcode-70-爬楼梯

爬到n层台阶，需要从n-1层和n-2层推到而来

n-1层爬一步到n层

n-2层爬两步到n层

int climbStairs(int n) {
    if(n <= 2)
        return n;
    int* dp = (int*)malloc(sizeof(int)*(n+1));
    dp[0] = 0, dp[1] = 1, dp[2] = 2;
    for(int i = 3 ; i <= n ; i++){
        dp[i] = dp[i-1] + dp[i-2];
    }
    return dp[n];
}

leetcode-746-使用最小花费爬楼梯

从dp[i - 1]跳还是从dp[i - 2]跳

一定是选最小的，所以dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);

int minCostClimbingStairs(int* cost, int costSize) {
    int* dp = (int*)malloc(sizeof(int)*(costSize+1));
    dp[0] = 0, dp[1] = 0;
    for(int i = 2 ; i <= costSize ; i++){
        dp[i] = fmin(dp[i-1] + cost[i-1] , dp[i-2] + cost[i-2]);
    }
    return dp[costSize];
}

leetcode-62-不同路径

1.dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。

2.想要求dp[i][j]，只能有两个方向来推导出来，即dp[i - 1][j] 和 dp[i][j - 1]。

dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

3.

for (int i = 0; i < m; i++) dp[i][0] = 1;
for (int j = 0; j < n; j++) dp[0][j] = 1;

int uniquePaths(int m, int n) {
    int** dp = (int**)malloc(sizeof(int*)*m);
    for(int i = 0 ; i < m ; i++){
        dp[i] = (int*)malloc(sizeof(int)*n);
        memset(dp[i],0,n);
    }
    for(int i = 0 ; i < m ; i++){
        dp[i][0] = 1;
    }
    for(int j = 0 ; j < n ; j++){
        dp[0][j] = 1;
    }
    for(int i = 1 ; i < m ; i++){
        for(int j = 1 ; j < n ; j++){
            dp[i][j] = dp[i-1][j] + dp[i][j-1];
        }
    }
    return dp[m-1][n-1];
}

leetcode-63-不同路径II

注意初始化条件改变

for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;

int uniquePathsWithObstacles(int** obstacleGrid, int obstacleGridSize, int* obstacleGridColSize) {
    int m = obstacleGridSize;
    int n = obstacleGridColSize[0];
    int** dp = (int**)malloc(sizeof(int*)*m);
    for(int i = 0 ; i < m; i++){
        dp[i] = (int*)malloc(sizeof(int)*n);
    }
    for(int i = 0 ; i < m ; i++){
        for(int j = 0 ; j < n ; j++){
            dp[i][j] = 0;
        }
    }
    for(int i = 0 ; i < m ; i++){
        if(obstacleGrid[i][0] == 0){
            dp[i][0] = 1;
        }else{
            break;
        }
    }
    for(int j = 0 ; j < n ; j++){
        if(obstacleGrid[0][j] == 0){
            dp[0][j] = 1;
        }else{
            break;
        }
        
    }
    for(int i = 1 ; i < m ; i++){
        for(int j = 1 ; j < n ; j++){
            if(obstacleGrid[i][j] == 0){
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }else{
                dp[i][j] = 0;
            } 
        }
    }
    return dp[m-1][n-1];
}