编写程序实现带权有向图图的邻接矩阵存储，输出邻接矩阵。输入第一行为结点个数(节点编号从0开始)，第二行开始为边的信息(节点编号，节点编号，权重)，输出邻接矩阵。C实现

以下是C语言实现的代码：

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

#define MAX_NODE_NUM 100 // 最大节点数

int main() {
    int n; // 节点个数
    int adj_mat[MAX_NODE_NUM][MAX_NODE_NUM] = {0}; // 邻接矩阵
    scanf("%d", &n); // 输入节点个数
    int i, j, k, w;
    while (scanf("%d %d %d", &i, &j, &w) == 3) { // 输入边信息
        adj_mat[i][j] = w; // 存储有向边权值
    }
    printf("邻接矩阵：\n");
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            printf("%d ", adj_mat[i][j]); // 输出邻接矩阵
        }
        printf("\n");
    }
    return 0;
}

输入示例：

4
0 1 2
1 2 3
2 3 1
0 3 4

输出示例：

邻接矩阵：
0 2 0 4 
0 0 3 0 
0 0 0 1 
0 0 0 0 

相关问题

python 实现将带权图图的领接矩阵转换成邻接表，和将邻接表转换成邻接矩阵

将带权图的领接矩阵转换成邻接表可以按照如下步骤进行：

1. 遍历领接矩阵，找到每个非零元素；
2. 对于每个非零元素，将其所在的行表示的节点与列表示的节点之间添加一条边；
3. 如果图是有向图，则只需将该边添加到起点的邻接表中；
4. 如果图是无向图，则需要将该边同时添加到起点和终点的邻接表中。

Python 代码实现如下：

def matrix_to_list(matrix):
    n = len(matrix)
    graph = {}
    for i in range(n):
        for j in range(n):
            if matrix[i][j] != 0:
                if i not in graph:
                    graph[i] = []
                graph[i].append((j, matrix[i][j]))
    return graph

将邻接表转换成邻接矩阵可以按照如下步骤进行：

1. 遍历邻接表，找到每个节点以及其邻居节点；
2. 对于每个节点及其邻居节点，将其在邻接矩阵中对应位置的值置为其边权值；
3. 注意区分有向图和无向图，无向图需要将对称的两个位置的值都置为边权值。

Python 代码实现如下：

def list_to_matrix(graph, directed=False):
    n = len(graph)
    matrix = [[0] * n for _ in range(n)]
    for node in graph:
        for neighbor, weight in graph[node]:
            matrix[node][neighbor] = weight
            if not directed:
                matrix[neighbor][node] = weight
    return matrix

注意，这里的邻接表使用字典来存储，字典的键表示节点，值为一个列表，其中每个元素是一个二元组，表示该节点与其邻居节点之间的边权值。

编程实现有向图图的邻接表存储，并计算给定结点的入度和初度。

好的，以下是 Python 代码实现：

class Graph:
    def __init__(self, nodes):
        self.nodes = nodes
        self.adj_list = {node: [] for node in nodes}

    def add_edge(self, u, v):
        self.adj_list[u].append(v)

    def indegree(self, node):
        indeg = 0
        for u in self.adj_list:
            if node in self.adj_list[u]:
                indeg += 1
        return indeg

    def outdegree(self, node):
        return len(self.adj_list[node])

其中，`Graph` 类中的 `__init__` 方法用于初始化有向图，`add_edge` 方法用于添加边，`indegree` 和 `outdegree` 方法分别用于计算给定结点的入度和出度。

例如，我们可以这样使用代码：

nodes = ['A', 'B', 'C', 'D', 'E']
edges = [('A', 'B'), ('B', 'C'), ('C', 'D'), ('D', 'A'), ('D', 'E')]

g = Graph(nodes)
for u, v in edges:
    g.add_edge(u, v)

print(g.indegree('A'))  # 输出 1
print(g.outdegree('D'))  # 输出 2

这里我们定义了一个包含 5 个结点和 5 条边的有向图，并计算了结点 'A' 的入度和结点 'D' 的出度。