leetcode_063 Unique Paths II

题意分析：此题与Unique Path是一样的，只是要单独考虑障碍物对整个棋盘的影响。

解题思路：

                           增加一个判断条件，如果有障碍物，此格填0，表示0个路径。

                           初始条件受障碍物影响如下：

                           1）假设整个棋盘只有一行，那么在第i个位置上设置一个障碍物后，说明位置i到最后一个格子这些

                                 路都没法走；

                           2）如果整个棋盘只有一列，那么在第i个位置上的障碍物，也会影响从第i位置往后的路；

                           综上，在初始条件中，如果一旦遇到障碍物，障碍物后面所有的格子的走法都是0。

                          方法一：动态规划实现

                           定义二维数组A[i][j]；

                           对于只有一列或只有一行的特殊情况处理。即只有存在障碍物，则路径为0，否则为1；

                           对于非一行和非一列的情况处理具体如下：

                           初始化A[i][j]中的第一列和第一行，具体为存在障碍物，则之后的路径全为0。否则为1；

                           递推公式为为 A[i][j] = (obstacleGrid[i-1][j] == 1 ? 0 : A[i-1][j]) + (obstacleGrid[i][j-1] == 1 ? 0 : A[i][j-1])；

                           最后返回A[m-1][n-1]即可。

                           方法二：动态规划 + 滚动数组实现

                           定义滚动数组A[m+1]；

                           初始化，原则：当某一列存在障碍物，则此时对应的A[i]值为0，否则此值A[i]值为1；

                           递推公式为 A[j+1] = (obstacleGrid[i][j] == 1 ? 0 : A[j] + A[j+1]；

                           最后返回A[m]即可。

class Solution
{
	public:
		// 方法一实现：动态规划 
		int uniquePathsWithObstacles(vector< vector<int> > &obstacleGrid) 
		{
			int m = obstacleGrid.size();
			int n = obstacleGrid[0].size();
			// 处理只有一行，或只有一列的情况 
			if (m == 1 || n == 1)
			{
				bool hasObstacle = false;
				for (int i = 0; i < m; i++)
				{
					for (int j = 0; j < n; j++)
					{
						if (obstacleGrid[i][j] == 1)
						{
							hasObstacle = true;
							break;
						}
					}
				}
				if (hasObstacle)
					return 0;
				else
					return 1; 
			}
			// 处理非一行也非一列的情况 
			vector< vector<int> > temp(m, vector<int>(n));
			if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1)
				return 0;
			temp[0][0] = 1;
			// 初始化第一列 
			for (int i = 1; i < m; i++)
			{
				if (obstacleGrid[i][0] == 1)
					temp[i][0] = 0;
				else
					temp[i][0] = temp[i - 1][0];
			}
			// 初始化第一行 
			for (int j = 1; j < n; j++)
			{
				if (obstacleGrid[0][j] == 1)
					temp[0][j] = 0;
				else
					temp[0][j] = temp[0][j - 1];
			}
			// 处理中间部分 
			for (int i = 1; i < m; i++)
			{
				for (int j = 1; j < n; j++)
				{
					temp[i][j] = (obstacleGrid[i - 1][j] == 1 ? 0 : temp[i - 1][j]) + (obstacleGrid[i][j - 1] == 1 ? 0 : temp[i][j - 1]);
				}
			}
			// 返回最终结果 
			return temp[m - 1][n - 1];
		} 
		
		// 方法二实现：动态规划 + 滚动数组 
		int uniquePathsWithObstacles2(vector< vector<int> > &obstacleGrid)
		{
			if (obstacleGrid.empty() || obstacleGrid[0].empty())
				return 0;
			int *temp = new int[obstacleGrid[0].size() + 1];
			temp[0] = 0;
			if (obstacleGrid[0][0])
				return 0;
			else
				temp[1] = 1;
			// 初始化处理 
			for (int i = 1; i < obstacleGrid[0].size(); i++)
			{
				if (obstacleGrid[0][i])
					temp[i + 1] = 0;
				else
					temp[i + 1] = temp[i]; 
			}
			// 中间部分处理 
			for (int i = 1; i < obstacleGrid.size(); i++)
			{
				for (int j = 0; j < obstacleGrid[0].size(); j++)
				{
					if (obstacleGrid[i][j])
						temp[j + 1] = 0;
					else
						temp[j + 1] += temp[j];
				}
			}
			// 最终返回值 
			return temp[obstacleGrid[0].size()]; 
		}
};