门 | GATE-CS-2014-(Set-2) | 问题2

这是一个关于门（gate）的算法问题。在这个问题中，你需要判断能否在一组给定的门中找到一个从起点到终点的路径。如果可以找到这样一条路径，那么你还需要计算这个路径的长度。

##问题描述

假设我们有n个门，每个门有三个属性：

• 开始位置
• 结束位置
• 长度

其中，每个位置都可以看做是一个二维坐标系中的点。你需要写一个函数，判断是否能从起点到达终点，如果可以，还需要找到最短的路径。

##输入格式

以下是函数的输入参数：

int n // 门的数量
int startx // 起点x坐标
int starty // 起点y坐标
int endx // 终点x坐标
int endy // 终点y坐标
vector<vector<int>> gates // 表示每个门的开始，结束和长度属性

其中，gates变量是一个大小为n x 3的二维向量，其中：

• gates[i][0]表示门的开始x坐标
• gates[i][1]表示门的开始y坐标
• gates[i][2]表示门的长度

##输出格式

• 如果能够找到一条从起点到终点的路径，返回最短路径的长度
• 如果找不到从起点到终点的路径，返回-1

##示例

###输入

int n = 3;
int startx = 0;
int starty = 0;
int endx = 5;
int endy = 5;
vector<vector<int>> gates = {
 {2, 2, 2},
 {4, 4, 1},
 {1, 1, 5}
};

###输出

12

##解题思路

这是一道经典的最短路径问题，可以使用Dijkstra或BFS解决。由于这个问题也需要输出距离，因此我们可以使用Dijkstra算法。具体步骤如下：

1. 初始化距离向量，起点的距离为0，其他点的距离为正无穷
2. 创建一个集合S，将起点放入其中
3. 创建一个set visited，用于记录已经被遍历过的节点
4. 当集合S非空时，执行以下操作：
   • 从S中取出一个节点u，并将其加入visited
   • 遍历节点u的所有邻居节点v，更新其距离和父节点（如果距离更小）
   • 如果节点v还未被遍历，将其加入集合S
5. 遍历完成后，最短路径的长度为终点的距离属性（如果被更新过），如果终点的距离属性为正无穷则表示无法到达终点。

需要注意的是，此题中每个门实际上会占用一定范围内的点，因此我们可以将每个门看做多个节点，并将它们之间的距离设置为门的长度。如下面的示例：

在这个例子中，门1占用了(2,2)、(2,3)、(2,4)、(2,5)四个点。我们可以将这四个点看做四个节点，它们之间的距离均为2（即门的长度）。这样，问题就转化为求节点之间的最短路径。

##参考代码

以下是使用Dijkstra算法求解的参考代码。时间复杂度为O(n^2)。

int shortestPath(int n, int startx, int starty, int endx, int endy, vector<vector<int>>& gates) {
    // 构建节点
    vector<pair<int, int>> nodes;
    for (auto gate : gates) {
        int startx = gate[0];
        int starty = gate[1];
        int length = gate[2];
        for (int i = startx; i < startx + length; i++) {
            nodes.emplace_back(i, starty);
        }
        for (int i = starty + 1; i <= starty + length; i++) {
            nodes.emplace_back(startx + length, i);
        }
    }
    nodes.emplace_back(startx, starty);
    nodes.emplace_back(endx, endy);

    // 构建距离矩阵和visited set
    vector<int> distances(nodes.size(), INT_MAX);
    unordered_set<unsigned long long> visited;
    distances[nodes.size() - 2] = 0;

    // Dijkstra算法
    while (visited.size() < nodes.size()) {
        int curr = -1, min_distance = INT_MAX;
        for (int i = 0; i < nodes.size(); i++) {
            if (!visited.count(i) && distances[i] < min_distance) {
                curr = i;
                min_distance = distances[i];
            }
        }
        if (curr == -1) break;
        visited.insert(curr);

        for (int i = 0; i < nodes.size(); i++) {
            if (!visited.count(i)) {
                int distance = abs(nodes[curr].first - nodes[i].first) + abs(nodes[curr].second - nodes[i].second);
                if (distance <= 1) { // 如果两个节点在同一个门内，则它们之间没有边
                    continue;
                }
                distance -= 1; // 节点之间的距离为门的长度-1
                int new_distance = distances[curr] + distance;
                if (new_distance < distances[i]) {
                    distances[i] = new_distance;
                }
            }
        }
    }

    return distances.back() == INT_MAX ? -1 : distances.back();
}

代码中将每个门拆分成多个节点，并将这些节点和起点、终点一起放入一个节点向量中。之后使用Dijkstra算法求解最短路径。可以注意到，节点之间的距离为门的长度-1，因为两个节点之间的距离实际上是这个门的长度-1。