标签：ni nj BFS vector grid 1293 LeetCode dp size

1. 题目

给你一个 m * n 的网格，其中每个单元格不是 0（空）就是 1（障碍物）。
每一步，您都可以在空白单元格中上、下、左、右移动。

如果您 最多 可以消除 k 个障碍物，请找出从左上角 (0, 0) 到右下角 (m-1, n-1) 的最短路径，并返回通过该路径所需的步数。
如果找不到这样的路径，则返回 -1。

示例 1：
输入： 
grid = 
[[0,0,0],
 [1,1,0],
 [0,0,0],
 [0,1,1],
 [0,0,0]], 
k = 1
输出：6
解释：
不消除任何障碍的最短路径是 10。
消除位置 (3,2) 处的障碍后，最短路径是 6 。
该路径是 (0,0) -> (0,1) -> (0,2) -> (1,2) -> (2,2) -> (3,2) -> (4,2).
 
示例 2：
输入：
grid = 
[[0,1,1],
 [1,1,1],
 [1,0,0]], 
k = 1
输出：-1
解释：
我们至少需要消除两个障碍才能找到这样的路径。
 
提示：
grid.length == m
grid[0].length == n
1 <= m, n <= 40
1 <= k <= m*n
grid[i][j] == 0 or 1
grid[0][0] == grid[m-1][n-1] == 0

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shortest-path-in-a-grid-with-obstacles-elimination
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2. 解题

• dp[i][j][s] 表示到（i,j）位置,消除了s个障碍物的最短步数
• 先用 BFS搜索跟起点相连的 非障碍物（0），记录每个到达的 0 位置 dp[i][j][0]的步数（BFS的层数）
• 然后在遍历所有可能的s，遍历所有的位置 i，j，下一个位置状态 ni，nj
• 如果(grid[ni][nj] && s+1 <= k) 是障碍物, 且还可以搬走
  则 dp[ni][nj][s+1] = min(dp[ni][nj][s+1], dp[i][j][s]+1)
• 如果 grid[ni][nj]不是障碍物
  则 dp[ni][nj][s] = min(dp[ni][nj][s], dp[i][j][s]+1)

class Solution {
public:
    int shortestPath(vector<vector<int>>& grid, int k) {
    	vector<vector<int>> dir = {{1,0},{0,1},{0,-1},{-1,0}};
        int m = grid.size(), n = grid[0].size(), i, j, ni, nj, s = 0, d;
        vector<vector<vector<int>>> dp(m,vector<vector<int>>(n, vector<int>(k+1, INT_MAX)));
        // dp[i][j][s] 表示到（i,j）位置,消除了s个障碍物的最短步数
        dp[0][0][0] = 0;
        vector<vector<bool>> vis(m, vector<bool>(n,false));
        queue<vector<int>> q;
        q.push({0,0});
        vis[0][0] = true;
        while (!q.empty()) //广度优先查找所有0位置，不用搬走障碍
        {
        	int size = q.size();
        	while(size--)
        	{
        		i = q.front()[0];
	        	j = q.front()[1];
                q.pop();
	        	dp[i][j][0] = s;//不用搬走障碍的最短步数
	        	for(d = 0; d < 4; ++d)
	        	{
	        		ni = i+dir[d][0];
        			nj = j+dir[d][1];
        			if(ni<0 || ni >= m || nj<0 || nj >= n || vis[ni][nj] || grid[ni][nj])
        				continue;//出界了，访问过，是障碍物
        			q.push({ni,nj});
        			vis[ni][nj] = true;
	        	}
        	}
        	s++;
        }
        for(s = 0; s <= k; s++)
        {	//障碍物
        	for(i = 0; i < m; i++) 
	        {	//位置 i
	        	for(j = 0; j < n; j++)
	        	{	//位置 j
                    if(dp[i][j][s] == INT_MAX)
                        continue;//状态不能走到，下一个
	        		for(d= 0; d < 4; ++d)
	        		{	//向4个方向移动，下一个坐标
	        			ni = i+dir[d][0];
	        			nj = j+dir[d][1];
	        			if(ni<0 || ni >= m || nj<0 || nj >= n)
	        				continue;//出界了，下一个
	        			if(grid[ni][nj] && s+1 <= k)//下一个位置为障碍物, 还可以搬走
		        			dp[ni][nj][s+1] = min(dp[ni][nj][s+1], dp[i][j][s]+1);
		        		else if(!grid[ni][nj])//不是障碍物
		        			dp[ni][nj][s] = min(dp[ni][nj][s], dp[i][j][s]+1);
	        		}
	        		
	        	}
	        }
        }
        int minstep = INT_MAX;
        for(s = 0; s <= k; ++s)
        	minstep = min(minstep, dp[m-1][n-1][s]);
        return minstep==INT_MAX ? -1 : minstep;
    }
};

