力扣面试题08.02.:迷路的机器人（可回溯、可动态规划）
作者：互联网
一、题目内容
二、题目分析
机器人从左上角开始运动，每次只可以向右或者向下运动，不可以经过障碍物，到达右下角为成功。
那我们从（0,0）点开始，分别向右向下运动，如果运动的坐标超出的边界或者碰到障碍物或者坐标被访问过，就返回，如果是正常可访问的坐标，就将它放到数组中去，并且给它标记为已访问。
接下来我们需要判断，当前访问的点是否是右下角的点，如果是，就结束一切操作，否则继续向下个坐标进发。
class Solution {
boolean flag=false;
public List<List<Integer>> pathWithObstacles(int[][] obstacleGrid) {
int m=obstacleGrid.length;
int n=obstacleGrid[0].length;
boolean [][]visited=new boolean[m][n];
List<List<Integer>> list=new ArrayList<>();
backtrack(list,0,0,obstacleGrid,visited);
return list;
}
public void backtrack(List<List<Integer>> list,int i,int j,int [][]obstacleGrid,boolean[][]visited)
{
if(i>=obstacleGrid.length||j>=obstacleGrid[0].length||i<0||j<0||obstacleGrid[i][j]==1||visited[i][j])
{
return;
}
list.add(Arrays.asList(i, j));
visited[i][j]=true;
if((i==obstacleGrid.length-1)&&(j==obstacleGrid[0].length-1))
flag=true;
if(flag==false)
backtrack(list,i+1,j,obstacleGrid,visited);
if(flag==false)
backtrack(list,i,j+1,obstacleGrid,visited);
if(flag==false)
list.remove(list.size()-1);
}
}这部分是未经优化的代码，可以看到我用了大量的额外空间去标记它的访问情况，但是其实访问过的点可以直接将它设置为1，也就是看做障碍物，这样也可以达到不重复访问的效果。
还有一点就是，我重复的使用了诸如obstacleGrid.length之类复杂的语句，可以将它们直接定义为类的属性，简化代码。
另外还有一点需要提一下,在下面这句判断中
if(i>=obstacleGrid.length||j>=obstacleGrid[0].length||i<0||j<0||obstacleGrid[i][j]==1)
{
return;
}obstacleGrid[i][j]==1这句一定要写在最后面，因为前面的语句只要有一个正确，就会直接进入底下的return，不会执行 obstacleGrid[i][j]==1。但是如果将它放在第一个，可能i,j下标越界而错误。
最后就是为什么最后要写三个if语句，而不是将这三个语句写到一个if里。因为第一个
backtrack(list,i+1,j,obstacleGrid,visited);执行完之后，可能已经访问到最后一个点了，flag为true，可以直接退出了，但是如果写在一个if里，那么上面的程序执行完之后，还需要继续执行，显然有问题。
底下是简化后的代码：
class Solution {
boolean flag=false;
int m,n;
List<List<Integer>> list=new ArrayList<>();
public List<List<Integer>> pathWithObstacles(int[][] obstacleGrid) {
m=obstacleGrid.length;
n=obstacleGrid[0].length;
backtrack(0,0,obstacleGrid);
return list;
}
public void backtrack(int i,int j,int [][]obstacleGrid)
{
if(i>=obstacleGrid.length||j>=obstacleGrid[0].length||i<0||j<0||obstacleGrid[i][j]==1){
return;
}
list.add(Arrays.asList(i, j));
obstacleGrid[i][j]=1;
if((i==m-1)&&(j==n-1))
flag=true;
if(flag==false)
backtrack(i+1,j,obstacleGrid);
if(flag==false)
backtrack(i,j+1,obstacleGrid);
if(flag==false)
list.remove(list.size()-1);
}
} 
这个题目我已经全都在原数组操作了，但是内存消耗还是很大， 可以试试用动态规划做，先判断起点到终点是否可达，再倒序求路径。
（这部分非原创）
class Solution {
public:
vector<vector<int>> pathWithObstacles(vector<vector<int>>& obstacleGrid) {
vector<vector<int>> res;
int rows = obstacleGrid.size();
int cols = obstacleGrid[0].size();
// 先排除边缘情况，起点和重点不可达
if (obstacleGrid[0][0] == 1 || obstacleGrid[rows-1][cols-1] ==1)
{
return res;
}
// 初始化
bool d[rows][cols];
memset(d, 0, sizeof(bool)*rows*cols);
d[0][0] = 1;
// 首列
for (int i = 1; i < rows; ++i)
{
d[i][0] = (obstacleGrid[i][0] == 0) && d[i-1][0];
}
// 首行
for (int j = 1; j < cols; ++j)
{
d[0][j] = (obstacleGrid[0][j] == 0) && d[0][j-1];
}
// 计算
for (int i = 1; i < rows; ++i)
{
for (int j = 1; j < cols; ++j)
{
// 这里把两种情况都合并在一起了
// 先判断是否为0
// 再判断上一次位置是否可达
d[i][j] = (obstacleGrid[i][j] == 0) && (d[i-1][j] || d[i][j-1]);
}
}
// 结果
// 如果不可达，直接返回空结果
if (!d[rows-1][cols-1])
{
return res;
}
// 可达，倒序计算
int i = rows-1;
int j = cols-1;
while (i > 0 || j > 0)
{
// cout << i << "," << j << endl;
res.push_back({i, j});
// 判断上一步是上方的情况是否可达
if (i > 0 && d[i-1][j])
{
--i;
}
else
{
// 因为最后是可达，所以这里必然有一个可达的, 考虑上一步是左边的情况
--j;
}
}
// 插入起点
res.push_back({0,0});
// 倒序
reverse(res.begin(), res.end());
return res;
}
};
三、感言
动态规划几天没写，怎么手生了呢? ctmd....
标签：08.02,面试题,obstacleGrid,int,list,cols,力扣,length,rows 来源： https://blog.csdn.net/sjl20021006/article/details/120808026