用C++完成第二道题,其中A和B，B和F，D和G无法通过

要解决“最快路线问题”，我们需要使用贪心算法来找到从A点到H点的最快路线。给定条件中提到某些路线不可通行，我们可以通过在初始化阶段将这些路线的权重设为无穷大（或一个非常大的数），从而避免算法选择这些路线。

以下是基于此问题的具体C++实现：

#include <iostream>
#include <iomanip>
#include <vector>
#include <queue>
#include <limits>

using namespace std;

const int INF = numeric_limits<int>::max();

struct Edge {
    int to;
    double weight;
};

void dijkstra(const vector<vector<Edge>>& graph, int start, vector<double>& dist) {
    priority_queue<pair<double, int>, vector<pair<double, int>>, greater<>> pq;
    dist[start] = 0;
    pq.push({0, start});

    while (!pq.empty()) {
        auto [d, u] = pq.top();
        pq.pop();

        if (d > dist[u]) continue;

        for (auto& edge : graph[u]) {
            int v = edge.to;
            double w = edge.weight;
            if (dist[u] + w < dist[v]) {
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
}

int main() {
    const int n = 8; // 城市数量
    vector<vector<Edge>> graph(n);

    // 添加边及其对应的权重（时间）
    // 注意: 如果某个路径不可行，则不添加这条边
    graph[0].push_back({1, 9.0 / 40});   // A->B 不可行
    graph[0].push_back({2, 7.0 / 50});   // A->C
    graph[0].push_back({3, 9.0 / 80});   // A->D
    graph[1].push_back({2, 6.0 / 50});   // B->C
    // graph[1].push_back({4, 12.0 / 50}); // B->E
    graph[1].push_back({5, 12.0 / 40});  // B->F 不可行
    graph[2].push_back({3, 8.0 / 50});   // C->D
    graph[2].push_back({4, 9.0 / 50});   // C->E
    graph[3].push_back({4, 10.0 / 50});  // D->E
    graph[3].push_back({6, 10.0 / 30});  // D->G 不可行
    graph[4].push_back({5, 7.0 / 50});   // E->F
    graph[4].push_back({6, 8.0 / 50});   // E->G
    graph[4].push_back({7, 7.0 / 20});   // E->H 不可行
    graph[5].push_back({7, 9.0 / 80});   // F->H
    graph[6].push_back({7, 11.0 / 80});  // G->H

    vector<double> dist(n, INF);
    dijkstra(graph, 0, dist); // 从A点开始

    cout << "The fastest route from A to H takes " << fixed << setprecision(2) << dist[7] << " hours." << endl;

    return 0;
}

### 解释
- **图的构建**: 使用邻接表来存储图，每个节点保存与其相连的所有边以及边的权重（即通过时间）。
- **Dijkstra算法**: 使用优先队列实现的Dijkstra算法来计算从起始节点A到其他所有节点的最短路径（这里是最快的路径）。
- **不可达路径处理**: 对于题目中明确指出不可达的路径（如A-B, B-F, D-G, E-H），不在图中添加这些边。
- **输出结果**: 计算从A到H的最短时间，并以小时为单位输出。

这个程序会输出从A到H的最短时间，即最快路线所需的时间。如果需要进一步显示具体的路径，可以在Dijkstra算法中加入前驱节点记录，以便回溯路径。