Điều này chuyển đổi "danh sách kề" của bạn [thực sự là một dict, không phải danh sách] thành một ma trận chính hãng:
import networkx as nx
graph = {'1': [{'2':'15'}, {'4':'7'}, {'5':'10'}],
'2': [{'3':'9'}, {'4':'11'}, {'6':'9'}],
'3': [{'5':'12'}, {'6':'7'}],
'4': [{'5':'8'}, {'6':'14'}],
'5': [{'6':'8'}]}
new_graph = nx.Graph[]
for source, targets in graph.iteritems[]:
for inner_dict in targets:
assert len[inner_dict] == 1
new_graph.add_edge[int[source] - 1, int[inner_dict.keys[][0]] - 1,
weight=inner_dict.values[][0]]
adjacency_matrix = nx.adjacency_matrix[new_graph]
. Cũng lưu ý rằng tôi đã thay đổi biểu đồ của bạn để sử dụng các chỉ số Python [tức là, bắt đầu từ 0].
In [21]: adjacency_matrix
Out[21]:
matrix[[[ 0., 15., 0., 7., 10., 0.],
[ 15., 0., 9., 11., 0., 9.],
[ 0., 9., 0., 0., 12., 7.],
[ 7., 11., 0., 0., 8., 14.],
[ 10., 0., 12., 8., 0., 8.],
[ 0., 9., 7., 14., 8., 0.]]]
CHÀO MỌI NGƯỜI!!
Như chúng ta đều biết rằng đồ thị là một loại cấu trúc dữ liệu về cơ bản được sử dụng để kết nối các yếu tố khác nhau thông qua mạng.Graph is as a kind of data structure that is basically used to connect various elements through a network.
Trong bài viết này, bạn sẽ tìm hiểu về cách tạo biểu đồ bằng ma trận liền kề trong Python. Bắt đầu nào!!
1⃣ đồ thị:
Biểu đồ là cấu trúc dữ liệu phi tuyến tính bao gồm các nút và cạnh. Các nút đôi khi cũng được gọi là các đỉnh và các cạnh là các đường hoặc cung kết nối bất kỳ hai nút nào trong biểu đồ.
Một biểu đồ bao gồm một tập hợp các đỉnh [hoặc nút] hữu hạn và tập hợp các cạnh kết nối một cặp nút.
Hình trên biểu thị biểu đồ có các đỉnh và cạnh. Nhưng câu hỏi bắt giữ:
Làm thế nào bạn sẽ đại diện cho biểu đồ trong mã của bạn ??
Để trả lời câu hỏi trên ma trận phụ thuộc vào hình ảnh!
Họ cho chúng tôi một cách để thể hiện biểu đồ của chúng tôi theo một quy trình rất hiệu quả và có cấu trúc. Bằng cách tạo một ma trận [một bảng có hàng và cột], bạn có thể biểu diễn các nút và cạnh rất dễ dàng.represent our graph following a very efficient and structured procedure. By creating a matrix [a table with rows and columns], you can represent nodes and edges very easily.
Hãy để xem cách bạn có thể tạo một ma trận kề cho biểu đồ đã cho
Đồ thị có trọng sốHãy để tạo ra một ma trận kề:
1⃣ Đầu tiên, tạo một ma trận trống như hình dưới đây:
Ma trận trống2⃣ Bây giờ, hãy nhìn vào biểu đồ và nhìn chằm chằm điền vào ma trận từ nút A:
Vì không có cạnh nào đi từ A đến A, do đó điền 0 trong khối.
A → a, giá trị sẽ là 0
A → B, giá trị sẽ là 2
A → c, giá trị sẽ là 0
A → D, giá trị sẽ là 1
A → E, giá trị sẽ là 0,
Lặp lại quá trình tương tự cho các đỉnh khác.
3⃣ Thay thế tất cả các giá trị 0 bằng null. Sau khi điền hoàn toàn các khối, ma trận sẽ trông giống như sau:
🏆 Cuối cùng! - Ma trận của chúng tôi đã sẵn sàng!
💻let Mã!Let’s Code!
Dưới đây là một ví dụ về biểu đồ có trọng số được biểu thị bằng một ma trận kề 👇
Thêm các đỉnh và cạnhMã để in biểu đồ:
Hãy để xem cách mã này hoạt động đằng sau hậu trường:
1⃣ Thêm các đỉnh:
Với phần mã này, bạn có thể thêm các đỉnh vào ma trận của mình.
Nếu đỉnh mà bạn đang thêm đã có mặt, thì hãy in ra đã tồn tại khác, hãy nối các đỉnh vào biểu đồ.
2⃣ Thêm các cạnh:
Để thêm cạnh giữa 2 đỉnh, trước tiên hãy kiểm tra xem các đỉnh có hợp lệ và tồn tại trong biểu đồ hay không.
Sau này, vì mã này không bị giới hạn trong biểu đồ được định hướng và không mong muốn, vì vậy bạn có thể thêm cạnh vào cả các đỉnh V1 và V2.
3⃣ Bây giờ in biểu đồ để có được đầu ra sau:
Đầu ra cuối cùngBằng cách này, bạn có thể tạo biểu đồ trong Python bằng ma trận liền kề.👍
Cảm ơn bạn !! 😊
Trong hướng dẫn này, bạn sẽ tìm hiểu một ma trận kề là gì. Ngoài ra, bạn sẽ tìm thấy các ví dụ làm việc về ma trận kề trong C, C ++, Java và Python.
Một ma trận kề là một cách thể hiện biểu đồ dưới dạng ma trận của Booleans [0 và 1]. Một biểu đồ hữu hạn có thể được biểu diễn dưới dạng ma trận vuông trên máy tính, trong đó giá trị boolean của ma trận cho biết nếu có đường dẫn trực tiếp giữa hai đỉnh.
Ma trận liền kề với ví dụ là gì?
Trong hướng dẫn này, bạn sẽ tìm hiểu một ma trận kề là gì. Ngoài ra, bạn sẽ tìm thấy các ví dụ làm việc về ma trận kề trong C, C ++, Java và Python.
Một biểu đồ không mong muốn
Chúng ta có thể biểu thị biểu đồ này trong mẫu ma trận như dưới đây.
Biểu diễn ma trận của đồ thị
Mỗi ô trong bảng/ma trận trên được biểu thị là Aij, trong đó ____10 và In [21]: adjacency_matrix
Out[21]:
matrix[[[ 0., 15., 0., 7., 10., 0.],
[ 15., 0., 9., 11., 0., 9.],
[ 0., 9., 0., 0., 12., 7.],
[ 7., 11., 0., 0., 8., 14.],
[ 10., 0., 12., 8., 0., 8.],
[ 0., 9., 7., 14., 8., 0.]]]
1 là các đỉnh. Giá trị của Aij là 1 hoặc 0 tùy thuộc vào việc có cạnh từ đỉnh In [21]: adjacency_matrix
Out[21]:
matrix[[[ 0., 15., 0., 7., 10., 0.],
[ 15., 0., 9., 11., 0., 9.],
[ 0., 9., 0., 0., 12., 7.],
[ 7., 11., 0., 0., 8., 14.],
[ 10., 0., 12., 8., 0., 8.],
[ 0., 9., 7., 14., 8., 0.]]]
0 đến đỉnh In [21]: adjacency_matrix
Out[21]:
matrix[[[ 0., 15., 0., 7., 10., 0.],
[ 15., 0., 9., 11., 0., 9.],
[ 0., 9., 0., 0., 12., 7.],
[ 7., 11., 0., 0., 8., 14.],
[ 10., 0., 12., 8., 0., 8.],
[ 0., 9., 7., 14., 8., 0.]]]
1 hay không.
In [21]: adjacency_matrix
Out[21]:
matrix[[[ 0., 15., 0., 7., 10., 0.],
[ 15., 0., 9., 11., 0., 9.],
[ 0., 9., 0., 0., 12., 7.],
[ 7., 11., 0., 0., 8., 14.],
[ 10., 0., 12., 8., 0., 8.],
[ 0., 9., 7., 14., 8., 0.]]]
In [21]: adjacency_matrix
Out[21]:
matrix[[[ 0., 15., 0., 7., 10., 0.],
[ 15., 0., 9., 11., 0., 9.],
[ 0., 9., 0., 0., 12., 7.],
[ 7., 11., 0., 0., 8., 14.],
[ 10., 0., 12., 8., 0., 8.],
[ 0., 9., 7., 14., 8., 0.]]]
In [21]: adjacency_matrix
Out[21]:
matrix[[[ 0., 15., 0., 7., 10., 0.],
[ 15., 0., 9., 11., 0., 9.],
[ 0., 9., 0., 0., 12., 7.],
[ 7., 11., 0., 0., 8., 14.],
[ 10., 0., 12., 8., 0., 8.],
[ 0., 9., 7., 14., 8., 0.]]]
- Nếu có một đường dẫn từ ____10 đến
1, thì giá trị củaIn [21]: adjacency_matrix Out[21]: matrix[[[ 0., 15., 0., 7., 10., 0.], [ 15., 0., 9., 11., 0., 9.], [ 0., 9., 0., 0., 12., 7.], [ 7., 11., 0., 0., 8., 14.], [ 10., 0., 12., 8., 0., 8.], [ 0., 9., 7., 14., 8., 0.]]]Aijlà 1 nếu không thì 0. Ví dụ, có một đường dẫn từ đỉnh 1 đến đỉnh 2, vì vậy
8 là 1 và không có đường dẫn từ đỉnh 1 đến 3, Vì vậy,In [21]: adjacency_matrix Out[21]: matrix[[[ 0., 15., 0., 7., 10., 0.], [ 15., 0., 9., 11., 0., 9.], [ 0., 9., 0., 0., 12., 7.], [ 7., 11., 0., 0., 8., 14.], [ 10., 0., 12., 8., 0., 8.], [ 0., 9., 7., 14., 8., 0.]]]
9 là 0.In [21]: adjacency_matrix Out[21]: matrix[[[ 0., 15., 0., 7., 10., 0.], [ 15., 0., 9., 11., 0., 9.], [ 0., 9., 0., 0., 12., 7.], [ 7., 11., 0., 0., 8., 14.], [ 10., 0., 12., 8., 0., 8.], [ 0., 9., 7., 14., 8., 0.]]] - Trong trường hợp các biểu đồ không mong muốn, ma trận là đối xứng về đường chéo vì mỗi cạnh
0, cũng có một cạnh# Adjacency Matrix representation in Python class Graph[object]: # Initialize the matrix def __init__[self, size]: self.adjMatrix = [] for i in range[size]: self.adjMatrix.append[[0 for i in range[size]]] self.size = size # Add edges def add_edge[self, v1, v2]: if v1 == v2: print["Same vertex %d and %d" % [v1, v2]] self.adjMatrix[v1][v2] = 1 self.adjMatrix[v2][v1] = 1 # Remove edges def remove_edge[self, v1, v2]: if self.adjMatrix[v1][v2] == 0: print["No edge between %d and %d" % [v1, v2]] return self.adjMatrix[v1][v2] = 0 self.adjMatrix[v2][v1] = 0 def __len__[self]: return self.size # Print the matrix def print_matrix[self]: for row in self.adjMatrix: for val in row: print['{:4}'.format[val]], print def main[]: g = Graph[5] g.add_edge[0, 1] g.add_edge[0, 2] g.add_edge[1, 2] g.add_edge[2, 0] g.add_edge[2, 3] g.print_matrix[] if __name__ == '__main__': main[]
1.# Adjacency Matrix representation in Python class Graph[object]: # Initialize the matrix def __init__[self, size]: self.adjMatrix = [] for i in range[size]: self.adjMatrix.append[[0 for i in range[size]]] self.size = size # Add edges def add_edge[self, v1, v2]: if v1 == v2: print["Same vertex %d and %d" % [v1, v2]] self.adjMatrix[v1][v2] = 1 self.adjMatrix[v2][v1] = 1 # Remove edges def remove_edge[self, v1, v2]: if self.adjMatrix[v1][v2] == 0: print["No edge between %d and %d" % [v1, v2]] return self.adjMatrix[v1][v2] = 0 self.adjMatrix[v2][v1] = 0 def __len__[self]: return self.size # Print the matrix def print_matrix[self]: for row in self.adjMatrix: for val in row: print['{:4}'.format[val]], print def main[]: g = Graph[5] g.add_edge[0, 1] g.add_edge[0, 2] g.add_edge[1, 2] g.add_edge[2, 0] g.add_edge[2, 3] g.print_matrix[] if __name__ == '__main__': main[] - Ưu điểm của ma trận phụ thuộc
- Các hoạt động cơ bản như thêm một cạnh, loại bỏ một cạnh và kiểm tra xem có cạnh từ đỉnh I đến đỉnh J cực kỳ hiệu quả về thời gian, thời gian không đổi hay không.
Nếu biểu đồ dày đặc và số lượng cạnh lớn, một ma trận kề phải là lựa chọn đầu tiên. Ngay cả khi biểu đồ và ma trận kề là thưa thớt, chúng ta có thể biểu diễn nó bằng cách sử dụng các cấu trúc dữ liệu cho ma trận thưa thớt.
- Tuy nhiên, lợi thế lớn nhất đến từ việc sử dụng ma trận. Những tiến bộ gần đây trong phần cứng cho phép chúng tôi thực hiện các hoạt động ma trận đắt tiền trên GPU.
- Bằng cách thực hiện các hoạt động trên ma trận liền kề, chúng ta có thể nhận được những hiểu biết quan trọng về bản chất của biểu đồ và mối quan hệ giữa các đỉnh của nó.
Nhược điểm của ma trận phụ thuộc
Yêu cầu không gian
# Adjacency Matrix representation in Python
class Graph[object]:
# Initialize the matrix
def __init__[self, size]:
self.adjMatrix = []
for i in range[size]:
self.adjMatrix.append[[0 for i in range[size]]]
self.size = size
# Add edges
def add_edge[self, v1, v2]:
if v1 == v2:
print["Same vertex %d and %d" % [v1, v2]]
self.adjMatrix[v1][v2] = 1
self.adjMatrix[v2][v1] = 1
# Remove edges
def remove_edge[self, v1, v2]:
if self.adjMatrix[v1][v2] == 0:
print["No edge between %d and %d" % [v1, v2]]
return
self.adjMatrix[v1][v2] = 0
self.adjMatrix[v2][v1] = 0
def __len__[self]:
return self.size
# Print the matrix
def print_matrix[self]:
for row in self.adjMatrix:
for val in row:
print['{:4}'.format[val]],
print
def main[]:
g = Graph[5]
g.add_edge[0, 1]
g.add_edge[0, 2]
g.add_edge[1, 2]
g.add_edge[2, 0]
g.add_edge[2, 3]
g.print_matrix[]
if __name__ == '__main__':
main[]Mặc dù các hoạt động cơ bản rất dễ dàng, các hoạt động như
# Adjacency Matrix representation in Python
class Graph[object]:
# Initialize the matrix
def __init__[self, size]:
self.adjMatrix = []
for i in range[size]:
self.adjMatrix.append[[0 for i in range[size]]]
self.size = size
# Add edges
def add_edge[self, v1, v2]:
if v1 == v2:
print["Same vertex %d and %d" % [v1, v2]]
self.adjMatrix[v1][v2] = 1
self.adjMatrix[v2][v1] = 1
# Remove edges
def remove_edge[self, v1, v2]:
if self.adjMatrix[v1][v2] == 0:
print["No edge between %d and %d" % [v1, v2]]
return
self.adjMatrix[v1][v2] = 0
self.adjMatrix[v2][v1] = 0
def __len__[self]:
return self.size
# Print the matrix
def print_matrix[self]:
for row in self.adjMatrix:
for val in row:
print['{:4}'.format[val]],
print
def main[]:
g = Graph[5]
g.add_edge[0, 1]
g.add_edge[0, 2]
g.add_edge[1, 2]
g.add_edge[2, 0]
g.add_edge[2, 3]
g.print_matrix[]
if __name__ == '__main__':
main[]# Adjacency Matrix representation in Python
class Graph[object]:
# Initialize the matrix
def __init__[self, size]:
self.adjMatrix = []
for i in range[size]:
self.adjMatrix.append[[0 for i in range[size]]]
self.size = size
# Add edges
def add_edge[self, v1, v2]:
if v1 == v2:
print["Same vertex %d and %d" % [v1, v2]]
self.adjMatrix[v1][v2] = 1
self.adjMatrix[v2][v1] = 1
# Remove edges
def remove_edge[self, v1, v2]:
if self.adjMatrix[v1][v2] == 0:
print["No edge between %d and %d" % [v1, v2]]
return
self.adjMatrix[v1][v2] = 0
self.adjMatrix[v2][v1] = 0
def __len__[self]:
return self.size
# Print the matrix
def print_matrix[self]:
for row in self.adjMatrix:
for val in row:
print['{:4}'.format[val]],
print
def main[]:
g = Graph[5]
g.add_edge[0, 1]
g.add_edge[0, 2]
g.add_edge[1, 2]
g.add_edge[2, 0]
g.add_edge[2, 3]
g.print_matrix[]
if __name__ == '__main__':
main[]// Adjacency Matrix representation in Java
public class Graph {
private boolean adjMatrix[][];
private int numVertices;
// Initialize the matrix
public Graph[int numVertices] {
this.numVertices = numVertices;
adjMatrix = new boolean[numVertices][numVertices];
}
// Add edges
public void addEdge[int i, int j] {
adjMatrix[i][j] = true;
adjMatrix[j][i] = true;
}
// Remove edges
public void removeEdge[int i, int j] {
adjMatrix[i][j] = false;
adjMatrix[j][i] = false;
}
// Print the matrix
public String toString[] {
StringBuilder s = new StringBuilder[];
for [int i = 0; i < numVertices; i++] {
s.append[i + ": "];
for [boolean j : adjMatrix[i]] {
s.append[[j ? 1 : 0] + " "];
}
s.append["\n"];
}
return s.toString[];
}
public static void main[String args[]] {
Graph g = new Graph[4];
g.addEdge[0, 1];
g.addEdge[0, 2];
g.addEdge[1, 2];
g.addEdge[2, 0];
g.addEdge[2, 3];
System.out.print[g.toString[]];
}
}// Adjacency Matrix representation in C
#include
#define V 4
// Initialize the matrix to zero
void init[int arr[][V]] {
int i, j;
for [i = 0; i < V; i++]
for [j = 0; j < V; j++]
arr[i][j] = 0;
}
// Add edges
void addEdge[int arr[][V], int i, int j] {
arr[i][j] = 1;
arr[j][i] = 1;
}
// Print the matrix
void printAdjMatrix[int arr[][V]] {
int i, j;
for [i = 0; i < V; i++] {
printf["%d: ", i];
for [j = 0; j < V; j++] {
printf["%d ", arr[i][j]];
}
printf["\n"];
}
}
int main[] {
int adjMatrix[V][V];
init[adjMatrix];
addEdge[adjMatrix, 0, 1];
addEdge[adjMatrix, 0, 2];
addEdge[adjMatrix, 1, 2];
addEdge[adjMatrix, 2, 0];
addEdge[adjMatrix, 2, 3];
printAdjMatrix[adjMatrix];
return 0;
}// Adjacency Matrix representation in C++
#include
using namespace std;
class Graph {
private:
bool** adjMatrix;
int numVertices;
public:
// Initialize the matrix to zero
Graph[int numVertices] {
this->numVertices = numVertices;
adjMatrix = new bool*[numVertices];
for [int i = 0; i < numVertices; i++] {
adjMatrix[i] = new bool[numVertices];
for [int j = 0; j < numVertices; j++]
adjMatrix[i][j] = false;
}
}
// Add edges
void addEdge[int i, int j] {
adjMatrix[i][j] = true;
adjMatrix[j][i] = true;
}
// Remove edges
void removeEdge[int i, int j] {
adjMatrix[i][j] = false;
adjMatrix[j][i] = false;
}
// Print the martix
void toString[] {
for [int i = 0; i < numVertices; i++] {
cout