640 ms 25.2 MB

• 或者直接BFS，队列内存储<i, j, 搬运障碍物次数>

class Solution {
public:
    int shortestPath(vector<vector<int>>& grid, int k) {
    	vector<vector<int>> dir = {{1,0},{0,1},{0,-1},{-1,0}};
        int m = grid.size(), n = grid[0].size(), i, j, ni, nj, step = 0, curs, d;
        vector<vector<vector<bool>>> vis(m,vector<vector<bool>>(n, vector<bool>(k+1, false)));
        queue<vector<int>> q;
        q.push({0,0,0});// i, j, s障碍物搬了几次
        vis[0][0][0] = true;
        while (!q.empty()) 
        {
        	int size = q.size();
        	while(size--)
        	{
        		i = q.front()[0];
	        	j = q.front()[1];
                curs = q.front()[2];
                if(i==m-1 && j==n-1)
                    return step;
                q.pop();
                for(d = 0; d < 4; ++d)
                {
                    ni = i+dir[d][0];
                    nj = j+dir[d][1];
                    if(ni<0 || ni >= m || nj<0 || nj >= n)
                        continue;//出界了
                    if(grid[ni][nj] && curs+1 <= k && !vis[ni][nj][curs+1])//是障碍物, 还能搬走
                    {
                        vis[ni][nj][curs+1] = true;
                        q.push({ni,nj,curs+1});
                    }
                    else if(!grid[ni][nj] && !vis[ni][nj][curs])//不是障碍物
                    {
                        vis[ni][nj][curs] = true;
                        q.push({ni,nj,curs});
                    }
                }
        	}
        	step++;
        }
        return -1;
    }
};

400 ms 41.1 MB

python3 解答

class Solution:
    def shortestPath(self, grid: List[List[int]], k: int) -> int:
        import queue
        dir = [[1,0],[0,1],[0,-1],[-1,0]]
        m, n = len(grid), len(grid[0])
        step = 0
        vis = [[[False]*(k+1) for _ in range(n)] for _ in range(m)]
        q = queue.Queue(m*n*(k+1))
        q.put([0,0,0])
        vis[0][0][0] = True
        while not q.empty():
            size = q.qsize()
            while size > 0:
                qt = q.get()
                i = qt[0]
                j = qt[1]
                curs = qt[2]
                if i==m-1 and j==n-1:
                    return step
                for d in range(4):
                    ni = i+dir[d][0]
                    nj = j+dir[d][1]
                    if ni<0 or ni>=m or nj<0 or nj>=n:
                        continue
                    if grid[ni][nj] and curs+1 <= k and not vis[ni][nj][curs+1]:
                        vis[ni][nj][curs+1] = True
                        q.put([ni,nj,curs+1])
                    elif not grid[ni][nj] and not vis[ni][nj][curs]:
                        vis[ni][nj][curs] = True
                        q.put([ni,nj,curs])
                size -= 1
            step += 1
        return -1

2200 ms 18.5 MB

标签：ni,nj,BFS,vector,grid,1293,LeetCode,dp,size
来源： https://blog.csdn.net/qq_21201267/article/details/106981377

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。