最小支撑树（下）

最新推荐文章于 2024-01-05 15:47:21 发布
最新推荐文章于 2024-01-05 15:47:21 发布
阅读量589 收藏 2
点赞数
分类专栏： 图论 文章标签： 图论 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52185313/article/details/121845441
版权

最小支撑树（下） – 潘登同学的图论笔记

文章目录


书接上文，上一篇我们写了Prim算法与Kruskal算法，接下来把剩下的算法解决掉

破圈法（Ⅰ）

输入： 赋权简单图 G G G

输出： G G G的最小支撑树 T = ( V T , E T ) T=(V_T, E_T) T=(VT​,ET​)

算法思路：每一步都删除权值最大而且不必要的边（出现在回路中的边），直到边数=顶点数-1

  • 1.把图G的边权值按不增的顺序排列成一个序列 e 1 , e 2 , … , e m e_1,e_2,\ldots,e_m e1​,e2​,…,em​, E ′ ← E , E T ← E E'\leftarrow E, E_T \leftarrow E E′←E,ET​←E
  • 2.若 ∣ E T ∣ = ∣ V ∣ − 1 |E_T|=|V|-1 ∣ET​∣=∣V∣−1，则输出 T = ( V , E T ) T=(V,E_T) T=(V,ET​)
  • 3.1.否则，假设e是 E ′ E' E′中权值最大的边， E ′ ← E ′ − { e } E'\leftarrow E'-\{e\} E′←E′−{e}
  • 3.2.如果 e 与 E T e与E_T e与ET​中的边构成回路，则 E T ← E T − { e } E_T\leftarrow E_T-\{e\} ET​←ET​−{e},返回2

很显然，这不就是把Kruskal算法倒过来了嘛，Kruskal算法是在一个图中从下到大找构不成回路的边，但是这个就是从大到小找破坏回路的边；

算法实现

#%% 破圈法（I）
from Vertex import Vertex
from Graph import Graph
import sys
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt

class New_Vertex(Vertex):  # 某一个具体问题的数据结构需要继承原有数据结构
    def __init__(self, key):
        super().__init__(key)
        self.color = 'white'  # 新增类属性(用于记录节点是否被走过)
        self.dist = sys.maxsize  # 新增类属性(用于记录strat到这个顶点的距离)初始化为无穷大
        self.pred = None  # 顶点的前驱 BFS需要

    # 新增类方法, 设置节点颜色
    def setColor(self, color):
        self.color = color

    # 新增类方法, 查看节点颜色
    def getColor(self):
        return self.color

    # 新增类方法, 设置节点前驱
    def setPred(self, p):
        self.pred = p

    # 新增类方法, 查看节点前驱
    def getPred(self):  # 这个前驱节点主要用于追溯，是记录离起始节点最短路径上
        return self.pred    # 该节点的前一个节点是谁

    # 新增类方法, 设置节点距离
    def setDistance(self, d):
        self.dist = d

    # 新增类方法, 查看节点距离
    def getDistance(self):
        return self.dist

    def getConnections_number(self):  # 查看相邻顶点的个数，用于后面找出最小支撑树
        return len(self.connectedTo)

    def del_Connection(self, nbr):
        '''
        Parameters
        ----------
        nbr : Vertex object
            DESCRIPTION.

        '''
        self.connectedTo.pop(nbr)

class New_Graph(Graph):  # 继承Graph对象
    def __init__(self):
        super().__init__()

    # 重载方法  因为原先Graph中新增节点用的是Vertex节点,但现在是用New_Vertex
    def addVertex(self, key):   # 增加节点
        '''
        input: Vertex key (str)
        return: Vertex object
        '''
        if key in self.vertList:
            return
        self.numVertices = self.numVertices + 1
        newVertex = New_Vertex(key)   # 创建新节点
        self.vertList[key] = newVertex
        return newVertex

    def del_edge(self, start, end):
        '''  
        Parameters
        ----------
        start : Vertex object
            DESCRIPTION.
        end : Vertex object
            DESCRIPTION.

        Returns
        -------
        None.
        '''
        # 调用顶点的方法进行删除
        start.del_Connection(end)

class Queue:
    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def enqueue(self, items):   # 往队列加入数据
        self.items.insert(0, items)

    def dequeue(self):
        return self.items.pop()

    def size(self):
        return len(self.items)

