Come to an end for now

Author: wOvOpy

README.md

@@ -25,3 +25,6 @@
 ### 3.1 Hungary algorithm
 - [代码](graph_match/hungary.py)
 - [图例](graph_match/hungary.png)
+### 3.2 Kuhn_Munkras
+- [代码](graph_match/kuhn_munkras.py)
+- [图例](graph_match/kuhn_munkras.png)

graph_match/hungary.png

@@ -4,17 +4,16 @@
 
 class Hungary:
     def __init__(self, nodes_one, nodes_two, edges) -> None:
-        self.nodes_one = nodes_one
-        self.nodes_two = nodes_two
-        self.edges = edges
-
+        self.nodes_one = nodes_one # 二部图的第一部分节点
+        self.nodes_two = nodes_two # 二部图的第二部分节点
+        self.edges = edges # 二部图的所有边
+    
     def max_match(self):
         '''求最大匹配边的数量，标记匹配的节点
         '''
-        match = defaultdict(lambda: -1) #记录节点匹配
+        match = defaultdict(lambda: None) #记录节点匹配
         num_match = 0 #最大匹配数量
         node_neighbors = defaultdict(list) # 节点邻居映射
-
         for (u, v) in self.edges:
             node_neighbors[u].append(v)
             node_neighbors[v].append(u)
@@ -23,11 +22,10 @@ def dfs(u):
             for v in node_neighbors[u]:
                 if v not in visited:
                     visited.add(v)
-                    if match[v] == -1 or dfs(match[v]):
+                    if match[v] == None or dfs(match[v]):
                         match[v] = u
                         return True
             return False
-
         for node in self.nodes_one:
             visited = set()
             if (dfs(node)):
@@ -64,9 +62,10 @@ def draw(G, nodes_one, nodes_two, color_edges):
         one_y -= 1
 
     for node_two in nodes_two:
-        pos[node_two] = [two_x // 3, two_y]
+        pos[node_two] = [two_x, two_y]
         two_y -= 1
     # print(pos)
+    plt.title('Hungary Algorithm: Maximum Matching')
     nx.draw(G, pos, with_labels=True, node_color=node_color, edge_color=edge_color)
     plt.savefig('hungary.png', format='PNG')
     plt.show()
@@ -86,9 +85,7 @@ def main():
     edges = [(0, 'a'), (0, 'b'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (3, 'c'), (3, 'd')]
 
     num_match, match = Hungary(nodes_one, nodes_two, edges).max_match()
-    match_edges = []
-    for key, value in match.items():
-        match_edges.append((value, key))
+    match_edges = [(u, v) for u, v in match.items()]
     print('{} | {}'.format(match_edges, num_match))
 
     G = nx.Graph()

graph_match/hungary.py

@@ -0,0 +1,127 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+import sys
+from collections import defaultdict
+
+
+class KM:
+    def __init__(self, nodes_one, nodes_two, edges) -> None:
+        self.nodes_one = nodes_one # 二部图第一部分节点
+        self.nodes_two = nodes_two # 二部图第二部分节点
+        self.edges = edges # 所有边（带权重）
+        
+    def optimal_match(self):
+        '''理解该算法建议手动模拟一下代码中的例子
+        '''
+        match = defaultdict(lambda: None) # 记录节点匹配情况
+        sum_weights = 0 # 最优匹配权重总和
+        node_neighbors = defaultdict(list) # 节点邻居映射
+        edge_weight = defaultdict(int) # 边权重映射
+        
+        label_one = defaultdict(int) # 第一部分节点的可行顶标
+        label_two = defaultdict(int) # 第二部分节点的可行顶标
+        slack = defaultdict(lambda: sys.maxsize) # 记录第二部分节点能和第一部分节点匹配还需要多少权重
+        one_visited, two_visited = set(), set()
+        # 初始化
+        for (u, v, w) in self.edges:
+            node_neighbors[u].append(v)
+            node_neighbors[v].append(u)
+            edge_weight[(u, v)] = edge_weight[(v, u)] = w
+        for node_one in self.nodes_one:
+            max_w = 0
+            for node_one_neighbor in node_neighbors[node_one]:
+                max_w = max(max_w, edge_weight[(node_one, node_one_neighbor)])
+            label_one[node_one] = max_w
+        
+        def dfs(u):
+            one_visited.add(u)
+            
+            for v in node_neighbors[u]:
+                if v in two_visited:
+                    continue
+                gap = label_one[u]+label_two[v] - edge_weight[(u, v)]
+                
+                if gap == 0:
+                    two_visited.add(v)
+                    if match[v] == None or dfs(match[v]):
+                        match[v] = u
+                        return True # 
+                else:
+                    slack[v] = min(slack[v], gap)
+            return False
+           
+        for u in self.nodes_one:
+            slack.clear()
+            while not dfs(u):
+                min_gap = sys.maxsize # 最小可以降低多少顶标值能够完成匹配
+                for node_two in self.nodes_two:
+                    if node_two not in two_visited:
+                        min_gap = min(min_gap, slack[node_two])
+                for node_one in self.nodes_one:
+                    if node_one in one_visited:
+                        label_one[node_one] -= min_gap
+                for node_two in self.nodes_two:
+                    if node_two in two_visited:
+                        label_two[node_two] += min_gap
+                    else:
+                        slack[node_two] -= min_gap
+                one_visited.clear()
+                two_visited.clear()
+        # 求最优匹配的权重和
+        for key, value in match.items():
+            sum_weights += edge_weight[(value, key)]
+        return match, sum_weights
+
+def draw(G, nodes_one, nodes_two, color_edges):
+    nodes = list(G.nodes)
+    edges = list(G.edges)
+    num_node = len(nodes)
+    num_edge = len(edges)
+    node_color = ['b'] * num_node
+    edge_color = ['b'] * num_edge
+
+    for i in range(0, num_node):
+        if isinstance(nodes[i], type(nodes_one[0])):
+            node_color[i] = 'r'
+
+    for i in range(num_edge):
+        u, v = edges[i][0], edges[i][1]
+        # 无向图
+        if (u, v) in color_edges or (v, u) in color_edges:
+            edge_color[i] = 'r'
+    '''
+    自定义pos
+    '''
+    # 对matplotlib不太熟悉，布局有待改进
+    pos = dict()
+    size = max(len(nodes_one), len(nodes_two)) + 2
+    one_x, two_x = size//3, 2*size // 3
+    one_y, two_y = size-1, size-1
+    for node_one in nodes_one:
+        pos[node_one] = [one_x, one_y]
+        one_y -= 1
+
+    for node_two in nodes_two:
+        pos[node_two] = [two_x, two_y]
+        two_y -= 1
+    plt.title('KM Algorithm: Optimal Matching')
+    nx.draw(G, pos, with_labels=True, node_color=node_color, edge_color=edge_color)
+    edge_labels = nx.get_edge_attributes(G, 'weight')
+    # label_pos=0.8作用: 防止图中交叉边上权重值重叠
+    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, label_pos=0.8)
+    plt.savefig('kuhn_munkras.png', format='PNG')
+    plt.show()       
+def main():
+    nodes_one = [0, 1, 2]
+    nodes_two = ['a', 'b', 'c']
+    edges = [(0, 'a', 3), (0, 'c', 4), (1, 'a', 2), (1, 'b', 1), (1, 'c', 3), (2, 'c', 5)]
+    match, sum_weights = KM(nodes_one, nodes_two, edges).optimal_match()
+    match_edges = [(u, v) for u, v in match.items()]
+    print('{} | {}'.format(match_edges, sum_weights))
+    G = nx.Graph()
+    G.add_nodes_from(nodes_one+nodes_two)
+    G.add_weighted_edges_from(edges)
+    draw(G, nodes_one, nodes_two, match_edges)
+
+if __name__ == '__main__':
+    main()

graph_match/kuhn_munkras.png

@@ -97,6 +97,7 @@ def draw(G, color_edges):
 
     # 边的长度和权重大小成正比
     pos = nx.kamada_kawai_layout(G)
+    plt.title('MST')
     nx.draw(G, pos, with_labels=True, edge_color=edge_color)
     edge_labels = nx.get_edge_attributes(G, 'weight')
     nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)

graph_match/kuhn_munkras.py

@@ -54,10 +54,11 @@ def draw(G, color_edges):
         if (u, v) in color_edges or (v, u) in color_edges:
             edge_color[i] = 'r'
     pos = nx.kamada_kawai_layout(G)
+    plt.title('MST')
     nx.draw(G, pos, with_labels=True, edge_color=edge_color)
     edge_labels = nx.get_edge_attributes(G, 'weight')
     nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
-    # plt.savefig("kruskal.png", format="PNG")
+    plt.savefig("kruskal.png", format="PNG")
     plt.show()
 
 def main():

mst/broken_circle.png

@@ -80,6 +80,7 @@ def draw(G, color_edges):
 
     # 边的长度和权重大小成正比
     pos = nx.kamada_kawai_layout(G)
+    plt.title('MST')
     edge_labels = nx.get_edge_attributes(G, 'weight') # 画权重
     nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
     nx.draw(G, pos, with_labels=True, edge_color=edge_color) # 画边

mst/broken_circle.py

@@ -102,10 +102,10 @@ def draw(DG, color_nodes, color_edges):
             edge_color[i] = 'r'
 
     pos = nx.circular_layout(DG)
-    plt.title('Digraph-Bellman_Ford')
+    plt.title('Digraph: Shortest Path')
     nx.draw(DG, pos, with_labels=True, node_color=node_color, edge_color=edge_color) # 画图
     edge_labels = nx.get_edge_attributes(DG, 'weight')
-    edge_labels = { (key[0],key[1]): "w:"+str(edge_labels[key]) for key in edge_labels }
+    # edge_labels = { (key[0],key[1]): "w:"+str(edge_labels[key]) for key in edge_labels }
     nx.draw_networkx_edge_labels(DG, pos, edge_labels=edge_labels) # 画权重
     plt.savefig('bellman_ford.png', format='PNG')
     plt.show()

