数据结构（用破圈法求一个带权连通图的最小生成树 ）

已于 2023-08-14 18:59:05 修改
阅读量2.2k 收藏 18
点赞数 3
文章标签： 数据结构 算法
于 2023-04-25 21:04:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54570435/article/details/130374094
版权

一、需求分析

1.1 问题描述

破圈法，是区别于避圈法（Prim算法和Kruskal算法）的⼀种寻找最⼩⽣成树的算法，也就是MST的⼀种⽅法。破圈法是“见圈破圈”，即如果看到图中有⼀个圈，就将这个圈的边去掉⼀条，直⾄图中再⽆⼀圈为⽌。破圈法是⼀种贪⼼算法，思想⼤体如下：

1.找到图中的⼀个圈；

2.删除其中的权最⼤的边；

3.重复上述操作，直到图中已⽆圈。

先将图G的边按照权的递减顺序排列后，依次检验每条边，在保持连通的情况下，每次删除最大权边，直到所有边都被遍历到无法删除任何一边（或余下n-1条边为止）。

1.2 基本要求

采用破圈法求一个带权连通图的最小生成树，并用 下图进行测试。图的存储结构自定义，并给出算法执行结果截图，以及算法效率分析。

1.3 任务

深入掌握图的复杂操作，图遍历算法和最小生成树的概念，以及最 小生成树的构造算法。 内容：编写一个程序，采用破圈法求一个带权连通图的最小生成树，并用 下图进行测试。图的存储结构自定义，并给出算法执行结果截图，以及算法效率分析。

二、概要设计

2.1 数据结构

利用的是图的存储结构。

2.2 程序模块

第一个模块——主函数main()的功能是：调用各函数完成相应的功能。

第二个模块——scanf()的功能是：在屏幕上输入邻接矩阵。

第三个模块——MAX( )的功能是：找出最大权值。

第四个模块——printf( )的功能是：输出各个信息。

2.3算法变量

a[n][n]:带权图的邻接矩阵,a[i][j]=w或a[i][j]=0；

max:标记当前找到的准备删去的边的权值；

p:标记找到的要删去的权值所在的行号；

q:标记找到的要删去的权值所在的列好；

am：标记找到的最大元素（am是为了保护权值大但不能删的边），如果a[i][j]不能删除，则可以让a[p][q]=am，a[q][p]=am来还原刚才删去的边；

I,j:二维数组的行号和列号

sm:图的边数，每删除一个边，sm就减1，当sm=n-1时，结束

wt：最小生成树的权值和

三、详细设计

3.1 主要函数的调用关系

 INPUT()

 {

        int i, j;

         printf("输入图的带权邻接矩阵：\n");

       for (i = 0; i < n; i++)

             {

                for (j = 0; j < n; j++)

                   scanf("%d", &a[i][j]);

            }

      }

  OUTPUT(int a[n][n])

  {

         int i, j;

         for (i = 0; i < n; i++)

              {

                  for (j = 0; j < n; j++)

                    printf("%5d", a[i][j]);

                  printf("\n");

             }

     }

  MAX(int a1[n][n], int am1, int p1, int q1)

  {

          int i, j, ptm, qtm;

          int max;

          max = 0;

         for (i = 0; i < n; i++)

              {

                 for (j = i; j < n; j++)

                      if ((a1[i][j] > max) && (a1[i][j] <= am1) && ((i != p1) || (j != q1)))

                      {

                         max = a1[i][j];

                         ptm = i;

                        qtm = j;

           

                         }

              }

        am = max;

      printf("max=%5d\t", am);

         p = ptm;

         q = qtm;

          a[p][q] = 0;

          a[q][p] = 0;

      }

  WSHALL(int array[n][n])

  {

        int i, j, k, m = 0;

          int r[n][n], B[n][n];

          for (i = 0; i < n; i++)

              {

                  for (j = 0; j < n; j++)

                      {

                          r[i][j] = 0;

                          B[i][j] = array[i][j];

                          //分界线

                              if (array[i][j] >= 1)

                                 B[i][j] = 1;

                         else

                                 B[i][j] = 0;

                         //分界线

                          }

              }

         for (j = 0; j < n; j++)

             {

                for (i = 0; i < n; i++)

                         if (B[i][j] >= 1)

                             {

                                 for (k = 0; k < n; k++)

                                         {

                                             if (B[k][i] >= 1)

                                                 {

                                                    B[k][j] = B[j][k] = 1;

                                                }

                                      }

                           }

            }

        for (i = 0; i < n; i++)

            {

                 for (j = 0; j < n; j++)

                        if (!B[i][j])

                         {

                             return 0;

                         }

             }

         return 1;

     }

