编程实现有向图的邻接矩阵储存

实现有向图的邻接矩阵储存，可以按照以下步骤进行：

1. 定义有向图的顶点数和边数，以及一个二维数组来表示邻接矩阵。

2. 初始化邻接矩阵，将所有元素都赋值为0。

3. 根据有向图的边，将邻接矩阵中对应的元素赋值为1。

下面是一个示例代码：

# 定义有向图的顶点数和边数
n = 5
m = 7

# 初始化邻接矩阵，将所有元素都赋值为0
matrix = [[0] * n for i in range(n)]

# 根据有向图的边，将邻接矩阵中对应的元素赋值为1
edges = [(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (3, 4), (4, 0)]
for i in range(m):
    x, y = edges[i]
    matrix[x][y] = 1

# 输出邻接矩阵
for i in range(n):
    for j in range(n):
        print(matrix[i][j], end=' ')
    print()

输出结果为：

0 1 1 0 0 
0 0 0 1 0 
0 0 0 1 1 
0 0 0 0 1 
1 0 0 0 0 

以上代码中，我们使用了一个二维数组 `matrix` 来表示有向图的邻接矩阵。其中，`matrix[i][j]` 表示从顶点 i 到顶点 j 是否存在一条有向边。如果存在，则为1，否则为0。我们通过定义边的方式来构造有向图，最后输出邻接矩阵。

相关问题

使用邻接矩阵来存储带权有向图G，并编程实现迪杰斯特拉算法。

好的，我来回答您的问题。

首先，邻接矩阵是一种表示图的数据结构，对于一个有 $n$ 个顶点的带权有向图 $G$，邻接矩阵 $M$ 是一个 $n \times n$ 的矩阵，其中 $M_{i,j}$ 表示从顶点 $i$ 到顶点 $j$ 的边的权值，如果不存在这样的边，则 $M_{i,j}$ 为无穷大。如果顶点 $i$ 和顶点 $j$ 之间没有边，则 $M_{i,j}$ 为 $0$。

接下来是迪杰斯特拉算法，它是一种单源最短路径算法，用于计算从一个源点到其他所有顶点的最短路径。算法的基本思想是，维护一个集合 $S$，其中包含已经找到最短路径的顶点，以及一个距离数组 $dist$，其中 $dist[i]$ 表示从源点到顶点 $i$ 的最短距离。初始时，将源点加入集合 $S$ 中，将 $dist$ 数组中除源点之外的所有元素设为无穷大。然后，从 $S$ 中找到一个离源点最近的顶点 $u$，将顶点 $u$ 加入 $S$ 中，并且更新所有与 $u$ 相邻的顶点的距离，如果新距离比原来的距离更小，则更新 $dist$ 数组。重复这个过程直到所有顶点都加入 $S$ 中。

下面是使用邻接矩阵来实现迪杰斯特拉算法的伪代码：

def dijkstra(graph, src):
    n = len(graph)
    visited = [False] * n
    dist = [float('inf')] * n
    dist[src] = 0
    
    for _ in range(n):
        # 找到距离源点最近的顶点
        u = -1
        for i in range(n):
            if not visited[i] and (u == -1 or dist[i] < dist[u]):
                u = i
        visited[u] = True
        
        # 更新与 u 相邻的顶点的距离
        for v in range(n):
            if graph[u][v] != 0 and not visited[v]:
                new_dist = dist[u] + graph[u][v]
                if new_dist < dist[v]:
                    dist[v] = new_dist
    
    return dist

其中，`graph` 是邻接矩阵，`src` 是源点的编号。算法的时间复杂度为 $O(n^2)$，可以通过使用堆来优化到 $O(n \log n)$。

希望这个回答对您有帮助！

用C语言实现使用邻接矩阵来存储带权有向图G，并编程实现迪杰斯特拉算法。

好的，这是一个比较复杂的问题，我来一步一步地解答。

首先，C语言中使用邻接矩阵来存储带权有向图G，可以定义一个二维数组来表示。数组的大小为n×n，其中n为图中节点的个数。如果节点i到节点j之间有一条权值为w的有向边，则邻接矩阵中第i行第j列的元素值为w；如果没有，则为一个特定的无穷大值，例如INT_MAX。

下面是一个示例代码，用于定义一个邻接矩阵：

#define MAX_SIZE 100
#define INT_MAX 2147483647

int graph[MAX_SIZE][MAX_SIZE];  // 邻接矩阵
int n;  // 节点个数

// 初始化邻接矩阵
void init_graph() {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) {
                graph[i][j] = 0;  // 节点到自身的距离为0
            } else {
                graph[i][j] = INT_MAX;  // 其他节点之间的距离为无穷大
            }
        }
    }
}

// 添加一条有向边
void add_edge(int u, int v, int w) {
    graph[u][v] = w;
}

接下来是关于迪杰斯特拉算法的实现。该算法用于解决从一个节点到其他节点的最短路径问题，其基本思想是通过不断更新起点到各个节点的距离，最终得到最短路径。

迪杰斯特拉算法的具体实现步骤如下：

1. 初始化距离数组dist和访问数组visited。dist[i]表示从起点到节点i的距离，visited[i]为true表示节点i已被访问过，反之为false。

2. 从起点开始，将起点的dist值设为0，并将其标记为已访问。

3. 遍历起点的所有邻居节点，更新它们的dist值。

4. 重复步骤3，直到所有节点都被访问过。

下面是一个示例代码，用于实现迪杰斯特拉算法：

#define INF 2147483647

// 计算起点到每个节点的最短距离
void dijkstra(int start) {
    int dist[MAX_SIZE];  // 起点到每个节点的最短距离
    bool visited[MAX_SIZE];  // 节点是否已被访问
    int i, j, k, min;

    // 初始化
    for (i = 0; i < n; i++) {
        dist[i] = graph[start][i];
        visited[i] = false;
    }
    dist[start] = 0;
    visited[start] = true;

    // 计算最短距离
    for (i = 1; i < n; i++) {
        min = INF;
        for (j = 0; j < n; j++) {
            if (!visited[j] && dist[j] < min) {
                k = j;
                min = dist[j];
            }
        }
        visited[k] = true;
        for (j = 0; j < n; j++) {
            if (!visited[j] && graph[k][j] < INF) {
                if (dist[k] + graph[k][j] < dist[j]) {
                    dist[j] = dist[k] + graph[k][j];
                }
            }
        }
    }

    // 输出结果
    for (i = 0; i < n; i++) {
        if (dist[i] == INF) {
            printf("起点到节点%d的距离为无穷大\n", i);
        } else {
            printf("起点到节点%d的最短距离为%d\n", i, dist[i]);
        }
    }
}

以上就是使用C语言实现邻接矩阵存储带权有向图并编程实现迪杰斯特拉算法的全部内容。