class Stack():  # 这个栈是后进先出  将列表的尾部设置为栈顶
    def __init__(self):
        self.stack = []

    def push(self, item):
        self.stack.append(item)

    def pop(self):
        return self.stack.pop()

    def peek(self):
        if self.isEmpty():
            return None
        else:
            return self.stack[-1]

    def isEmpty(self):
        return self.stack == []

    def size(self):
        return len(self.stack)

    def __len__(self):
        return self.size()

    def __iter__(self):
        return iter(self.stack)

class Solution_1:
     def createGraph(self, g_dict=None, g_matrix=None):
        '''
        input: g_dict(邻接表) or g_matrix(邻接矩阵)
        output: directgraph(有向图)
        '''
        graph = New_Graph()
        if g_dict:
            for from_key in g_dict:
                for to_key in g_dict[from_key]:
                    # 这里就是注意提到的f跟着c走所以原图的c是[f,c],这个很重要
                    graph.addEdge(from_key, to_key[0], to_key[1])

        elif g_matrix.any():
            # 先给顶点起个名字
            name = [str(i) for i in range(1, len(g_matrix)+1)]
            for i, from_key in enumerate(name):
                for j, to_key in enumerate(name):
                    if i != j and g_matrix[i][j] != float('inf'):
                        graph.addEdge(from_key, to_key, g_matrix[i][j])
        return graph

     def Reverse_delete(self, graph):
         V = []
         E = []
         Vt = New_Graph()
         for i in graph:
             for j in graph:
                 if i != j and j in i.getConnections():
                     # 因为如果用deepcopy会有问题，我也不知道为啥不行，所以自己从够一个图
                     Vt.addEdge(i.getId(), j.getId(), i.getWeight(j))
                     V.append([i, j])
                     E.append(i.getWeight(j))
         edge_number = len(E)
         del_dege_number = 0
         while del_dege_number != edge_number - len(graph) + 1:
             e = 0
             v = None
             # 找出最大的边
             for i,k in enumerate(E):
                 if k > e:
                     v = V[i]
                     e = k
             E.remove(e)
             V.remove(v)
             # 先删除
             Vt.del_edge(Vt.getVertex(v[0].getId()), Vt.getVertex(v[1].getId()))
             # 如果删后仍然可达，就确认删除
             if self.arrive(Vt, Vt.getVertex(v[0].getId()), Vt.getVertex(v[1].getId())):
                 del_dege_number += 1
             else:  # 否则就加回
                 Vt.addEdge(v[0], v[1], e)

         Tree_v = Stack()
         for i in Vt:
             if i.getConnections_number() == 0:
                 Tree_v.push(i)
                 break
         while len(Tree_v) != 2*len(Vt)-1:
             end = Tree_v.peek()
             for i in Vt:
                 if end in i.getConnections():
                     cost = i.getWeight(end)
                     Tree_v.push(cost)
                     Tree_v.push(i)
             

         print('最小生成树是：','总长度:', sum([i for i in Tree_v if isinstance (i,float)]))
         while len(Tree_v) != 1:
             print(f'{Tree_v.pop().getId()}--', f'{Tree_v.pop()}->', end='')
         print(f'{Tree_v.pop().getId()}')
         return Vt

     def arrive(self, Vt, start, end):
         '''

         Parameters
         ----------
         Vt : New_Graph对象
             DESCRIPTION.
         start : Vertex对象
             起始顶点.
         end : Vertex对象
             终止节点.

         Returns
         -------
          : bool
             True or False.
         '''
         for i in Vt:
             i.setColor('white')
         start.setPred(None)  # 前驱节点
         vertQueue = Queue()   # 队列
         vertQueue.enqueue(start)  # 把起始节点加入图中
         while vertQueue.size() > 0:   # 当搜索完所有节点时，队列会变成空的
             currentVert = vertQueue.dequeue()  # 取队首作为当前顶点
             for nbr in currentVert.getConnections():  # 遍历临接顶点
                 if (nbr.getColor() == 'white'):   # 当邻接顶点是白色的时候
                     nbr.setColor('gray')
                     nbr.setPred(currentVert)
                     vertQueue.enqueue(nbr)
             currentVert.setColor('balck')
         return not (end.getColor()=='white')


     def draw(self, graph, Vt):
         '''
         Parameters
         ----------
         graph : graph
             原图对象.
         Vt : graph
             Kruskal算法得出的.
         Returns
         -------
         plt.
         
         '''
         plt.rcParams['font.sans-serif'] = ['SimHei']
         plt.rcParams['axes.unicode_minus'] = False
         G = nx.DiGraph()
         GT = nx.DiGraph()
         for i in graph:
             for j in graph:
                 if i != j and j in i.getConnections():
                     G.add_edge(i.getId(), j.getId(), weight=i.getWeight(j))
         for i in Vt:
             for j in Vt:
                 if i != j and j in i.getConnections():
                     GT.add_edge(i.getId(), j.getId(), weight=i.getWeight(j))
         pos = nx.spring_layout(G,seed=41)
         options = {
            "font_size": 20,
            "node_size": 200,
            "node_color": "green",
            "edgecolors": "white",
            "edge_color": 'blue',
            "font_color": 'red',
            "linewidths": 2,
            "width": 2,
            'alpha':0.8,
            'with_labels':True
            }
         plt.figure(figsize=(12,6))
         plt.subplot(121)
         nx.draw(G, pos, **options)
         plt.title('原图')
         plt.subplot(122)
         nx.draw(GT, pos, **options)
         plt.title('最小支撑树')
         plt.show()