3.2 各模块的算法

各模块的功能实现，主要代码见源代码。

源代码

#include<stdio.h>
 #define n 7
 int a[n][n];
 int flag, am, p, q;
 INPUT()
 {
        int i, j;
         printf("输入图的带权邻接矩阵：\n");
       for (i = 0; i < n; i++)
             {
                for (j = 0; j < n; j++)
                   scanf("%d", &a[i][j]);
            }
      }
  OUTPUT(int a[n][n])
  {
         int i, j;
         for (i = 0; i < n; i++)
              {
                  for (j = 0; j < n; j++)
                    printf("%5d", a[i][j]);
                  printf("\n");
             }
     }
  MAX(int a1[n][n], int am1, int p1, int q1)
  {
          int i, j, ptm, qtm;
          int max;
          max = 0;
         for (i = 0; i < n; i++)
              {
                 for (j = i; j < n; j++)
                      if ((a1[i][j] > max) && (a1[i][j] <= am1) && ((i != p1) || (j != q1)))
                      {
                         max = a1[i][j];
                         ptm = i;
                        qtm = j;
           
                         }
              }
        am = max;
      printf("max=%5d\t", am);
         p = ptm;
         q = qtm;
          a[p][q] = 0;
          a[q][p] = 0;
      }
  WSHALL(int array[n][n])
  {
        int i, j, k, m = 0;
          int r[n][n], B[n][n];
          for (i = 0; i < n; i++)
              {
                  for (j = 0; j < n; j++)
                      {
                          r[i][j] = 0;
                          B[i][j] = array[i][j];
                          //分界线
                              if (array[i][j] >= 1)
                                 B[i][j] = 1;
                         else
                                 B[i][j] = 0;
                         //分界线 
                          }
              }
         for (j = 0; j < n; j++)
             {
                for (i = 0; i < n; i++)
                         if (B[i][j] >= 1)
                             {
                                 for (k = 0; k < n; k++)
                                         {
                                             if (B[k][i] >= 1)
                                                 {
                                                    B[k][j] = B[j][k] = 1;
                                                }
                                      }
                           }
            }
        for (i = 0; i < n; i++)
            {
                 for (j = 0; j < n; j++)
                        if (!B[i][j])
                         {
                             return 0;
                         }
             }
         return 1;
     }
 int main()
 {
         int i, j, sm, wt = 0;
         am = 10000, p = -1, q = -1, sm = 0;
         INPUT();
       for (i = 0; i < n; i++)
             {
                for (j = i; j < n; j++)
                   {
                         if (a[i][j] > 0)
                                sm = sm + 1;
                     }
            }
         printf("\nsm=%d\n", sm);
        printf("输出图的带权邻接矩阵：\n");
         OUTPUT(a);
        printf("\n");
       while (sm > n - 1)
            {
                 MAX(a, am, p, q);
                flag = WSHALL(a);//华沙尔算法判断是否连通 
                //printf("flag= %d",flag);
                     {
                        if (flag == 1)
                            {
                                sm = sm - 1;
                                //printf("flag= %d",flag);
                                 }
                         else
                             {
                                 a[p][q] = am;
                                 a[q][p] = am;
                             }
                     }
             }
        for (i = 0; i < n; i++)
             for (j = i; j < n; j++)
           {
                 wt = wt + a[i][j];
             }
         printf("\n\n输出最小生成树的带权邻接矩阵：\n");
        OUTPUT(a);
        printf("最小生成树的树权是: %d\n", wt);
     }

