请根据乡镇A,B,…,R的邻接矩阵来求O->H的最短路径及最短路长

抱歉，我是一个语言模型，无法直接处理您提供的问题。不过，根据您所提供的信息，这是一个图论问题，需要使用最短路径算法来求解。常见的最短路径算法有Dijkstra算法、Bellman-Ford算法、Floyd算法等。您可以根据具体情况选择适合的算法来解决问题。如果您有具体的问题需要帮助，可以提供更详细的信息，我会尽力提供帮助。

相关问题

求邻接矩阵指定两点位置间的最短路径C语言代码，并给出代码解释

以下是求邻接矩阵指定两点位置间的最短路径的 C 语言代码，基于 Dijkstra 算法：

#include <stdio.h>
#include <stdbool.h>

#define MAX_NODES 100
#define INF 99999

int graph[MAX_NODES][MAX_NODES]; // 邻接矩阵
int dist[MAX_NODES]; // 记录起点到各点的最短距离
bool visited[MAX_NODES]; // 记录各点是否已被访问

// 求起点到终点的最短路径
int dijkstra(int start, int end, int num_nodes) {
    // 初始化
    for (int i = 0; i < num_nodes; i++) {
        dist[i] = INF;
        visited[i] = false;
    }
    dist[start] = 0;

    // 循环 n-1 次
    for (int i = 0; i < num_nodes - 1; i++) {
        int u = -1;
        // 找到未访问过的距离起点最近的点
        for (int j = 0; j < num_nodes; j++) {
            if (!visited[j] && (u == -1 || dist[j] < dist[u])) {
                u = j;
            }
        }
        visited[u] = true;
        // 更新 u 的邻居的最短距离
        for (int v = 0; v < num_nodes; v++) {
            if (graph[u][v] != 0) {
                int new_dist = dist[u] + graph[u][v];
                if (new_dist < dist[v]) {
                    dist[v] = new_dist;
                }
            }
        }
    }

    // 返回起点到终点的最短距离
    return dist[end];
}

int main() {
    int num_nodes, num_edges, start, end;
    // 输入节点数、边数、起点、终点
    scanf("%d %d %d %d", &num_nodes, &num_edges, &start, &end);
    // 初始化邻接矩阵
    for (int i = 0; i < num_nodes; i++) {
        for (int j = 0; j < num_nodes; j++) {
            graph[i][j] = 0;
        }
    }
    // 输入边的信息
    for (int i = 0; i < num_edges; i++) {
        int u, v, w;
        scanf("%d %d %d", &u, &v, &w);
        graph[u][v] = w;
    }
    // 求起点到终点的最短路径
    int shortest_dist = dijkstra(start, end, num_nodes);
    // 输出最短距离
    printf("%d\n", shortest_dist);

    return 0;
}

代码解释：

首先定义了邻接矩阵 `graph`、记录起点到各点的最短距离的数组 `dist` 和记录各点是否已被访问的数组 `visited`。

`dijkstra` 函数实现了 Dijkstra 算法，接受起点、终点和节点数作为参数，返回起点到终点的最短距离。在函数中，首先进行初始化，将起点的最短距离设为 0，其他节点的最短距离设为无穷大。然后循环 n-1 次，每次找到未访问过的距离起点最近的点 u，将 u 标记为已访问，然后更新 u 的邻居的最短距离。最后返回起点到终点的最短距离。

`main` 函数中输入节点数、边数、起点和终点，然后初始化邻接矩阵，输入边的信息，调用 `dijkstra` 函数求起点到终点的最短路径，并输出最短距离。

邻接矩阵求最短路径c++

邻接矩阵求最短路径可以使用 Dijkstra 算法来实现，具体的 C++ 代码如下：

#include <iostream>
#include <vector>
#include <queue>
#include <limits.h>

using namespace std;

const int MAXN = 100;
const int INF = INT_MAX;

int n; // 节点数
int m; // 边数
int s; // 起点
int t; // 终点

int g[MAXN][MAXN]; // 邻接矩阵表示图
int dis[MAXN]; // 起点到各个点的最短距离
bool vis[MAXN]; // 记录每个点是否已经确定最短距离

void dijkstra() {
    // 初始化
    for (int i = 1; i <= n; i++) {
        dis[i] = g[s][i];
        vis[i] = false;
    }
    dis[s] = 0;
    vis[s] = true;

    // 每次确定一个点的最短距离
    for (int i = 1; i <= n; i++) {
        int minDis = INF;
        int minIndex = -1;
        for (int j = 1; j <= n; j++) {
            if (!vis[j] && dis[j] < minDis) {
                minDis = dis[j];
                minIndex = j;
            }
        }
        if (minIndex == -1) break;
        vis[minIndex] = true;

        // 更新其他点的距离
        for (int j = 1; j <= n; j++) {
            if (!vis[j] && g[minIndex][j] != INF) {
                dis[j] = min(dis[j], dis[minIndex] + g[minIndex][j]);
            }
        }
    }
}

int main() {
    cin >> n >> m >> s >> t;

    // 初始化邻接矩阵
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            g[i][j] = INF;
        }
    }
    for (int i = 1; i <= m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        g[u][v] = g[v][u] = w;
    }

    dijkstra();

    cout << dis[t] << endl;

    return 0;
}

其中，邻接矩阵 `g` 的初始化值为 `INF`，表示两个节点之间没有边相连。在输入边时，需要将两个节点之间的距离存储在邻接矩阵中。`dijkstra` 函数中，首先初始化起点到各个点的距离，然后每次选择一个未确定最短距离的点，更新其他点的距离，直到所有点的最短距离都被确定。最终，起点到终点的最短距离存储在 `dis[t]` 中。