代码随想录训练营29-动态规划2

一、动态规划总结

具体可以参考代码随想录。

二、62 不同路径

题目需要从[0, 0]到[m, n]位置，求多少种路径；

因此：dp[i][j]代表位置[i, j]上路径种类；初始化过程，从0位置开始，一直横向或者一直纵向，只有一种路径；

状态转移公式：dp[i][j] = dp[i-1][j] + dp[i][j-1]

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

    //初始化
    for(int i = 0; i < n; i++)
    {
        dp[0][i] = 1;
    }
    for(int i = 0; i < m; i++)
    {
        dp[i][0] = 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];
}

三、63. 不同路径 II

 题目设置障碍，主要怎么去思考障碍的处理：

1 初始化时候，如果某一行或者某一列的一个位置出现了障碍，那么后面的位置不能使用了，应该初始化为0

2 在其他位置出现障碍，该位置不再进行计算，跳过；

int uniquePathsWithObstacles(int** obstacleGrid, int obstacleGridSize, int* obstacleGridColSize) {
    int m = obstacleGridSize;
    int n = *obstacleGridColSize;
    int** dp = (int**)malloc(sizeof(int*) * (m + 1));
    for(int i = 0; i <= m; i++)
    {
        dp[i] = (int*)calloc(n+1, sizeof(int));
    }

    //初始化
    for(int i = 0; i < n; i++)
    {
        if(obstacleGrid[0][i] != 0)
        {
            break;
        }
        dp[0][i] = 1;
    }
    for(int i = 0; i < m; i++)
    {
        if(obstacleGrid[i][0] != 0)
        {
            break;
        }
        dp[i][0] = 1;
    }

    for(int i = 1; i < m; i++)
    {
        for(int j = 1; j < n; j++)
        {
            if(obstacleGrid[i][j] == 1)
            {
                continue;
            }
            dp[i][j] = dp[i -1][j] + dp[i][j -1];
        }
    }
    return dp[m-1][n-1];
}

四、343. 整数拆分

 根据题目，需要怎样遍历，思路是(i - j)* j，j来遍历，数学上已经证明过，j是1 到j/2区间能取最大值，超过了就逐渐减小。

注意：0和1无法拆分，dp无意义；dp[i]代表的是整数i的最大值。

从1遍历j，两种方式得到dp[i]：

一个是j * (i - j) 直接相乘。j * (i - j) 是单纯的把整数拆分为两个数相乘;

一个是j * dp[i - j]，其中dp[i - j]相当于是拆分(i - j)，j * dp[i - j]是拆分成两个以及两个以上的个数相乘。

因此，需要去比较三个数，dp[i] 、dp[i-j] * j 、 (i - j) * j，找到最大的值，作为当前dp[i]。

//取三数最大值
int max(int num1, int num2, int num3) {
    int tempMax = num1 > num2 ? num1 : num2;
    return tempMax > num3 ? tempMax : num3;
}
int integerBreak(int n) {
    //dp初始化 dp[i]代表i整数的最大的整数乘积，
    int* dp = (int*)malloc(sizeof(int) * (n + 1));
    //dp 0 1无意义，无法拆
    dp[2] = 1;

    for(int i = 3; i <= n; i++)
    {
        for(int j = 1; j <= i/2; j++)
        {
            //(i -j)* j:是j遍历过程中的乘积
            dp[i] = max(dp[i], (i -j)*j, dp[i-j] * j);
        }
    }
    return dp[n];
}

五、96.不同的二叉搜索树

 解析思路可参考代码随想录：

dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量]

递推公式：dp[i] += dp[j - 1] * dp[i - j]; ，j-1 为j为头结点左子树节点数量，i-j 为以j为头结点右子树节点数量。

int numTrees(int n) {
    //初始化
    int* dp = (int*)calloc(n+1, sizeof(int));//malloc(sizeof(int) * (n + 1));

    dp[0] = 1;

    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= i; j++)
        {
            dp[i] += dp[j - 1] * dp[i - j];
        }
    }

    return dp[n];
}