实现图的邻接矩阵的存储 编写程序，输入顶点的个数、边的个数、每个顶点的值、 每一条边及其权值,建立带权无向图 G 的邻接矩阵，并输出其邻接矩阵。 输入格式： 第一行两个整数分别表示图的顶点个数 m、边的个数 n，两个整数之间以空格分隔； 第二行的字符序列分别表示图的 m 个顶点的数据(为简单，每个顶点的数据为一个字符)； n 行数据，每行数据表示图的一条边的信息，每条边依附的两个顶点的值以及这条边的权 值。

好的，下面是实现图的邻接矩阵存储的 Python 代码：

m, n = map(int, input().split())  # 输入顶点个数和边的个数
vertices = input().split()  # 输入每个顶点的值

# 初始化邻接矩阵，全部赋值为无穷大
adj_matrix = [[float('inf')] * m for _ in range(m)]

# 读入每条边的信息，构建邻接矩阵
for _ in range(n):
    v1, v2, weight = input().split()
    i = vertices.index(v1)
    j = vertices.index(v2)
    adj_matrix[i][j] = adj_matrix[j][i] = int(weight)

# 输出邻接矩阵
for row in adj_matrix:
    print(' '.join(map(str, row)))

输入样例：

5 7
A B C D E
A B 2
A C 1
B C 3
B D 10
C D 4
C E 5
D E 6

输出样例：

0 2 1 inf inf
2 0 3 10 inf
1 3 0 4 5
inf 10 4 0 6
inf inf 5 6 0

相关问题

c语言实现图的邻接矩阵的存储 编写程序，输入顶点的个数、边的个数、每个顶点的值、 每一条边及其权值,建立带权无向图 G 的邻接矩阵，并输出其邻接矩阵。每个顶点的数据为一个字符

好的，下面是 C 语言实现图的邻接矩阵存储并输出的程序：

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

#define MAX_VERTEX_NUM 100 // 最大顶点数

// 定义图的邻接矩阵结构体
typedef struct {
    char vertex[MAX_VERTEX_NUM]; // 存储顶点数据
    int arc[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 存储边的权值
    int vertex_num; // 顶点个数
    int edge_num; // 边的个数
} Graph;

// 创建图的邻接矩阵
void createGraph(Graph* G) {
    printf("请输入顶点个数和边的个数：\n");
    scanf("%d%d", &G->vertex_num, &G->edge_num);
    getchar(); // 去掉缓冲区中的换行符

    printf("请输入每个顶点的值：\n");
    for (int i = 0; i < G->vertex_num; i++) {
        scanf("%c", &G->vertex[i]);
        getchar(); // 去掉缓冲区中的换行符
    }

    // 初始化邻接矩阵
    for (int i = 0; i < G->vertex_num; i++) {
        for (int j = 0; j < G->vertex_num; j++) {
            G->arc[i][j] = 0;
        }
    }

    // 输入每一条边及其权值
    printf("请输入每一条边及其权值：\n");
    for (int i = 0; i < G->edge_num; i++) {
        char v1, v2;
        int weight;
        printf("请输入第%d条边的两个顶点和权值：\n", i + 1);
        scanf("%c%c%d", &v1, &v2, &weight);
        getchar(); // 去掉缓冲区中的换行符

        int index1, index2;
        // 查找顶点 v1 和 v2 在顶点数组中的下标
        for (int j = 0; j < G->vertex_num; j++) {
            if (G->vertex[j] == v1) {
                index1 = j;
            }
            if (G->vertex[j] == v2) {
                index2 = j;
            }
        }

        // 将边的权值存入邻接矩阵中
        G->arc[index1][index2] = weight;
        G->arc[index2][index1] = weight;
    }
}

// 输出图的邻接矩阵
void printGraph(Graph G) {
    printf("图的邻接矩阵为：\n");
    for (int i = 0; i < G.vertex_num; i++) {
        for (int j = 0; j < G.vertex_num; j++) {
            printf("%d ", G.arc[i][j]);
        }
        printf("\n");
    }
}

int main() {
    Graph G;
    createGraph(&G);
    printGraph(G);
    return 0;
}

希望能对你有所帮助！

实现图的邻接矩阵的存储 编写程序，输入顶点的个数、边的个数、每个顶点的值、 每一条边及其权值,建立带权无向图 G 的邻接矩阵，并输出其邻接矩阵。 输入格式： 第一行两个整数分别表示图的顶点个数 m、边的个数 n，两个整数之间以空格分隔； 第二行的字符序列分别表示图的 m 个顶点的数据(为简单，每个顶点的数据为一个字符)； n 行数据，每行数据表示图的一条边的信息，每条边依附的两个顶点的值以及这条边的权 值。c语言实现

好的，下面是实现图的邻接矩阵存储的 C 语言代码：

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

#define MAX_VERTICES  100 // 顶点数的最大值
#define INF 2147483647  // 无穷大

int adj_matrix[MAX_VERTICES][MAX_VERTICES]; // 邻接矩阵

int main()
{
    int m, n, i, j, k, weight;
    char vertices[MAX_VERTICES]; // 存储顶点的值
    char v1, v2;

    scanf("%d%d", &m, &n); // 输入顶点数和边数

    // 初始化邻接矩阵
    for (i = 0; i < m; i++) {
        for (j = 0; j < m; j++) {
            adj_matrix[i][j] = INF;
        }
        adj_matrix[i][i] = 0;
    }

    // 输入顶点的值
    scanf("%s", vertices);

    // 输入每条边的信息，构建邻接矩阵
    for (k = 0; k < n; k++) {
        scanf(" %c %c %d", &v1, &v2, &weight);
        i = strchr(vertices, v1) - vertices;
        j = strchr(vertices, v2) - vertices;
        adj_matrix[i][j] = adj_matrix[j][i] = weight;
    }

    // 输出邻接矩阵
    for (i = 0; i < m; i++) {
        for (j = 0; j < m; j++) {
            printf("%d ", adj_matrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

输入样例：

5 7
ABCDE
A B 2
A C 1
B C 3
B D 10
C D 4
C E 5
D E 6

输出样例：

0 2 1 2147483647 2147483647
2 0 3 10 2147483647
1 3 0 4 5
2147483647 10 4 0 6
2147483647 2147483647 5 6 0