LeetCode - 二维网格(数组)路径类题目

不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。问总共有多少条不同的路径？

例如，上图是一个7 x 3 的网格。有多少可能的路径？
说明：m 和 n 的值均不超过 100。
示例 : 输入: m = 3, n = 2; 输出: 3
解释: 从左上角开始，总共有 3 条路径可以到达右下角。

1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右

分析：采用动态规划，如果采用回溯则时间复杂度高

 //动态规划
 class Solution {
public:
    int uniquePaths(int m, int n) {
        if (m == 0 || n == 0) {
            return 0;
        }
        vector<vector<int>> dp(m, vector<int>(n));
        dp[0][0] = 1;
        for (int i = 1; i < m; i++) {
            dp[i][0] = dp[i - 1][0];
        }
        for (int j = 1; j < n; j++) {
            dp[0][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];
    }
};
//回溯
 class Solution {
 public:
	 int uniquePaths(int m, int n) {
		 if (m <= 0 || n <= 0)
			 return 0;
		 return findPath(0,0,m,n);
	 }
	 int findPath(int x, int y,int m,int n)
	 {
		 if ( x >= m ||  y >= n)
			 return 0;
		 if (x == m - 1 && y == n - 1)
			 return 1;
		 return findPath(x + 1, y, m, n) + findPath(x, y + 1, m, n);
	 }
 };

---

不同路径II

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

分析： 采用动态规划

class Solution {
public:
	int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
		int m = obstacleGrid.size();
		if (m == 0)
			return 0;
		int n = obstacleGrid[0].size();
		if (n == 0)
			return 0;
		vector<vector<long>> dp(m, vector<long>(n, 0));
		for (int i = 0; i < m; i++)
			for (int j = 0; j < n; j++)
			{
				if (obstacleGrid[i][j] == 1)
				{
					dp[i][j] = 0;
					continue;
				}
				if (i == 0 && j == 0) {
					dp[i][j] = 1;
					continue;
				}
				if (i == 0)
				{
					dp[i][j] = dp[0][j - 1];
				}
				else if (j == 0) {
					dp[i][j] = dp[i - 1][j];
				}
				else
					dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
			}
		return dp[m - 1][n - 1];
	}
};

---

不同路径 III

在二维网格 grid 上，有 4 种类型的方格：1 表示起始方格。且只有一个起始方格。2 表示结束方格，且只有一个结束方格。0 表示我们可以走过的空方格。-1 表示我们无法跨越的障碍。返回在四个方向（上、下、左、右）上行走时，从起始方格到结束方格的不同路径的数目，每一个无障碍方格都要通过一次。

示例 ：输入：[[1,0,0,0],[0,0,0,0],[0,0,2,-1]], 输出：2
解释：我们有以下两条路径：

1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2)
2. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2)

分析： 让我们尝试遍历每一个 0 方格，并在走过的方格里留下一个障碍。回溯的时候，我们要删除那些自己留下的障碍。介于输入数据的限制，这个方法是可以通过的，因为一个不好的路径很快就会因没有无障碍的方格可以走而被卡住。dfs.首先统计空的个数作为必须走的步数.当达到grid[i][j]==2时,判断步数step是否为0.

class Solution {
	int dfs(vector<vector<int>>& grid, int r, int c, int n) {
		if (r < 0 || r >= grid.size() || c < 0 || c >= grid[r].size() || grid[r][c] == -1) return 0;
		if (grid[r][c] == 2) return n == 0 ? 1 : 0;
		grid[r][c] = -1;
		int sum = dfs(grid, r + 1, c, n - 1) + dfs(grid, r - 1, c, n - 1) + dfs(grid, r, c + 1, n - 1) + dfs(grid, r, c - 1, n - 1);
		grid[r][c] = 0;
		return sum;
	}
public:
	int uniquePathsIII(vector<vector<int>>& grid) {
		int step = 1, r = 0, c = 0;
		for (int i = 0; i < grid.size(); ++i)
			for (int j = 0; j < grid[i].size(); ++j)
				if (grid[i][j] == 1) r = i, c = j;
				else if (grid[i][j] == 0) ++step;
		return dfs(grid, r, c, step);
	}
};

---

最小路径和

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。说明：每次只能向下或者向右移动一步。
示例: 输入: [ [1,3,1], [1,5,1], [4,2,1] ]，输出: 7。解释: 因为路径 1→3→1→1→1 的总和最小。

分析： 动态规划

class Solution {
public:
	int minPathSum(vector<vector<int>>& grid) {
		int row = grid.size();
		if (row == 0)
			return 0;
		int column = grid[0].size();
		vector<vector<int>>dp(row,vector<int>(column,0));
		dp[0][0] = grid[0][0];
		for (int i = 1; i < row; i++)
			dp[0][i] = dp[0][i-1]+grid[0][i];
		for (int i = 1; i < column; i++)
			dp[i][0] = dp[i-1][0] + grid[i][0];
		for(int i=1;i<row;i++)
			for (int j = 1; j < column; j++) 
				dp[i][j] = min(dp[i-1][j],dp[i][j-1])+grid[i][j];
		return dp[row-1][column-1];
	}
};