C ++程序用于矩阵或网格中两个单元格之间的最短距离

给定一个 N*M 阶的矩阵。查找从源单元格到目标单元格的最短距离，仅遍历有限的单元格。您也只能向上、向下、向左和向右移动。如果找到输出距离，否则为-1。
s 代表'来源'
d 代表“目的地”
* 代表您可以旅行的单元格
0 代表你不能旅行的单元格
此问题适用于单一来源和目的地。
例子：

Input : {'0', '*', '0', 's'},
        {'*', '0', '*', '*'},
        {'0', '*', '*', '*'},
        {'d', '*', '*', '*'}
Output : 6

Input :  {'0', '*', '0', 's'},
         {'*', '0', '*', '*'},
         {'0', '*', '*', '*'},
         {'d', '0', '0', '0'}
Output :  -1

这个想法是对矩阵单元进行 BFS（广度优先搜索）。请注意，如果图未加权，我们总是可以使用 BFS 来找到最短路径。

1. 将每个单元格存储为一个节点，其中包含它们的行、列值和与源单元格的距离。
2. 使用源单元启动 BFS。
3. 制作一个已访问的数组，其中除了“0”单元格之外的所有单元格都具有“假”值，这些单元格被分配了“真”值，因为它们不能被遍历。
4. 在每次移动中不断更新与源值的距离。
5. 到达目的地时返回距离，否则返回-1（源和目的地之间不存在路径）。

CPP

// C++ Code implementation for above problem
#include 
using namespace std;
  
#define N 4
#define M 4
  
// QItem for current location and distance
// from source location
class QItem {
public:
    int row;
    int col;
    int dist;
    QItem(int x, int y, int w)
        : row(x), col(y), dist(w)
    {
    }
};
  
int minDistance(char grid[N][M])
{
    QItem source(0, 0, 0);
  
    // To keep track of visited QItems. Marking
    // blocked cells as visited.
    bool visited[N][M];
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++)
        {
            if (grid[i][j] == '0')
                visited[i][j] = true;
            else
                visited[i][j] = false;
  
            // Finding source
            if (grid[i][j] == 's')
            {
               source.row = i;
               source.col = j;
            }
        }
    }
  
    // applying BFS on matrix cells starting from source
    queue q;
    q.push(source);
    visited[source.row][source.col] = true;
    while (!q.empty()) {
        QItem p = q.front();
        q.pop();
  
        // Destination found;
        if (grid[p.row][p.col] == 'd')
            return p.dist;
  
        // moving up
        if (p.row - 1 >= 0 &&
            visited[p.row - 1][p.col] == false) {
            q.push(QItem(p.row - 1, p.col, p.dist + 1));
            visited[p.row - 1][p.col] = true;
        }
  
        // moving down
        if (p.row + 1 < N &&
            visited[p.row + 1][p.col] == false) {
            q.push(QItem(p.row + 1, p.col, p.dist + 1));
            visited[p.row + 1][p.col] = true;
        }
  
        // moving left
        if (p.col - 1 >= 0 &&
            visited[p.row][p.col - 1] == false) {
            q.push(QItem(p.row, p.col - 1, p.dist + 1));
            visited[p.row][p.col - 1] = true;
        }
  
         // moving right
        if (p.col + 1 < M &&
            visited[p.row][p.col + 1] == false) {
            q.push(QItem(p.row, p.col + 1, p.dist + 1));
            visited[p.row][p.col + 1] = true;
        }
    }
    return -1;
}
  
// Driver code
int main()
{
    char grid[N][M] = { { '0', '*', '0', 's' },
                        { '*', '0', '*', '*' },
                        { '0', '*', '*', '*' },
                        { 'd', '*', '*', '*' } };
  
    cout << minDistance(grid);
    return 0;
}

输出：

6

有关更多详细信息，请参阅有关矩阵或网格中两个单元格之间的最短距离的完整文章！