mst/kruskal.png

@@ -108,10 +108,10 @@ def draw(DG, color_nodes, color_edges):
             edge_color[i] = 'r'
 
     pos = nx.circular_layout(DG)
-    plt.title('Digraph-Dijkstra')
+    plt.title('Digraph: Shortest Path')
     nx.draw(DG, pos, with_labels=True, node_color=node_color, edge_color=edge_color) # 画图
     edge_labels = nx.get_edge_attributes(DG, 'weight')
-    edge_labels = { (key[0],key[1]): "w:"+str(edge_labels[key]) for key in edge_labels }
+    # edge_labels = { (key[0],key[1]): "w:"+str(edge_labels[key]) for key in edge_labels }
     nx.draw_networkx_edge_labels(DG, pos, edge_labels=edge_labels) # 画权重
     plt.savefig('dijkstra.png', format='PNG')
     plt.show()

mst/kruskal.py

@@ -11,24 +11,25 @@
 
 class FloydWarshall:
     def __init__(self, graph_mat) -> None:
-        self.graph_mat = graph_mat
+        self.graph_mat = graph_mat # 图的邻接矩阵
 
     def shortest_path(self):
         m, n = len(self.graph_mat), len(self.graph_mat[0])
-        path = [[-1] * n for _ in range(m)]
+        distance_mat = self.graph_mat.copy()
+        path = [[None] * n for _ in range(m)] # 记录路径
         for k in range(m):
             for i in range(m):
                 for j in range(n):
-                    if self.graph_mat[i][k]+self.graph_mat[k][j] < self.graph_mat[i][j]:
-                        self.graph_mat[i][j] = self.graph_mat[i][k]+self.graph_mat[k][j]
+                    if distance_mat[i][k]+distance_mat[k][j] < distance_mat[i][j]:
+                        distance_mat[i][j] = distance_mat[i][k]+distance_mat[k][j]
                         path[i][j] = k
-        return self.graph_mat, path
+        return distance_mat, path
 # 递归
 # def get_nodes_edges_recursion(paths, i, j):
 #         if i == j:
 #             return [i], []
 #         else:
-#             if paths[i][j] == -1:
+#             if paths[i][j] == None:
 #                 return [j], [(i, j)]
 #             else:
 #                 left_nodes, left_edges = get_nodes_edges(paths, i, paths[i][j])
@@ -38,7 +39,7 @@ def shortest_path(self):
 def get_nodes_edges(paths, i, j):
     pass_nodes = [i, j]
     pass_edges = []
-    while paths[i][j] != -1:
+    while paths[i][j] != None:
         j = paths[i][j]
         pass_nodes.insert(1, j)
         pass_edges.append((j, pass_nodes[2]))
@@ -67,7 +68,7 @@ def draw(sp_mat, color_nodes, color_edges):
     # print(nx_G.edges(data=True))
     edge_labels = nx.get_edge_attributes(nx_G, 'w')
     # tensor.item() tensor(0.)->0(tensor->int)
-    edge_labels = { (key[0],key[1]): "w:"+str(edge_labels[key].item()) for key in edge_labels }
+    edge_labels = { (key[0],key[1]): edge_labels[key].item() for key in edge_labels }
     edges = list(nx_G.edges)
     num_nodes = nx_G.number_of_nodes()
     num_edges = nx_G.number_of_edges()
@@ -82,7 +83,7 @@ def draw(sp_mat, color_nodes, color_edges):
         if (u, v) in set(color_edges) or (v, u) in set(color_edges):
             edge_color[i] = 'r'
     pos = nx.circular_layout(nx_G)
-    plt.title('Undigraph-Floyd Warshall')
+    plt.title('Undigraph: Shortest Path')
     nx.draw(nx_G, pos, with_labels=True, node_color=node_color, edge_color=edge_color)
     nx.draw_networkx_edge_labels(nx_G, pos, edge_labels=edge_labels)
     plt.savefig('floyd_warshall.png', format='PNG')
@@ -105,13 +106,13 @@ def main():
                 graph_mat[i][j] += graph_mat[j][i]
                 graph_mat[j][i] = graph_mat[i][j]
 
-    finaly_mat, paths = FloydWarshall(graph_mat).shortest_path()
-    print(finaly_mat)
+    distance_mat, paths = FloydWarshall(graph_mat).shortest_path()
+    print(distance_mat)
     print(paths)
 
     for i in range(count_node):
         for j in range(i+1, count_node):
-            print('{}->{}: {} | {}'.format(i, j, get_nodes_edges(paths, i, j), finaly_mat[i][j]))
+            print('{}->{}: {} | {}'.format(i, j, get_nodes_edges(paths, i, j), distance_mat[i][j]))
 
     start_node, end_node = 0, 5 # 开始节点，结束节点
     pass_nodes, pass_edges = get_nodes_edges(paths, start_node, end_node)