X-MTing
关注
  • 3
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
带权图的最小生成树问题
Stevenson的博客
04-21 7618
带权图的最小生成树问题假设共有六个定点，分别为命名为０-５，如下图所示： 根据图构建出邻接矩阵adjMat[][]如下（其中权值为-1表示该两点之间没有路径）： adjMat[][] 0 1 2 3 4 5 0 -1 6 -1 4 -1 -1 1 6 -1 10 7 7 -1 2 -1 10
用“破圈法”求解带权连通无向图的一棵最小代价生成树
03-02
我们可用“破圈法”求解...请给出用“破圈法”求解给定的带权连通无向图的一棵最小代价生成树的详细算法，并用程序实现你所给出的算法. 这也是复旦大学97年数据结构和操作系统的考研题.答案，亲测可用，c++编写工程。
用“破圈法”求全部最小生成树的算法 (2006年)
05-26
求连通图的最小生成树是数据结构中讨论的一个重要问题．但在现实生活中．经常遇到如何得到连通图的所有最小生成树．针对此问题．运用“破圈法”思想，对所给的图进行约化，在约化图的基础上，提出了求全部最小生成树的算法，给出了应用例子．
数据结构实验：破圈法求最小生成树
10-10
根据书P262习题10给定的无向带权图，用破圈法构造其最小生成树。 所谓“破圈法”就是“任取一圈，去掉圈上权最大的边”，反复执行这一步骤，直到没有圈为止。请给出用“破圈法”求解给定的带权连通无向图的一最小生成树的详细算法，并用程序实现所给出的算法(注:圈就是回路)。 实现技术： 1、邻接矩阵作为存储结构 2、最大堆存放边 3、边结点类模板
最小生成树的三种求法（Kruskal避圈法，Prim，破圈法）
最新发布
2201_76011469的博客
06-09 1129
破圈法是“见圈破圈”，即如果看到图中有一个圈，就将这个圈的最大权边去掉一条，直至图中再无一圈为止。2、依次补全边，如果形成回路就舍弃（避圈）3、每个点的距离之和就是最小生成树的权值和。（kruskal在效率上更适用于稀疏图）3、连接完所有点，判断边数是否为n-1。边数排序：1，1，2，2，3，3，5。（prim在效率上更适用于稠密图）1、每次找一个离集合距离最小的点。（生成树的特征是边数为n-1）2、更新节点周围的节点的距离。1、把边按权值从大到小排序。Prim和dij很像。
破圈法构造最小生成树
12-21
用邻接矩阵存储图的信息 图的信息由用户输入 算法思想：1、找到度为1的顶点 将这个点删除 并把它的邻接点度数减一 反复执行此操作直到没有度为1 的顶点2、剩下的点已经在环中，找到最大的边 ，删除 3、反复执行1 2操作 直到最后找不到环路
数据结构实验——破圈法求最小生成树
qq_54146731的博客
10-10 1303
所谓“破圈法”就是“任取一圈，去掉圈上权最大的边”，反复执行这一步骤，直到没有圈为止。请给出用“破圈法”求解给定的带权连通无向图的一最小生成树的详细算法，并用程序实现所给出的算法(注:圈就是回路)。在AdjMatrixUndirNetwork.h头文件中，用邻接矩阵类作为图的存储结构，该头文件中包含了邻接矩阵类的数据成员及成员函数的声明与定义（这里不做代码展示）。连通图的生成树包括图中的全部n个顶点和足以使图连通的n-1条边，最小生成树是边上权值之和最小的生成树。
for循环延时_基于Redis实现简易消息队列和延时消息队列
weixin_39956036的博客
11-22 186
1.背景有时候，我们只是需要在系统内或两系统间将任务做延时异步处理，如果因为这个需求引入消息队列中间件，比如Kafka、Rabbitmq，未免有点杀鸡用牛刀。在消息可靠性要求不那么高的情况下,使用Redis基本数据类型list或zset，可以轻松满足我们的需求.2.list实现简易消息队列如下图所示，简易消息队列使用到list数据结构以及相关命令lpush、rpop或者rpush、lpop。这里提...
关于破圈法求最小生成树
热门推荐
fly around
12-29 2万+
       马上就要数据结构考试了，看到求最小生成树中有个“破圈法”，网上都没有详细介绍的，我就发表下自己的心得。    “破圈法”其实也是一种贪心算法，只不过prim和krustal算法是“加”边，而这个顾名思义，就是减边。思想大体如下：1.找到图中的一个圈。2.删除其中的权最大的边。3.重复上述操作，直到图中已无圈。针对无向图，可以这样做：1.用拓扑分类算法，找到图中的圈。具