if __name__ == '__main__':
    inf = float('inf')
    a = np.array([[0, 1, 12, inf, inf, inf],
                  [inf, 0, 9, 3, inf, inf],
                  [inf, inf, 0, inf, 5, inf],
                  [inf, inf, 4, 0, 13, 15],
                  [inf, inf, inf, inf, 0, 4],
                  [inf, inf, inf, inf, inf, 0]])
    s = Solution_1()
    graph = s.createGraph(g_matrix=a)
    Vt = s.Reverse_delete(graph)
    s.draw(graph, Vt)
  • 结果如下：

破圈法(I)

破圈法(Ⅱ)

输入： 赋权简单图 G G G

输出： G G G的最小支撑树 T = ( V T , E T ) T=(V_T, E_T) T=(VT​,ET​)

因为上面的算法需要破除回路，就需要判断两点之间的可达关系，用上了BFS还是很麻烦的，而这个算法与上面的等价，但是相对简单一点

  • 1.把图G的边权值按不增的顺序排列成一个序列 e 1 , e 2 , … , e m e_1,e_2,\ldots,e_m e1​,e2​,…,em​, E ′ ← E , E T ← E E'\leftarrow E, E_T \leftarrow E E′←E,ET​←E
  • 2.若 ∣ E T ∣ = ∣ V ∣ − 1 |E_T|=|V|-1 ∣ET​∣=∣V∣−1，则输出 T = ( V , E T ) T=(V,E_T) T=(V,ET​)
  • 3.1.否则，假设e是 E ′ E' E′中权值最大的边， E ′ ← E ′ − { e } E'\leftarrow E'-\{e\} E′←E′−{e}
  • 3.2.如果 e 不 是 E T e不是E_T e不是ET​中的桥，则 E T ← E T − { e } E_T\leftarrow E_T-\{e\} ET​←ET​−{e},返回2

算法实现

#%% 破圈法（II）
from Graph import Graph
from Vertex import Vertex
import copy
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt

class New_Vertex(Vertex):  # 某一个具体问题的数据结构需要继承原有数据结构
    def __init__(self, key):
        super().__init__(key)
        self.in_degree = 0  # 新增入度属性
        self.out_degree = 0 # 新增出度属性
    
    def addNeighbor(self, nbr, weight=0):   # 重载加入节点方法
        '''
        input:
            nbr: Vertex object
            weight: int
        return:
            None
        '''
        self.connectedTo[nbr] = weight
        self.out_degree += 1
        nbr.in_degree += 1

    def get_degree(self):  # 查看度数
        return self.in_degree + self.out_degree

    def del_Connection(self, nbr):
        '''
        Parameters
        ----------
        nbr : Vertex object
            DESCRIPTION.

        '''
        self.connectedTo.pop(nbr)

