动态规划浅淡1（C语言）

本题很容易联想到回溯算法，因为是路径问题，但非常可惜题目有时间限制，基于暴力的回溯算法显然会超时。因为dfs会递归探索从起点到终点的每一条可能路径，在最坏的情况下（没有障碍物且每次都能向下或向右移动），搜索的路径数量是指数级别的，即最多有 2^(m+n） 条路径。时间复杂度： O(2^(m+n）).

考虑下面这种做法：

我们现在想求得到达坐标（i，j）的路径总数，因为机器人只能从上方的格子或者左边的格子来，因此到坐标（i，j）的路径总数应该是到达（i-1，j）和（i，j-1）的路径之和。

因此，我们可以定义一个二维数组dp[][],dp[i][j]表示的就是到达坐标（i，j）的路径总数，有递推公式dp[i][j]=dp[i][j-1]+dp[i-1][j]。

分析完了一般情况，再分析特殊情况：

• 起点有障碍物：

  • 如果起点 (0, 0) 有障碍物，那么机器人无法出发，路径数为 0。
  • 处理方法：将 dp[0][0] 初始化为 0。

• 有障碍物的格子：

  • 如果格子 (i, j) 有障碍物，那么机器人无法通过该格子，到达这个格子的路径数为 0。
  • 处理方法：设置 dp[i][j] = 0，直接跳过此格子的路径计算。

• 边界情况：

  • 第一行：在第一行的格子，只能从左侧到达，因此 dp[i][0] = dp[i-1][0]，但如果某个格子有障碍物，那么障碍物右侧的所有格子的路径数都为 0。
  • 第一列：在第一列的格子，只能从上方到达，因此 dp[0][j] = dp[0][j-1]，但如果某个格子有障碍物，那么障碍物下方的所有格子的路径数都为 0。
  • 为了简化代码，可以舍去数组的第一行和第一列的特殊处理。将这些边界元素直接赋值为 0，这样起点从 (1, 1) 开始，所有位置的递推关系统一为 dp[i][j] = dp[i-1][j] + dp[i][j-1]，并且不需要额外考虑边界条件。

    int uniquePathsWithObstacles(int** obstacleGrid, int obstacleGridSize, int* obstacleGridColSize) {
        // 获取行数和列数
        int m = obstacleGridSize;
        int n = *obstacleGridColSize;
    
        // 定义 DP 数组
        int dp[m][n];
    
        // 初始化起点
        dp[0][0] = (obstacleGrid[0][0] == 1) ? 0 : 1;
    
        // 初始化第一列
        for (int i = 1; i < m; i++) {
            // 如果当前位置是障碍物或者上一个位置为 0，则当前为 0
            dp[i][0] = (obstacleGrid[i][0] == 1 || dp[i - 1][0] == 0) ? 0 : 1;
        }
    
        // 初始化第一行
        for (int j = 1; j < n; j++) {
            // 如果当前位置是障碍物或者左边的位置为 0，则当前为 0
            dp[0][j] = (obstacleGrid[0][j] == 1 || dp[0][j - 1] == 0) ? 0 : 1;
        }
    
        // 遍历网格，根据递推公式 dp[i][j] = dp[i-1][j] + dp[i][j-1]
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                // 如果当前位置是障碍物，则路径数为 0
                if (obstacleGrid[i][j] == 1) {
                    dp[i][j] = 0;
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
    
        // 返回终点的路径总数
        return dp[m - 1][n - 1];