代码随想录算法训练营第39天|不同路径、不同路径II

不同路径【Mid】

62. 不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

用dp来写

code

d[x][y]表示从start开始到点（x,y）有d[x][y]种走法

关键点在于只能向下走或者向右走，所以x和y都智能递增，是不可能回头的，所以对于边缘d[x][1]和d[1][y]都应该初始化为1；

/**
 * @param {number} m
 * @param {number} n
 * @return {number}
 */
var uniquePaths = function(m, n) {
    //初始化d[x][y]边缘元素为1
    let d = new Array(m + 1);
    for(let x = 1; x <= m; x++){
        d[x] = new Array(n + 1);
        if(x == 1) d[1].fill(1);
        d[x][1] = 1;
    }
    for(let x = 2; x <= m; x++){
        for(let y = 2; y <= n; y++){
            d[x][y] = d[x][y - 1] + d[x - 1][y];
        }
    }
    console.log(d);
    return d[m][n];
};

DFS的基本写法

在JavaScript中，深度优先搜索（DFS）的一般写法与其他编程语言类似。下面是一个基本的DFS函数示例，用于在一个图或树结构中进行深度优先搜索：

function dfs(node, visited) {
    if (visited.has(node)) {
        return;
    }
    
    // 处理当前节点
    visited.add(node);
    
    // 遍历当前节点的相邻节点
    for (let neighbor of node.neighbors) {
        if (!visited.has(neighbor)) {
            dfs(neighbor, visited);
        }
    }
}

// 初始化访问记录
let visited = new Set();

// 从起始节点开始进行DFS
dfs(startNode, visited);

在这段代码中，dfs()函数表示深度优先搜索的递归函数，接受一个节点node和一个记录访问情况的visited集合作为参数。在DFS过程中，首先检查当前节点是否已经被访问过，如果已经访问过则直接返回；否则将当前节点标记为已访问，并递归地对当前节点的相邻节点进行DFS遍历。

用dfs,会超时，时间复杂度会达到2^(m+n)次，所以不合适，但是思路是可行的，如果m和n较小的话

/**
 * @param {number} m
 * @param {number} n
 * @return {number}
 */
var uniquePaths = function(m, n) {
    function dfs(x, y) {
        // 如果越界，则认为这条路径不可行
        if (x >= m || y >= n) return 0;
        // 当到达终点时，返回1
        if (x === m - 1 && y === n - 1) return 1;
        // 向右走 + 向下走
        return dfs(x + 1, y) + dfs(x, y + 1);
    }

    return dfs(0, 0);
};

不同路径II

63. 不同路径 II

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

示例 1：

输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

示例 2：

输入：obstacleGrid = [[0,1],[0,0]]
输出：1

提示：

• m == obstacleGrid.length
• n == obstacleGrid[i].length
• 1 <= m, n <= 100
• obstacleGrid[i][j] 为 0 或 1

/**
 * @param {number[][]} obstacleGrid
 * @return {number}
 */
var uniquePathsWithObstacles = function(obstacleGrid) {
    //当（x,y）点是障碍点时，那么达到x,y的路径只能是0条，多加一个判断条件
    //初始化d[x][y]
    let m = obstacleGrid.length;
    let n = obstacleGrid[0].length;
    let d = new Array(m);
    for(let x = 0; x < m; x++){
        d[x] = new Array(n);
        let y = 0;
        while(x==0 && obstacleGrid[0][y]!=1 && y < n){
            d[0][y++] = 1
        }
        while(x==0 && y < n){
            d[0][y++] = 0;
        }
        if(obstacleGrid[x][0]!=1){
            d[x][0] = 1;
        } else {
            while(x < m){//这里有个易错点
              //如果在这个代码块种不加if(x < m)d[x] = new Array(n);，那么因为当x++的时候，下一个d[x]是没有定义为数组的，如果此时使用d[x][0]就会报不能给undefined赋值的错误
                d[x][0] = 0;
                x++;
                if(x < m)d[x] = new Array(n);
            }
        }     
    }
    for(let x = 1; x < m; x++){
        for(let y = 1; y < n; y++){
            if(obstacleGrid[x][y]==1){
                d[x][y] = 0;
            }else{
                d[x][y] = d[x-1][y] + d[x][y-1];
            }
        }
    }
    console.log(d);
    return d[m-1][n-1];

};