class New_Graph(Graph):  # 继承Graph对象
    def __init__(self):
        super().__init__()

    # 重载方法  因为原先Graph中新增节点用的是Vertex节点,但现在是用New_Vertex
    def addVertex(self, key):   # 增加节点
        '''
        input: Vertex key (str)
        return: Vertex object
        '''
        if key in self.vertList:
            return
        self.numVertices = self.numVertices + 1
        newVertex = New_Vertex(key)   # 创建新节点
        self.vertList[key] = newVertex
        return newVertex

    def judge_brige(self, from_Ver, to_Ver):
        # 只有两个节点的度数都不是1，才不是桥
        return (from_Ver.get_degree == 1 or to_Ver.get_degree == 1)

    def del_edge(self, start, end):
        '''  
        Parameters
        ----------
        start : Vertex object
            DESCRIPTION.
        end : Vertex object
            DESCRIPTION.

        Returns
        -------
        None.
        '''
        # 调用顶点的方法进行删除
        start.del_Connection(end)
        
class Stack():  # 这个栈是后进先出  将列表的尾部设置为栈顶
    def __init__(self):
        self.stack = []

    def push(self, item):
        self.stack.append(item)

    def pop(self):
        return self.stack.pop()

    def peek(self):
        if self.isEmpty():
            return None
        else:
            return self.stack[-1]

    def isEmpty(self):
        return self.stack == []

    def size(self):
        return len(self.stack)

    def __len__(self):
        return self.size()

    def __iter__(self):
        return iter(self.stack)

        
class Solution_2:
     def createGraph(self, g_dict=None, g_matrix=None):
        '''
        input: g_dict(邻接表) or g_matrix(邻接矩阵)
        output: directgraph(有向图)
        '''
        graph = New_Graph()
        if g_dict:
            for from_key in g_dict:
                for to_key in g_dict[from_key]:
                    # 这里就是注意提到的f跟着c走所以原图的c是[f,c],这个很重要
                    graph.addEdge(from_key, to_key[0], to_key[1])

        elif g_matrix.any():
            # 先给顶点起个名字
            name = [str(i) for i in range(1, len(g_matrix)+1)]
            for i, from_key in enumerate(name):
                for j, to_key in enumerate(name):
                    if i != j and g_matrix[i][j] != float('inf'):
                        graph.addEdge(from_key, to_key, g_matrix[i][j])
        return graph

     def Reverse_delete_plus(self, graph):
         V = []
         E = []
         Vt = copy.deepcopy(graph)
         for i in graph:
             for j in graph:
                 if i != j and j in i.getConnections():
                     V.append([i, j])
                     E.append(i.getWeight(j))
         edge_number = len(E)
         del_dege_number = 0
         while del_dege_number != edge_number - len(graph) + 1:
             e = 0
             v = None
             # 找出最大的边
             for i,k in enumerate(E):
                 if k > e:
                     v = V[i]
                     e = k
             E.remove(e)
             V.remove(v)
             if not Vt.judge_brige(Vt.getVertex(v[0].getId()), Vt.getVertex(v[1].getId())):
                 Vt.del_edge(Vt.getVertex(v[0].getId()), Vt.getVertex(v[1].getId()))
                 del_dege_number += 1

         Tree_v = Stack()
         for i in Vt:
             if i.out_degree == 0:
                 Tree_v.push(i)
                 break
         while len(Tree_v) != 2*len(Vt)-1:
             end = Tree_v.peek()
             for i in Vt:
                 if end in i.getConnections():
                     cost = i.getWeight(end)
                     Tree_v.push(cost)
                     Tree_v.push(i)
             

         print('最小生成树是：','总长度:', sum([i for i in Tree_v if isinstance (i,float)]))
         while len(Tree_v) != 1:
             print(f'{Tree_v.pop().getId()}--', f'{Tree_v.pop()}->', end='')
         print(f'{Tree_v.pop().getId()}')
         return Vt

     def draw(self, graph, Vt):
         '''
         Parameters
         ----------
         graph : graph
             原图对象.
         Vt : graph
             Kruskal算法得出的.
         Returns
         -------
         plt.
         
         '''
         plt.rcParams['font.sans-serif'] = ['SimHei']
         plt.rcParams['axes.unicode_minus'] = False
         G = nx.DiGraph()
         GT = nx.DiGraph()
         for i in graph:
             for j in graph:
                 if i != j and j in i.getConnections():
                     G.add_edge(i.getId(), j.getId(), weight=i.getWeight(j))
         for i in Vt:
             for j in Vt:
                 if i != j and j in i.getConnections():
                     GT.add_edge(i.getId(), j.getId(), weight=i.getWeight(j))
         pos = nx.spring_layout(G,seed=41)
         options = {
            "font_size": 20,
            "node_size": 200,
            "node_color": "green",
            "edgecolors": "white",
            "edge_color": 'blue',
            "font_color": 'red',
            "linewidths": 2,
            "width": 2,
            'alpha':0.8,
            'with_labels':True
            }
         plt.figure(figsize=(12,6))
         plt.subplot(121)
         nx.draw(G, pos, **options)
         plt.title('原图')
         plt.subplot(122)
         nx.draw(GT, pos, **options)
         plt.title('最小支撑树')
         plt.show()


