求邻接矩阵通路或回路长度计算C语言

邻接矩阵通路或回路长度计算的C语言代码如下：

#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTEX_NUM 100   // 最大顶点数
#define INF 999999          // 无穷大

typedef struct {
    int vertex[MAX_VERTEX_NUM]; // 存储顶点信息
    int edge[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 存储边的权值，若为0则表示无边相连
    int vertex_num, edge_num; // 顶点数和边数
} Graph;

// 初始化图
void init_graph(Graph *G) {
    int i, j;
    G->vertex_num = G->edge_num = 0;
    for (i = 0; i < MAX_VERTEX_NUM; ++i) {
        G->vertex[i] = 0;
        for (j = 0; j < MAX_VERTEX_NUM; ++j) {
            G->edge[i][j] = INF;
        }
    }
}

// 添加顶点
void add_vertex(Graph *G, int v) {
    if (G->vertex_num >= MAX_VERTEX_NUM) {
        printf("超过最大顶点数限制！\n");
        return;
    }
    G->vertex[G->vertex_num++] = v;
}

// 添加边
void add_edge(Graph *G, int v1, int v2, int weight) {
    if (v1 >= G->vertex_num || v2 >= G->vertex_num) {
        printf("顶点编号超出范围！\n");
        return;
    }
    G->edge[v1][v2] = weight;
    G->edge_num++;
}

// Floyd算法计算任意两点之间的最短路径
void floyd(Graph *G, int dist[][MAX_VERTEX_NUM]) {
    int i, j, k;
    for (i = 0; i < G->vertex_num; ++i) {
        for (j = 0; j < G->vertex_num; ++j) {
            dist[i][j] = G->edge[i][j];
        }
    }
    for (k = 0; k < G->vertex_num; ++k) {
        for (i = 0; i < G->vertex_num; ++i) {
            for (j = 0; j < G->vertex_num; ++j) {
                if (dist[i][j] > dist[i][k] + dist[k][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }
}

int main() {
    Graph G;
    int dist[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
    int i, j, length;

    init_graph(&G);

    // 添加顶点
    for (i = 0; i < 5; ++i) {
        add_vertex(&G, i);
    }

    // 添加边
    add_edge(&G, 0, 1, 1);
    add_edge(&G, 0, 2, 3);
    add_edge(&G, 1, 2, 1);
    add_edge(&G, 1, 3, 5);
    add_edge(&G, 2, 3, 2);
    add_edge(&G, 2, 4, 1);
    add_edge(&G, 3, 4, 4);

    // 计算任意两点之间的最短路径
    floyd(&G, dist);

    // 输出邻接矩阵
    printf("邻接矩阵：\n");
    for (i = 0; i < G.vertex_num; ++i) {
        for (j = 0; j < G.vertex_num; ++j) {
            if (G.edge[i][j] == INF) {
                printf("∞ ");
            } else {
                printf("%d ", G.edge[i][j]);
            }
        }
        printf("\n");
    }

    // 计算0号顶点到4号顶点的路径长度
    length = dist[0][4];
    printf("0号顶点到4号顶点的路径长度为：%d\n", length);

    return 0;
}

这段代码实现了一个简单的图结构，并使用Floyd算法计算任意两点之间的最短路径。其中，邻接矩阵存储在`G.edge`数组中，使用`INF`表示两个顶点之间没有直接边相连。`floyd()`函数接收一个二维数组`dist`，用于存储计算出来的任意两点之间的最短路径长度。最后，我们计算0号顶点到4号顶点的路径长度并输出。