leetcode解题之62&63. Unique Paths ||64. Minimum Path Sum java版（路径（最短）可达）

62. Unique Paths

A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).

The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).

How many possible unique paths are there?

Above is a 3 x 7 grid. How many possible unique paths are there?

Note: m and n will be at most 100.

设path[i][j] 为从起点到（i,j）位置处的路径数。

第一行，第一列都为1（只能一个方向行走）

到其他位置处（i,j）：到达位置（i,j）只能从上面或者左面过来，因此决定到位置（i,j）的路径数由到达上面位置（i-1,j）的路径数和到达左面位置（i,j-1）的路径所决定的。

状态转移方程：

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

时间复杂度：O(n^2)  空间复杂度：O(n^2)

public int uniquePaths(int m, int n) {
		int[][] path = new int[m][n];
		for (int i = 0; i < m; i++)
			path[i][0] = 1;
		for (int i = 0; i < n; i++)
			path[0][i] = 1;
		for (int i = 1; i < m; i++)
			for (int j = 1; j < n; j++)
				path[i][j] = path[i - 1][j] + path[i][j - 1];
		System.out.println(path[m-1][n-1]);
		return path[m-1][n-1];
	}

想到用DFS+回溯来做但是超时！

int count;
	public int uniquePath(int m, int n) {
		boolean[][] visited = new boolean[m][n];
		dfsCore(visited, m, n, 0, 0);
		//System.out.println(count);
		return count;
	}

	private void dfsCore(boolean[][] visited, int m, int n, int row, int col) {
		if (row == m - 1 && col == n - 1) {
			count++;
			return;
		}
		if (col >= n || row >= m)
			return;
		if (visited[row][col])
			return;
		visited[row][col] = true;
		dfsCore(visited, m, n, row + 1, col);
		dfsCore(visited, m, n, row, col + 1);
		visited[row][col] = false;
	}

63. Unique Paths II

Follow up for "Unique Paths":

Now consider if some obstacles are added to the grids. How many unique paths would there be?

An obstacle and empty space is marked as 1 and 0 respectively in the grid.

For example,

There is one obstacle in the middle of a 3x3 grid as illustrated below.

[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]

The total number of unique paths is 2.

Note: m and n will be at most 100.

有障碍物，和上题一样，为1，那么此时path[i][j]为0，第一行和第一列注意初始化；

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
		int m = obstacleGrid.length;
		int n = obstacleGrid[0].length;
		int[][] path = new int[m][n];
		// 第一列行初始化，只能从上到下
		for (int i = 0; i < m; i++) {
			// 如果有一个为1，那么剩下的第一行全部不可达
			if (obstacleGrid[i][0] == 1)
				break;
			path[i][0] = 1;
		}
		// 第一行行初始化，只能从左到右
		for (int i = 0; i < n; i++) {
			// 如果有一个为1，那么剩下的第一行全部不可达
			if (obstacleGrid[0][i] == 1)
				break;
			// 默认值为0
			path[0][i] = 1;
		}
		for (int i = 1; i < m; i++)
			for (int j = 1; j < n; j++) {
				path[i][j] = path[i - 1][j] + path[i][j - 1];
				if (obstacleGrid[i][j] == 1)
					path[i][j] = 0;
			}
		// System.out.println(path[m - 1][n - 1]);
		return path[m - 1][n - 1];
	}

64. Minimum Path Sum（最小路径代价）

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

先处理最左边和最上边两条边，因为只有一条路。接下来每一点的值等于它上边和左边的较小值加上该点的数值~即为到达该点的最短路径

public int minPathSum(int[][] grid) {
		if (grid == null || grid.length == 0)
			return 0;
		int m = grid.length;
		int n = grid[0].length;
		int[][] dp = new int[m][n];
		
		dp[0][0] = grid[0][0];
		
		for (int i = 0; i < n - 1; i++)
			dp[0][i + 1] = dp[0][i] + grid[0][i + 1];
		for (int i = 0; i < m - 1; i++)
			dp[i + 1][0] = dp[i][0] + grid[i + 1][0];
		
		for (int i = 1; i < m; i++)
			for (int j = 1; j < n; j++)
				dp[i][j] = Math.min(dp[i - 1][j], 
						dp[i][j - 1]) + grid[i][j];
		return dp[m - 1][n - 1];
	}