if __name__ == '__main__':
    inf = float('inf')
    a = np.array([[0, 1, 12, inf, inf, inf],
                  [inf, 0, 9, 3, inf, inf],
                  [inf, inf, 0, inf, 5, inf],
                  [inf, inf, 4, 0, 13, 15],
                  [inf, inf, inf, inf, 0, 4],
                  [inf, inf, inf, inf, inf, 0]])
    s = Solution_2()
    graph = s.createGraph(g_matrix=a)
    Vt = s.Reverse_delete_plus(graph)
    s.draw(graph, Vt)
  • 结果如下:

破圈法(II)

博鲁夫卡算法

输入： 赋权简单图 G G G

输出： G G G的最小支撑树 T = ( V T , E T ) T=(V_T, E_T) T=(VT​,ET​)

算法思路：每一步都选择最相近的两个连通分支合并，直到剩下最后一个连通分支

  • 1. E T ← ∅ E_T \leftarrow \empty ET​←∅, 图G中的每个顶点v都作为一个连通分支， C ← ( V , E T ) C\leftarrow (V,E_T) C←(V,ET​)
  • 2.对图C中的每两个不同的连通分支，选择权重最小的边 e = u v e=uv e=uv, E T ← E T ∪ { e } , C ← ( V , E T ) E_T\leftarrow E_T \cup \{e\},C\leftarrow (V,E_T) ET​←ET​∪{e},C←(V,ET​)
  • 3.若只有一个连通分支，则输出 T = ( V , E T ) T=(V,E_T) T=(V,ET​),否则返回步骤2

注意 这里出现了连通分支，之前在图的分类那里说过，连通分支的特点就是互相可达，所以这就要求图是无向图，因为一个连通的有向图，就算把原图原封不动的输出，也可能不是一个连通分支；

如下图，这个就是三个连通分支

连通分支

算法实现

#%%  博鲁夫卡算法

import numpy as np
import copy
import networkx as nx
import matplotlib.pyplot as plt

class Solution(object):
    def min_merge(self, a, i, j, index=None):
        '''
        用于合并两行（列），并且以两行（列）的小的值作为新一行（列）的值
    
        Parameters
        ----------
        a : array

        i : int
            第一行（列）.
        j : int
            第二行（列）.
        Returns
        -------
        result
            处理后的array.
        index
            修改的index
        '''
        result = copy.deepcopy(a)
        ai = result[i, :]
        aj = result[j, :]
        temp = []
        if not isinstance(index, np.ndarray):
            index = [[(0,0)]*len(result) for _ in range(len(result))]
            index = np.array(index)
            for a in range(len(result)):
                for b in range(len(result)):
                        index[a, b] = (a, b)
        for s,b in zip(ai,aj):
            bool_index = ai>aj
            for k in range(len(bool_index)):
                if k:
                    index[i, k] = index[j, k]
            temp.append(min(s,b))
        for k in range(len(temp)):
            result[i,k] = temp[k]
        result = np.delete(result,j,axis=0)
        index = np.delete(index,j,axis=0)
    
        ai = result[:,i]
        aj = result[:,j]
        temp = []
        for s,b in zip(ai,aj):
            bool_index = ai>aj
            for k in range(len(bool_index)):
                if k:
                    index[k, i] = index[k, j]
            temp.append(min(s,b))
        for k in range(len(temp)):
            result[k,i] = temp[k]
        result = np.delete(result,j,axis=1)
        index = np.delete(index,j,axis=1)
        return result, index
    
    def main(self, mat):
        '''

        Parameters
        ----------
        mat : array
            无向图的领接矩阵，可以是三角型矩阵.

        Returns
        -------
        Vt: list
            [[from_key, to_key]*n-1]
        Et: list
            [e1, ...,e(n-1)]

        '''
        result = copy.deepcopy(mat)
        Vt = []
        Et = []
        index = None
        while len(result) != 1:
            i,j = np.where(result==np.min(result[result>0]))
            i = i[0]
            j = j[0]
            if isinstance(index, np.ndarray):
                a,b = index[i,j]
                Vt.append([str(a+1), str(b+1)])
            else:
                Vt.append([str(i+1), str(j+1)])
            Et.append(np.min(result[result>0]))
            result,index = self.min_merge(result, i, j, index)
        return Vt, Et
    
    def draw(self, mat, Vt, Et):
         '''
         Parameters
         ----------
         graph : graph
             原图对象.
         Vt : graph
             Kruskal算法得出的.
         Returns
         -------
         plt.
         
         '''
         plt.rcParams['font.sans-serif'] = ['SimHei']
         plt.rcParams['axes.unicode_minus'] = False
         G = nx.Graph()
         GT = nx.Graph()
         num = '123456789'
         for i in range(len(mat)):
             for j in range(len(mat)):
                 if mat[i, j] != float('inf') and mat[i, j] != 0:
                     G.add_edge(num[i], num[j], weight=mat[i, j])
         for i,j in zip(Vt, Et):
             GT.add_edge(i[0], i[1], weight=j)
         pos = nx.spring_layout(G,seed=42)
         options = {
            "font_size": 20,
            "node_size": 200,
            "node_color": "green",
            "edgecolors": "white",
            "edge_color": 'blue',
            "font_color": 'red',
            "linewidths": 2,
            "width": 2,
            'alpha':0.8,
            'with_labels':True
            }
         plt.figure(figsize=(12,6))
         plt.subplot(121)
         nx.draw(G, pos, **options)
         plt.title('原图')
         plt.subplot(122)
         nx.draw(GT, pos, **options)
         plt.title('最小支撑树')
         plt.show()
            
        
        
    