破圈法求最小生成树_JavaScript 实现 最小生成树
weixin_40005795的博客
12-03 681
一 ： 了解最小生成树最小生成树（MST）问题是网络设计中常见的问题。想象一下，你的公司有几间办公室，要 以最低的成本实现办公室电话线路相互连通，以节省资金，最好的办法是什么？这也可以应用于岛桥问题。设想你要在 n 个岛屿之间建造桥梁，想用最低的成本实现所有岛 屿相互连通。这两个问题都可以用 MST 算法来解决，其中的办公室或者岛屿可以表示为图中的一个顶点， 边代表成本。下面有一个图的例子，其中...
可用“破圈法”求解带权连通无向图的一棵最小代价生成树。所谓“破圈法”就是“任取一圈，去掉圈上权最大的边”，反复执行这一步骤，直到没有圈为止。
12-21
可用“破圈法”求解带权连通无向图的一...请给出用“破圈法”求解给定的带权连通无向图的一棵最小代价生成树的详细算法，并用程序实现你所给出的算法。注：圈就是回路。 VS运行会出错，用visual studio 2010运行就可以
破圈法->最小生成树
12-03
可用“破圈法”求解带权连通图的一棵最小代价生成树。所谓“破圈法”就是“任取一圈，去掉圈上权最大的边”反复执行这一步骤，知道没有圈为止。请给出“破圈法”求解给定的带权连通无向图的一棵最小生成树的详细算法，并用程序实现你所给出的算法。注：圈就是回路
破圈法.doc
06-16
最小生成树，破圈法MATLAB程序，有想要LINGO程序的可以饲料我
破圈法求最小生成树
04-10
可用“破圈法”求解带权连通无向图的一棵最小代价生成树。所谓”破圈法“就是”任取一圈，去掉圈上权最大的...请给出用“破圈法”求解给定的带权连通无向图的一棵最小代价生成树的详细算法，并用程序实现你所给出的算法
最小生成树算法
weixin_34390996的博客
08-09 162
正文      所谓最小生成树，就是在一个具有N个顶点的带权连通图G中，如果存在某个子图G'，其包含了图G中的所有顶点和一部分边，且不形成回路，并且子图G'的各边权值之和最小，则称G'为图G的最小生成树。      由定义我们可得知最小生成树的三个性质：      • 最小生成树不能有回路。      • 最小生成树可能是一个，也可能是多个。      • 最小生成树边的个数等于顶点的个数减一。 ...
破圈法求解最小生成树c语言实现（已验证）
weixin_33778778的博客
04-18 2086
破圈法求解最小生成树c语言实现（已验证） 下面是算法伪代码，每一个算法都取一个图作为输入，并返回一个边集T。 对该算法，证明T是一棵最小生成树，或者证明T不是一棵最小生成树。此外，对于每个算法，无论它是否能计算出一棵最小生成树，都要给出其最有效的实现。 MAYBE-MST-A(G，w) Sort the edges into nonincreasing order of edge ...
Java 算法：（有权图）最小生成树问题
抛弃幻想，准备斗争
04-24 878
以下面相互联通的带权图为例： 一张图如果有V个节点的话，相应的有V - 1条边，V-1条边连接了V个节点，就说它是这个图的生成树。 生成树连接图中的所有节点。 最小生成树：生成树所有边的权值相加是最小的、针对带权无向图、连通图。 应用：电缆的布线设计、网络设计、电路设计。 设计思路：找V-1条边，连接V个顶点，总权值最小。 切分定理（Cut Property）： 1....
带权图的最小生成树
DouDouLee_blog的博客
08-26 2006
管理科学基础知识__图论__最小生成树和最短路径
华工的专栏
05-26 1173
在软件开发中，各项任务之间怎么衔接， 才能使开发工作完成得既快又好。 可以用图论作为工具来研究和解决问题。 例如，完成工程任务的时间最少、费用最省等。 1 最小生成树 在连通的带权图的所有生成树中， 权值和最小的那棵生成树(包含图中所有顶点的树)， 称作最小生成树。 求带权连通无向图的最小生成树的算法有普里姆（Prim）算法和 克鲁斯卡尔（Kruskal）算法。 1 普里姆算法 设已知G=（V，E）是一个带权连通无向图， 顶点V={0,1,2,... n-1}. 设U...
用破圈法求一个带权连通图的最小生成树用c++实现
06-09
好的，我会回答你的问题。 破圈法是一种求带权连通图最小生成树的经典算法之一，它的基本思想是：从连通图中任选一条边作为生成树的第一条边，然后依次添加剩余的边，直到生成一棵最小生成树。 下面是用C++实现破圈法求解带权连通图的最小生成树的示例代码： ```c++ #include <iostream> #include <algorithm> #include <vector> using namespace std; const int MAXN = 1005; // 最大顶点数 const int INF = 0x3f3f3f3f; // 无穷大 struct Edge { int u, v, w; Edge(int u_, int v_, int w_) : u(u_), v(v_), w(w_) {} }; int n, m; // 顶点数、边数 int fa[MAXN]; // 并查集数组 int find(int x) { // 并查集查找父节点 return (fa[x] == x) ? x : (fa[x] = find(fa[x])); } void merge(int x, int y) { // 并查集合并 fa[find(x)] = find(y); } bool cmp(Edge a, Edge b) { // 边长从小到大排序 return a.w < b.w; } int Kruskal(vector<Edge> &edges) { // 破圈法求最小生成树 int ans = 0; sort(edges.begin(), edges.end(), cmp); // 边长从小到大排序 for (int i = 1; i <= n; i++) fa[i] = i; // 初始化并查集 for (int i = 0; i < m; i++) { int u = edges[i].u, v = edges[i].v, w = edges[i].w; if (find(u) != find(v)) { // 判断是否在同一连通块 merge(u, v); // 合并连通块 ans += w; // 加上边长 } } return ans; } int main() { cin >> n >> m; vector<Edge> edges; for (int i = 0; i < m; i++) { int u, v, w; cin >> u >> v >> w; edges.push_back(Edge(u, v, w)); } int ans = Kruskal(edges); cout << ans << endl; return 0; } ``` 上述代码中，首先定义了一个边的结构体Edge，其中包括边的起点、终点和边权重。然后，定义了并查集的find和merge操作及判断两个点是否在同一连通块的函数。接着，定义了一个比较函数cmp，用于将边按照权值从小到大排序。最后，实现了破圈法的Kruskal函数，其中对边进行排序，初始化并查集，依次添加边，并判断是否在同一连通块，最后返回最小生成树的边权和。在main函数中，读入顶点数、边数和边的信息，调用Kruskal函数求解最小生成树，并输出结果。 希望我的回答能够帮到你，如果你还有其他问题，可以继续问我哦。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

X-MTing

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

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

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

打赏作者

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

抵扣说明：

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

余额充值