A和B，B和F，D和G无法通行

根据提供的信息，如果A和B，B和F，D和G之间的道路无法通行，那么在计算“最快路线问题”的时候需要对这些不可通行的道路进行特殊处理。具体做法是在初始化 `journey` 和 `speed` 数组时，将这些道路的权重设为无穷大（或一个非常大的数），以表明它们不能被使用。以下是调整后的部分代码：

// 初始化距离数组
float journey[8][8] = {
    {0, INT_MAX, 7, 9, INT_MAX, INT_MAX, INT_MAX, INT_MAX}, // A
    {INT_MAX, 0, 6, INT_MAX, 12, 12, INT_MAX, INT_MAX},     // B
    {7, 6, 0, 8, 9, INT_MAX, INT_MAX, INT_MAX},             // C
    {9, INT_MAX, 8, 0, 10, INT_MAX, 10, INT_MAX},           // D
    {INT_MAX, 12, 9, 10, 0, 7, 8, 7},                       // E
    {INT_MAX, 12, INT_MAX, INT_MAX, 7, 0, INT_MAX, 9},      // F
    {INT_MAX, INT_MAX, INT_MAX, 10, 8, INT_MAX, 0, 11},     // G
    {INT_MAX, INT_MAX, INT_MAX, INT_MAX, 7, 9, 11, 0}       // H
};

// 初始化速度数组
float speed[8][8] = {
    {0, 0, 50, 80, 0, 0, 0, 0}, // A
    {0, 0, 50, 0, 50, 50, 0, 0}, // B
    {50, 50, 0, 50, 50, 0, 0, 0}, // C
    {80, 0, 50, 0, 50, 0, 80, 0}, // D
    {0, 50, 50, 50, 0, 50, 50, 50}, // E
    {0, 50, 0, 0, 50, 0, 0, 80}, // F
    {0, 0, 0, 80, 50, 0, 0, 80}, // G
    {0, 0, 0, 0, 50, 80, 80, 0} // H
};

// 补充拥堵路段的速度
speed[0][1] = 0; // A-B 不通
speed[3][6] = 30; // D-G 拥堵
speed[4][7] = 20; // E-H 拥堵
speed[1][5] = 0; // B-F 不通

// 将双向距离和速度设置成一样
for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
        if (journey[i][j] < INT_MAX) {
            journey[j][i] = journey[i][j];
        }
        if (speed[i][j] > 0) {
            speed[j][i] = speed[i][j];
        }
    }
}

这样，在后续的算法执行过程中，这些不可通行的道路将不会被考虑。接下来，您可以继续使用 Dijkstra 或其他合适的算法来找到从 A 到 H 的最快路线。