if __name__ == '__main__':
    inf = float('inf')
    a = np.array([[0, 1, 12, inf, inf, inf],
                  [inf, 0, 9, 3, inf, inf],
                  [inf, inf, 0, inf, 5, inf],
                  [inf, inf, 4, 0, 13, 15],
                  [inf, inf, inf, inf, 0, 4],
                  [inf, inf, inf, inf, inf, 0]])
    s = Solution()
    Vt, Et = s.main(a)
    s.draw(a, Vt, Et)
  • 结果如下：

博鲁夫卡算法

注意 博鲁夫卡算法是应用在无向图下的，考虑到无向图的连通分支判断过于简单，所以这里没有运用图的数据结构，直接操作矩阵就能得到结果，但是在算法过程中，注意两个点：

  • 两个连通分支合并，对应矩阵上就是两行及两列取小后合并
  • 维护好一个连通分支与其他连通分支的边是哪个节点提供的，而我们采用的方法就是维护一个index数组，这个数组的一行、一列代表一个连通分支，而第i行第j列的元素则表示第i个连通分支到第j个连通分支是哪两个点进行连接，比如
    i n d e x [ 2 , 4 ] = [ 4 , 6 ] index[2,4] = [4, 6] index[2,4]=[4,6]

则表示第2个连通分支与第4个连通分支的最短边是节点4与节点6的边

最小瓶颈支撑树

定义

设 ( G , W ) (G,W) (G,W)是无向连通赋权图， G G G的所有支撑树中权值最大的边权值最小的支撑树

从定义中可以看出，最小瓶颈支撑树不唯一，且可能不是最小支撑树

两者的关系：最小支撑树一定是最小瓶颈支撑树，最小瓶颈支撑树不一定是最小支撑树

斯坦纳树

设 ( G = ( V , E ) , W ) (G=(V,E), W) (G=(V,E),W)是无向连通赋权图， R ⊆ V R\subseteq V R⊆V,在G的所有包含 R R R中所有顶点的子图中，总权值最小的树

特别地，当 R = V R=V R=V时，斯坦纳树就是最小支撑树

注意 在斯坦纳树中，不一定只含有 R R R，有时候多含有一些顶点可能树会更小

  • 例如：对于 R = { A , B , C } R=\{A,B,C\} R={A,B,C}的斯坦纳树来说，当边权值不同时，斯坦纳树可能不同

斯坦纳树

事实上，斯坦纳树是NPC问题；

最小支撑树（下）就是这么多了，继续学习下一章吧！

PD我是你的真爱粉
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
破圈法求最小支撑树matlab_破圈法求解最小生成树c语言实现（已验证）
weixin_31366459的博客
01-12 879
破圈法求解最小生成树c语言实现(已验证)下面是算法伪代码，每一个算法都取一个图作为输入，并返回一个边集T。对该算法，证明T是一棵最小生成树，或者证明T不是一棵最小生成树。此外，对于每个算法，无论它是否能计算出一棵最小生成树，都要给出其最有效的实现。MAYBE-MST-A(G，w)Sort the edges into nonincreasing order of edge weights wTFo...
最小支撑树(最小生成树)
热门推荐
Viator
05-04 1万+
如下图所示，连通图G的某一无环两通子图T若覆盖G中所有的顶点，则称作G的一棵支撑树或生成树(spanning tree)。 其中顶点数为n，其边数为n-1。 如果其生成树中各边权值和最小，那么称其为最小生成树(可以不唯一)。 实现一 Prim算法 在图中G=(V;E)中，顶点集V的任一非平凡子集U及其补集V\U都构成G的一个割(cut)，记作(U:V\U)。若边uv满足u属于U且...
UVA - 10457 最小瓶颈生成树（最大边最小的最小生成树）
twh233的算法blog
09-28 826
题目链接 题意：你有一辆很magic的车，如果你的驾驶速度比以前的最大速度要大，就要消耗相应的差值的能量，如果速度比以前的最小速度要小，也要消耗相应的差值的能量。然后有一个无向图，边的权值代表你必须要以这样的速度经过这条边，问从s，到t的最小能量消耗。 做法： 枚举两条边，m^2的复杂度，如果起点和终点在同一集合，代表他们已经合并了，查询两边差值即可。 /// ...
UVA-1395 最小瓶颈生成树
刷题记录
01-28 212
problem 求min(maxval-minval) maxval,minval 生成树边的最大最小值 sort边集，枚举最小值 因为最小生成树同时也是最小瓶颈生成树 每次做一遍kruskal更新答案即可 code： #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=1e5+7...
图论：最小瓶颈生成树
weixin_30600503的博客
08-10 424
最小瓶颈生成树不一定是最小生成树，但最小生成树一定是最小瓶颈生成树 由于关心最大边便把边从小到大排序，最先生成的那棵生成树就是答案。而这就是Kruskal算法，所以原图的最小生成树就是一棵最小瓶颈生成树了 感觉这个解释很牵强呀 不过知道结论就舒服多了 题目是BZOJ2429 int kruskal() //返回瓶颈 { int tot=0; for(int ...
网络规划之最小支撑树1
08-04
【网络规划之最小支撑树1】知识详解 网络规划中，最小支撑树是解决图与网络优化问题的关键方法。图与网络优化问题广泛应用于工程和管理领域，它们利用线性规划理论和算法来处理具有图结构的问题。由于这类问题的...
最小生成树算法C语言代码实例
12-31
在贪婪算法这一章提到了最小生成树的一些算法，首先是Kruskal算法，实现如下： MST.h 代码如下:#ifndef H_MST#define H_MST #define NODE node *#define G graph *#define MST edge ** /* the undirect graph start...
图的最小支撑树算法 Kruskal算法
11-27
数据结构实验做的图的最小生成树算法，C++实现的Kruskal算法
最小生成树MATLAB代码实现
01-08
假设 WN=(V,{E}) 是一个含有 n 个顶点的连通网，则按照...反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直至森林中只有一棵树，也即子图中含有 n-1条边为止。
用prim算法求最小支撑树的解法
09-15
Prim算法求解最小支撑树问题 Prim算法是一种常用的求解最小支撑树问题的方法，该算法可以求解无向图的最小支撑树。该算法的思路是从图中的一个顶点开始，逐步添加边和顶点，直到所有顶点都被添加到树中。 Prim...
破圈法求最小生成树
04-10
可用“破圈法”求解带权连通无向图的一棵最小代价生成树。所谓”破圈法“就是”任取一圈，去掉圈上权最大的边“，反复执行这一步骤，直到没有圈为止。请给出用“破圈法”求解给定的带权连通无向图的一棵最小代价生成树的详细算法，并用程序实现你所给出的算法
关于最小瓶颈树的详解
NCC__dapeng的博客
08-14 1548
首先给出最小瓶颈树的定义： 树中的最大权值边 — 树中的最小权值边的值，是图G的各个生成树中最小的。 算法实现： 此类题要使用Kruskal算法进行求解，Kruskal算法详解：https://blog.csdn.net/luomingjun12315/article/details/47700237/ 大体上是利用了Kruskal算法中的三条特性： （1）、并...
week-6-D-数据中心（最小瓶颈生成树）
weixin_43904059的博客
03-30 106
题意 样例: INPUT: 4 5 1 1 2 3 1 3 4 1 4 5 2 3 8 3 4 2 OUTPUT: 4 思路 此题本意是求 最优的max{Th},就是求最优max{t11,t12,t13,t21,t22,t23，t31},也就是求解一棵生成树，使其最大边权最小； 如...
最小生成树算法
最新发布
wanglianda2007的博客
01-05 916
三种常见最小生成树算法原理。
7-5 最小支撑树 (10 分)
weixin_45566930的博客
03-19 594
7-5 最小支撑树 (10 分) 给定一个包含n个顶点的正权无向图，编号为0至n-1。请编写程序求出其最小支撑树，并计算其代价。 输入格式: 输入包含多组数据。每组数据第一行为2个整数n和e，均不超过200，分别表示图的顶点数和边数。接下来e行表示每条边的信息，每行为3个非负整数a、b、c，其中a和b表示该边的端点编号，c表示权值。各边并非按端点编号顺序排列。 输出格式: 对于每组数据，若存在最小支撑树则输出一个整数，为最小支撑树各边权值之和；若不存在最小支撑树，则输出“There is no minimu
图论 最小生成树 Boruvka算法
HeartFireY的博客
11-09 2441
文章目录一、前导1.Kruskal和Prim的回顾2.Boruvka算法引入二、Brouvka原理与实现1.基本原理2.基本过程3.实现 一、前导 1.Kruskal和Prim的回顾 首先我们对KruskalKruskalKruskal和PrimPrimPrimu算法进行回顾： KruskalKruskalKruskal算法的基本思想是维护一个森林，查询两个结点是否在同一棵树中，并连接两棵树。在实际的算法过程中，我们需要对边集进行排序，复杂度O(mlog⁡m)O(m \log m)O(mlogm)，并使用
12.4 Borüvka算法
你的指尖有改变世界的力量
04-18 1549
用例子和python代码来讲述boruvka算法过程
[图论]Prim算法求最小支撑树和最短路径
让勤奋成为习惯
12-22 9440
Prim算法
最小生成树之Boruvka算法
愿君出走半生，归来时仍是少年
06-18 4059
Boruvka算法是求最小生成树的最古老的算法，于1926年由Boruvka提出，那时计算机还没出现呢。其时间复杂度和Prim、Kruskal算法一样，也是O(ELogV)。而且Boruvka算法也和Prim、Kruskal一样是贪心法。 它的基本思想是：生成树中所有顶点必然是连通的，所以两个不相交集必须连接起来才能构成生成树，而且所选择的连接边的权重必须最小，才能得到最小生成树。 算法描述如下 （1）输入一个连通的有向带权图； （2）把所有顶点都初始化成单独的一个子集； （3）初始化一个空的MS
求解最小支撑树MST的算法原理
05-11
最小支撑树 (Minimum Spanning Tree，MST) 是一棵树，它连接了一个无向图中的所有节点，并且总权值最小。求解最小支撑树的算法有多种，下面介绍两种常见的算法： 1. Kruskal算法 Kruskal算法是一种贪心算法，它通过不断选择边来构建最小支撑树。具体步骤如下： 1）将所有边按照权值从小到大排序。 2）从权值最小的边开始，如果这条边的两个端点不在同一个连通块中，则选择这条边，并将这两个端点所在的连通块合并。 3）重复第2步，直到所有节点都在同一个连通块中为止。 2. Prim算法 Prim算法也是一种贪心算法，它通过不断选择节点来构建最小支撑树。具体步骤如下： 1）选择任意一个节点作为起点，将该节点加入最小支撑树中。 2）将与最小支撑树的节点相邻的所有边按照权值从小到大排序。 3）选择权值最小的边所连接的节点，如果该节点不在最小支撑树中，则将该节点加入最小支撑树中。 4）重复第2步和第3步，直到所有节点都在最小支撑树中为止。 以上两种算法都可以求解最小支撑树，它们的时间复杂度都是O(ElogE)，其中E是图中的边数，因此在实际应用中可以根据具体情况选择使用哪种算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PD我是你的真爱粉

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值