最小生成树(MATLAB)
最小生成树matlab代码
最小生成树简介最小生成树（Minimum Spanning Tree）是图论中的一个重要概念。
它是一种用于连接所有节点的树，同时使得树中边的权值之和最小。
最小生成树在许多领域中都有广泛的应用，例如网络设计、电力传输、交通规划等。
算法Kruskal算法Kruskal算法是一种常用的解决最小生成树问题的算法。
它的基本思想是通过不断选择图中权值最小的边，并且保证这些边不会形成环，直到选择了足够多的边为止。
具体步骤如下：1.初始化一个空的最小生成树集合。
2.将图中所有边按照权值从小到大排序。
3.遍历排序后的边，如果当前边不会导致最小生成树形成环，则将该边添加到最小生成树集合中。
4.最终得到的最小生成树集合即为所求。
Prim算法Prim算法是另一种解决最小生成树问题的经典算法。
它的基本思想是从一个起始节点开始，逐步扩展最小生成树，直到覆盖所有节点。
具体步骤如下：1.初始化一个空的最小生成树集合。
2.随机选择一个起始节点，并将其加入到最小生成树集合中。
3.在最小生成树集合和图的剩余节点之间找到连接两部分的最小权值边，将该边和连接的节点加入到最小生成树集合中。
4.重复步骤3，直到最小生成树覆盖了所有节点。
应用场景网络设计最小生成树在网络设计中有着广泛应用。
例如，在计算机网络中，我们希望通过最小的成本将所有节点连接起来。
最小生成树提供了一种方法来实现这一目标，通过构建一个权值最小的树形网络，可以节省物理资源，提高网络传输效率。
电力传输在电力传输领域，最小生成树被用于设计最优的电力传输网络。
通过选择最小的成本边连接所有电力站点，可以减少电力传输的总成本，并优化电力的分布。
交通规划最小生成树在交通规划中也有着广泛的应用。
例如，在城市道路规划中，我们希望通过最小的道路建设成本将所有地区连接起来。
最小生成树算法可以帮助我们找到连接所有区域的最短路径，从而实现高效的交通规划。
MATLAB代码实现function [T] = minSpanningTree(G)% 输入参数:% G: 输入图的邻接矩阵表示% 输出参数:% T: 最小生成树的邻接矩阵表示n = size(G, 1); % 节点个数visited = zeros(1, n); % 记录节点是否被访问过T = zeros(n); % 初始化最小生成树的邻接矩阵visited(1) = 1; % 从第一个节点开始构建最小生成树while sum(visited) < n % 当所有节点都被访问过时停止minEdge = inf; % 最小权值边的权值minIndex = 0; % 最小权值边的终点for i = 1:nif visited(i) == 1for j = 1:nif visited(j) == 0 && G(i, j) < minEdgeminEdge = G(i, j);minIndex = j;endendendendvisited(minIndex) = 1; % 将新节点标记为已访问T(minIndex, :) = G(minIndex, :); % 将该边添加到最小生成树中T(:, minIndex) = G(:, minIndex);endend总结最小生成树是一种重要的图论概念，常用于解决连接所有节点的问题。
最小生成树Prim算法（邻接矩阵和邻接表）
最⼩⽣成树Prim算法（邻接矩阵和邻接表） 最⼩⽣成树，普利姆算法．简述算法: 先初始化⼀棵只有⼀个顶点的树，以这⼀顶点开始，找到它的最⼩权值，将这条边上的令⼀个顶点添加到树中 再从这棵树中的所有顶点中找到⼀个最⼩权值（⽽且权值的另⼀顶点不属于这棵树） 重复上⼀步．直到所有顶点并⼊树中．图⽰：注：以a点开始，最⼩权值为１，另⼀顶点是ｃ，将ｃ加⼊到最⼩⽣成树中．树中 ａ－ｃ在最⼩⽣成树中的顶点找到⼀个权值最⼩且另⼀顶点不在树中的，最⼩权值是４，另⼀个顶点是ｆ，将ｆ并⼊树中， ａ－ｃ－ｆ重复上⼀步骤，ａ－ｃ－ｆ－ｄ， ａ－ｃ－ｆ－ｄ－ｂ， ａ－ｃ－ｆ－ｄ－ｂ－ｅ．邻接矩阵的实现我⼜构建了⼀个邻接矩阵（prim_tree)，将我们求出的最⼩⽣成树写⼊其中．我们还需要⼀个visited数组，来确定⼀个顶点是否已被纳⼊最⼩⽣成树中．１）初始化，visited数组，prim_tree节点信息，矩阵．１－１１，４１－５５⾏２）将⼀个顶点并⼊树（prim_tree）中．以这个顶点开始，进⾏遍历寻找最⼩权值． 这⾥⽤了三层循环嵌套． ｉ这⼀层的作⽤是遍历图的节点信息，我们要将所有节点都纳⼊树中． ｊ这⼀层的作⽤是遍历树的节点信息．（我们是通过visited数组来确定⼀个节点是否属于最⼩⽣成树的，１９⾏，ｉｆ的作⽤） ｋ这⼀层的作⽤是在ｊ节点所在所在矩阵的⾏中找到最⼩权值． （注：ｊ和ｋ配合，找到树中的最⼩权值（最⼩权值的另⼀个节点没有被纳⼊树中，２３⾏ｉｆ的作⽤）．ｊ查找的节点信息的下标，但矩阵是正⽅形的，所以ｊ既是节点信息的下标，⼜是该节点在矩阵中的列位置．⽽ｋ则在ｊ这⼀列查找最⼩权值．当ｊ将树遍历⼀遍，这时会找到⼀个最⼩权值，这个最⼩权值的另⼀个顶点就是我们将要纳⼊树中的节点．）３）将上⾯获得的信息写⼊树中．（写⼊时也要判断该节点是否已被纳⼊树中．没有纳⼊树中的节点才会将其纳⼊树中．）1//最⼩⽣成树prim算法2static void init_prim(Graph * graph, Graph * prim_tree);3void Prim(Graph * graph, Graph * prim_tree)4 {5bool visited[graph->vertexs];6int i, j, k, h;7int power, power_j, power_k;89for ( i = 0; i < graph->vertexs; i++ )10 visited[i] = false;11 init_prim(graph, prim_tree);1213 visited[0] = true;14for ( i = 0; i < graph->vertexs; i++ )16 power = MAX_VALUE;17for ( j = 0; j < graph->vertexs; j++ )18 {19if ( visited[j] )20 {21for ( k = 0; k < graph->vertexs; k++ )22 {23if ( power > graph->arcs[j][k] && !visited[k] )24 {25 power = graph->arcs[j][k];26 power_j = j;27 power_k = k;28 }29 }30 }31 }32//min power33if ( !visited[power_k] )34 {35 visited[power_k] = true;36 prim_tree->arcs[power_j][power_k] = power;37 }38 }39 }4041static void init_prim(Graph * graph, Graph * prim_tree)42 {43int i, j;4445 prim_tree->vertexs = graph->vertexs;46for ( i = 0; i < prim_tree->vertexs; i++ )//初始化节点47 prim_tree->vertex[i] = graph->vertex[i];48for ( i = 0 ; i < prim_tree->vertexs; i++ )//初始化矩阵49 {50for ( j = 0; j < prim_tree->vertexs; j++ )51 {52 prim_tree->arcs[i][j] = MAX_VALUE;53 }54 }55 }上述代码适⽤于连通图．如果想运⾏这个程序，到/ITgaozy/p/5187483.html找源码，将上⾯的代码粘到⾥⾯就可以了．邻接表的实现算法和矩阵⼀样，只是由于数据结构不同，在代码上有些差别．static void init_prim(Graph * graph, Graph * prim_tree);void g_prim(Graph * graph, Graph * prim_tree){bool visited[graph->vertexs];int i, j, k;int power, pos;Arc_node * tmp;for ( i = 0; i < graph->vertexs; i++ )visited[i] = false;init_prim(graph, prim_tree);visited[0] = true;for ( i = 0; i < graph->vertexs; i++ ){power = INT_MAX;//limits.hfor ( j = 0; j < graph->vertexs; j++ ){if ( visited[j] ){tmp = graph->adjlist[j].next;while ( tmp != NULL ){if ( power > tmp->distance && !visited[tmp->pos] ){power = tmp->distance;pos = tmp->pos;k = j;}tmp = tmp->next;}}if ( !visited[pos] ){if ( prim_tree->adjlist[k].next == NULL ){prim_tree->adjlist[k].next = make_node(pos, power);}else{tmp = prim_tree->adjlist[k].next;while ( tmp->next != NULL )tmp = tmp->next;tmp->next = make_node(pos, power);}visited[pos] = true;}}}static void init_prim(Graph * graph, Graph * prim_tree){int i;for ( i = 0; i < graph->vertexs; i++ ){prim_tree->adjlist[i].info = graph->adjlist[i].info;prim_tree->adjlist[i].next = NULL;}prim_tree->vertexs = graph->vertexs;}到/ITgaozy/p/5187526.html⾥找到源码，将上述代码粘到源码中，就可以了．由于本⼈⽔平有限，不⾜之处还望⼤家不吝指教．。
Primf及Krusf最小成树及matlab源代码
11
2013年8月21日11 Nhomakorabea
例 、一个乡有7个自然村，其间道路如图 所示，要以村为中心建有线广播网络，如 要求沿道路架设广播线，应如何架设？
a
18
19 14 16 12
b
7
8
5
c
3
e
f
g
27
21
d
12
数学建模-图论
四、最小生成树问题及其算法
Prim 算法 Matlab 程序如下：
function T =Primf(a) l=length(a); a(a==0)=inf; k=1:l; listV(k)=0; listV(1)=1; e=1; while(e<l) min=inf; for i=1:l if listV(i)==1 for j=1:l if listV(j)==0 & min>a(i,j) min=a(i,j); b=a(i,j); s=i; d=j; end end end end
10
数学建模-图论
四、最小生成树问题及其算法
求最小生成树的 Prim 算法的思想如下：
从连通图 G=<V,E>的某一顶点 v 出发，选择与其关联的具有最小权的边 (u0,v)，将其顶点加入到生成树的顶点集合 U 中。以后每一步从一个顶点 在 U 中而另一顶点不在 U 中的各条边中选择权值最小的边（u，v） ，把它的 顶点加入到集合 U 中，如此下去，直到图中的所有顶点都加入到生成树顶点 集合 U 中为止，这时得到一颗最小生成树。
0 2 2 0 4 4 0 8 A 8 0 4 5 3 7 8 5 3 7 8 0 3 7 3 0 6 7 6 0 4
数学建模-最小生成树-kruskal算法及各种代码
kruskal算法及代码---含伪代码、c代码、matlab、pascal等代码K r u s k a l算法每次选择n- 1条边，所使用的贪婪准则是：从剩下的边中选择一条不会产生环路的具有最小耗费的边加入已选择的边的集合中。
注意到所选取的边若产生环路则不可能形成一棵生成树。
K r u s k a l算法分e 步，其中e 是网络中边的数目。
按耗费递增的顺序来考虑这e 条边，每次考虑一条边。
当考虑某条边时，若将其加入到已选边的集合中会出现环路，则将其抛弃，否则，将它选入。
目录Kruskal算法Kruskal算法的代码实现Kruskal算法Kruskal算法的代码实现算法定义克鲁斯卡尔算法假设 WN=(V,{E}) 是一个含有 n 个顶点的连通网，则按照克鲁斯卡尔算法构造最小生成树的过程为：先构造一个只含 n 个顶点，而边集为空的子图，若将该子图中各个顶点看成是各棵树上的根结点，则它是一个含有 n 棵树的一个森林。
之后，从网的边集 E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，也就是说，将这两个顶点分别所在的两棵树合成一棵树；反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。
依次类推，直至森林中只有一棵树，也即子图中含有n-1条边为止。
举例描述克鲁斯卡尔算法(Kruskal's algorithm)是两个经典的最小生成树算法的较为简单理解的一个。
这里面充分体现了贪心算法的精髓。
大致的流程可以用一个图来表示。
这里的图的选择借用了Wikipedia上的那个。
非常清晰且直观。
首先第一步，我们有一张图，有若干点和边如下图所示：第一步我们要做的事情就是将所有的边的长度排序，用排序的结果作为我们选择边的依据。
这里再次体现了贪心算法的思想。
资源排序，对局部最优的资源进行选择。
排序完成后，我们率先选择了边AD。
这样我们的图就变成了第二步，在剩下的变中寻找。
02最小生成树
范例：制造系统的分组技术
建模
设用Mi表示需由机器i加工的零件集，对任 意两台机器i,j, 定义相异度：
(i, j) | Mi M j | | Mi M j |
建模
(i, j) | Mi M j | | Mi M j |
“”：对称差， 分子：在机器i但不在机器j上加工，或在机 器j但不在机器i上加工的零件数。 分母：或在机器i，或在机器j上加工的零件数。 显然 01
最小生成树
一些常见的树形结构
无向树的定义
无向树: 连通无回路的无向图 平凡树: 平凡图 森林: 每个连通分支都是树的非连通的无向图 树叶: 树中度数为1的顶点 分支点: 树中度数2的顶点 例如
(a)
(b)
子图
定义设G=<V,E>, G=<V,E>是2个图(同为无向图,或同 为有向图) 若VV且EE, 则称G为G的子图, G为G的母图, 记作 GG 若GG 且V=V, 则称G为G的生成子图 设VV且V, 以V为顶点集, 以两端点都在V中的所有 边为边集的G的子图称作V的导出子图, 记作G[V] 设EE且E, 以E为边集, 以E中边关联的所有顶点为 顶点集的G的子图称作E的导出子图, 记作G[E]
范例：制造系统的分组技术
分组技术是设计制造系统的一种方法，它把生 产零件的机器分组，相应地把需生产的零件分类，使 零件跨组加工的情形尽量少，最理想的情况是使每个 零件的加工，都在组内完成。 假设有13种零件，需在9台机器上加工。在各台 机器上加工的零件号在下表中给出。
范例：制造系统的分组技术
机器 加工 的零 件 1 2,3, 7,8, 9,12 ,13 2 2,7, 8,11 ,12, 3 1,6 表 4 5 3,5, 3,7, 10 8,9, 12, 13 6 5 7 4,10 8 4,10 9 6
PRIM算法求最小生成树
PRIM算法求最小生成树输入：一个加权连通图G=(V,E)，其中V为图中的顶点集合，E为边集合。
输出：一个最小生成树T=(V',E')，其中V'为T中的顶点集合，E'为T中的边集合。
1.初始化一个空的最小生成树T，选择一个初始点v0作为起点。
2.将v0加入到最小生成树T中。
3.重复以下步骤直到T中包含了所有的顶点：a.找到从T中的顶点集合V'到V-V'的边集合E-V'中的最小权值边(u,v)。
b.将顶点v加入到最小生成树T中。
c.将边(u,v)加入到最小生成树T中。
4.输出最小生成树T。
PRIM算法的思想是通过不断选择最小权值的边来构建最小生成树。
在每一步中，算法都会选择一条跨越T和V-T的边中权值最小的边(u,v)，将顶点v加入到T中，并将边(u,v)加入到T中。
通过该过程，最终可以得到一个最小生成树。
PRIM算法的时间复杂度为O(，V，^2)，其中，V，表示顶点的数量。
在每一次添加节点v时，算法需要遍历所有的顶点来选择具有最小权值的边(u, v)，因此时间复杂度为O(，V，^2)。
如果使用优先队列来存储边集合E-V'，则可以将时间复杂度优化为O(，E，log，V，)。
下面以一个具体的例子来说明PRIM算法的执行过程。
假设有如下的加权连通图G：```34v0-----v1-----v2/，2，1/，73//，/，v3-----v4-----v556```选择v0为初始点，按照PRIM算法的步骤执行：1.初始化T为{v0}。
2.将v0加入到T中。
3.重复以下步骤直到T中包含了所有的顶点：a.找到从T中的顶点集合V'={v0}到V-V'={v1,v2,v3,v4,v5}的边集合E-V'={(v0,v1),(v0,v3)}中的最小权值边(v0,v1)。
b.将顶点v1加入到T中。
c.将边(v0,v1)加入到T中。
d.找到从T中的顶点集合V'={v0,v1}到V-V'={v2,v3,v4,v5}的边集合E-V'={(v0,v3),(v1,v2),(v1,v3)}中的最小权值边(v0,v3)。
Kruskal算法寻找最小树的matlab程序
Kruskal算法寻找最小树的matlab程序function tree=kruskal(d) %矩阵d为无向图的权矩阵，且是对称矩阵N=size(d,1);k=0; %记录图中边的条数I=max(max(d)); %I作为无穷大edge=zeros(N*(N-1)/2,3);%用于存储图中所有的边，边的条数最多为n*(n-1)/2for i=1:N-1 %因为权矩阵是对称阵，所以只用上三角矩阵。
for j=i+1:Nif d(i,j)<Ik=k+1;edge(k,1)=i;edge(k,2)=j;edge(k,3)=d(i,j);endendendedge=edge(1:k,:); %删除多余的行。
o_edge=edge; %用于存储排序后的边及边的端点。
for i=1:k-1 %用选择排序法进行升序排序for j=i+1:kif o_edge(i,3)>o_edge(j,3)temp=o_edge(i,:);o_edge(i,:)=o_edge(j,:);o_edge(j,:)=temp;endendendtree=zeros(N-1,3); %用于存放最小树中的边及边的端点，最小树中的边数为节点数减1 tree(1:2,:)=o_edge(1:2,:); %两条边一定不能构成圈，所以前面最小的两条边一定在最小树中。
line=3;for i=3:kif line==N %如果line=N说明tree矩阵已填满，最小树已经找到，跳出循环break;elseif line<Nif isempty(find(tree(:,1:2)==o_edge(i,1), 1))||isempty(find(tree(:,1:2)==o_edge(i,2), 1))%判断tree中已经确定的的所有边中的节点是否和新增加的边的两个端点都重复，若新边的两个端点不都重复，则为真%直接说明新边符合条件，加入tree中。
最小生成树
如此进行下去，每次往生成树里并入一 个顶点和一条边，直到n-1次后，把所有 n 个顶点都并入生成树T的顶点集U中， 此时U=V，TE中包含有（n-1）条边；
图
图6.10 图G 及其生成树
无向连通图 G 图
➢ 生成树
图6.10 图G 及其生成树
生成树
➢ 最小生成树
图
1.1 普里姆(prim)算法
假设G=(V,E)是一个具有n 个顶点的连通网络， T=(U,TE)是G的最小生成树，其中U是T的顶点 集，TE是T的边集，U和TE的初值均为空。
算法开始时，首先从V中任取一个顶点（假定 为V1），将此顶点并入U中，此时最小生成树 顶点集U={V1}；
这样，T就是最后得到的最小生成树。
普里姆算法中每次选取的边两端，总是 一个已连通顶点（在U集合内）和一个未 连通顶点（在U集合外），故这个边选取 后一定能将未连通顶点连通而又保证不 会形成环路。
图
图6.11 普里姆算法例子
图
为了便于在顶点集合U和V-U之间选择权 最小的边，建立两个数组closest和 lowcost,closest[i]表示U中的一个顶点，该 顶点与V-U中的一个顶点构成的边具有最 小的权；lowcost表示该边对应的权值。
姆
{
算
min=lowcost[j];
法
k=j;
续
} printf(“(%d,%d)”,k,closest[j]);
/* 打印生成树的一条边*/
最小生成树matlab实现
primclear all;close all;Graph1;%调用Graph1M文件，产生图1的邻接矩阵%Graph2;%调用Graph2M文件，产生图2的邻接矩阵len=length(graph_adjacent);%求图中有多少个顶点k=sprintf('please input the point where you want to start ,do rem ember it must be between 1 and %d ',len);start_point=input(k);%输入最小生成树产生起点while((start_point<=0)|(start_point>len))%如果输入的结点位置不合法即：小于等于零，或大于结点数，则重新输入disp('bad positon,please input again!');start_point=input(k);end;%************************************下面完成prim算法************** **************%相关变量初始设置tree=zeros(len-1,2);%用于保存选入最小生成树的边lowcost=zeros(1,len);%用来保存集合V-U与集合U中顶点的最短边权值，lowcost [v]=0表示顶点v已经%加入最小生成树中adjvex=zeros(1,len);%用来保存依附于该边在集合U中的节点，U集合为生成最小生成树的辅助集合，%首先U={start_point},之后依次确定为把最小生成树的一边的另一节点加入U%依次下去，直到图的全部顶点都在U中能找到lowcost=graph_adjacent(start_point,:);%lowcost(i)的值为节点i与start _point的权值；adjvex=start_point.*ones(1,len);%adjvex中所有元素的值都为初始节点%以下循n-1次，用于找出最小生成树的len-1条边for i=1:len-1k=lowcost>0;%k为一逻辑数组，它和lowcost同维，对于每一个位置i1lowcos t(i)>0则k(i)=1%否则k(i)=0;稍候将用这个数组进行辅助寻址cost_min=min(lowcost(k));%找出lowcost中除0外的最小值index=find(lowcost==cost_min);%找出此最小值在lowcost中的下标，即找到相应的节点index=index(1);%因为最小值的下标可能不止一个，这里取第一个下标进行处理 lowcost(index)=0;%表明该节点已经加入了最小生成树中tree(i,:)=[adjvex(index),index];%对lowcost和adjvex进行更新for j=1:lenif lowcost(j)>graph_adjacent(j,index);lowcost(j)=graph_adjacent(j,index);adjvex(j)=index;endendend;%*************************结果显示模块***************************** *******s=0;for ii=1:len-1k=sprintf('最小生成树第%d条边：（%d,%d），权值为%d',ii,tree(ii,1),tr ee(ii,2),graph_adjacent(tree(ii,1),tree(ii,2)));%格式化字符串%disp(k);%显示%disp(' ');%空一行s=s+graph_adjacent(tree(ii,1),tree(ii,2)); %求最小生成树的代价end%显示最小生成树的代价disp('最小生成树的总代价为：')disp(s);kruskalclear all;close all;Graph11;%调用以邻接矩阵储存的图所在的M文件%Graph22;len=length(graph_adjacent);%计算图中的顶点数temp=graph_adjacent;%将原图内容拷贝到temp中，以防对原图做改动superedge=zeros(len-1,2);%用于保存生成最小生成树的边i=1;%指向superedge的下标for j=1:lentag(j)=j;%关联标志初始化，将每个顶点的关联标志设为其本身end;%以下的循环完成kruskal算法while(superedge(len-1,1)==0)[Y,I]=sort(temp);%将temp的每列按从小到大排序，数组Y保存temp 排序后的结果，I中保存相应结果对应的在temp中的下标cost_min=min(Y(1,:));%找出权值最小的边index=find(Y(1,:)==cost_min);%找出权值最小的边对应的顶点index=index(1);%一条边对应两个节点，且不同的边的权值可能一样，这里为了方便处理人为规定了顺序，取标号最小的顶点进行处理anotherpoint=I(1,index);%找到该边对应的另一个顶点%将该边对应的权值修改为最大，防止该边在下次循环中再次被选为最优边temp(index,anotherpoint)=100;temp(anotherpoint,index)=100;if(tag(anotherpoint)~=tag(index))%当两个点不属于一个连通集时，这两个点之间的边为最小生成树的边superedge(i,:)=[index,anotherpoint];%将其加入最小生成树的边集中i=i+1;%下标加1%下面的语句的作用是将两个连通分支变成一个连通分支，即tag值一样for j=1:len%以index的tag值为标准if((tag(j)==tag(anotherpoint))&(j~=anotherpoint))%遍搜tag数组，先将和anotherpoint tag值一样的点的tag值变为index的tag值tag(j)=tag(index);endendtag(anotherpoint)=tag(index);%将anotherpoint的tag值变为in dex的tag值endend%*************************结果显示模块**************************** ********s=0;for ii=1:len-1k=sprintf('最小生成树第%d条边：（%d,%d），权值为%d',ii,superedge(ii,1),superedge(ii,2),graph_adjacent(superedge(ii,1),superedge(ii,2)));%格式化字符串%disp(k);%显示%disp(' ');%空一行s=s+graph_adjacent(superedge(ii,1),superedge(ii,2)); %求最小生成树的代价end%显示最小生成树的代价disp('最小生成树的总代价为：')disp(s);。
模型建立与算法构造：基于Prim算法构造最小生成树
模型建立与算法构造：基于Prim算法构造最小生成树作者：李琳赵娟虎建勋来源：《科教导刊·电子版》2019年第12期摘要最小生成树有许多重要的应用。
例如：要在n个城市之间铺设光缆，主要目标是要使这 n 个城市的任意两个之间都可以通信，但铺设光缆的费用很高，且各个城市之间铺设光缆的费用不同，因此另一个目标是要使铺设光缆的总费用最低。
这就需要找到带权的最小生成树。
本文通过使用Matlab软件进行编程实现了用Prim算法构造最小生成树的分析运算。
本程序可以方便地处理层次分析法下较大的运算量，解决层次分析法的效率问题，提高计算机辅助决策的时效性。
其中建立了有效的基于Prim算法的数学模型并验证了模型的合理性和科学准确性。
利用MATLAB、EXCEL、SPSS13.0 for windows等软件，实现了高效、准确的研究。
关键词模型 atlab软件算法构造中图分类号：TP312 文献标识码：A1建立结构模型1.1最小生成树相关概念连通图：任意两个结点之间都有一个路径相连。
生成树（Spannirng Tree）：连通图的一个极小的连通子图，它含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。
最小生成树（Minimum Spannirng Tree）：连通图的最小代价的生成树（各边的权值之和最小）。
最小生成树即对于连通的带权图（连通网）G，其生成树也是带权的。
生成树T各边的权值总和称为该树的权，记作：这里：TE表示T的边集，w（u，v）表示边（u，v）的权。
权最小的生成樹称为G的最小生成树（Minimum SpannirngTree）。
最小生成树可简记为MST。
1.2 Prim算法实现Prim算法是一种贪心算法，将全部的顶点划分为2个集合，每次总在2个集合之间中找最小的一条边，局部最优最终达到全局最优，这正是贪心的思想。
在无向加权图中，n个顶点的最小生成树有n-1条边，这些边使得n个顶点之间可达，且总的代价最小。
最小生成树matlab代码
最小生成树matlab代码在Matlab中，最小生成树可以通过Kruskal算法和Prim算法来实现。
本文将分别介绍两种算法的代码实现，并对其进行详细解析。
Kruskal算法Kruskal算法是基于贪心算法的最小生成树算法。
其基本思想是将边按照权值从小到大进行排序，然后逐个加入到树中，直到树连通为止。
如果加入一条边使得形成环，则不加入该边。
定义一个函数Kruskal(weight,n)来实现Kruskal算法。
参数weight是一个n*n的矩阵，表示图的邻接矩阵；n表示图中节点的个数。
该函数的返回值为最小生成树的边集。
function edges=Kruskal(weight,n)%初始化[rows,cols,vals]=find(weight);edge_num=length(rows);%边数edges=zeros(n-1,2);%初始化，存放最小生成树的边%边按照权重从小到大排序[~,idx]=sort(vals);rows=rows(idx);cols=cols(idx);%初始化并查集par=1:n;rank=zeros(1,n);%依次加入边n_edge=0;%表示已加入的边数for i=1:edge_num%如果两个节点已经在同一连通块中，则不能加入当前边if FindPar(par,rows(i))==FindPar(par,cols(i))continue;end%将当前边加入到最小生成树中n_edge=n_edge+1;edges(n_edge,:)=[rows(i),cols(i)];%将两个节点合并Union(par,rank,rows(i),cols(i));%如果当前已经加入足够的边，则退出循环if n_edge==n-1break;endendFindPar函数和Union函数是实现并查集的两个函数，用于判断是否形成环以及将两个节点合并。
具体代码如下：%查找节点的祖先function par=FindPar(par,idx)if par(idx)==idxpar=idx;elsepar=FindPar(par,par(idx));end%将两个节点合并function Union(par,rank,x,y)x_par=FindPar(par,x);y_par=FindPar(par,y);if rank(x_par)>rank(y_par)par(y_par)=x_par;elsepar(x_par)=y_par;if rank(x_par)==rank(y_par)rank(y_par)=rank(y_par)+1;endendPrim算法Prim算法也是一种贪心算法，基本思想是从任意一个点开始，找到与该点相邻的最短边，然后将这个边连接的点加入到集合中，继续寻找与该集合相邻的最短边。
Matlab中避圈法求解最小生成树
end
end
P(2,y)=P(1,y);
elseif P(2,y)<P(1,y)
for l=(y+1):m
%准备工作
T=zeros(n); %最小生成树的加权邻接矩阵
WW=W;
for i=1:n
for j=1:n
if W(i,j)==inf WW(i,j)=0;
end
end
end
m=((nnz(WW))/2); %图的边线的数目
%编程工具Matlab；程序名称MST_k.m.
%这是一个通过避圈法求解连通带权图的最小生成树的程序.
n=input('请输入图的顶点数目:n= ')
W=input('请输入图的加权邻接矩阵:[W(1,1),..,W(1,n);..;W(n,1),..,W(n,n)]=')
%用W(i,i)="inf" 代替 "=0"
end
W(a,b)=inf;
else %如果条件|E|=|V|-1成立
MST=T;
input('这个图的最小生成树的加权邻接矩阵是:')
MST
break
end
Байду номын сангаас
end
if j<(n-1) %如果条件|E|<|V|-1成立
input('这个图没有最小生成树.')
end
j=0; %最小生成树的边线的数目
%主要步骤
for i=1:m %被选择边线的数目
最小生成树算法详解
最小生成树算法详解常见的最小生成树算法包括普里姆（Prim）算法和克鲁斯卡尔（Kruskal）算法。
下面将详细介绍这两种算法的原理和步骤。
普里姆算法的基本思想是从一个顶点出发，每次选择与当前生成树相连的权重最小的边，直到生成树包含所有的顶点。
具体步骤如下：1.初始化一个空的生成树和一个空的候选边集合。
2.随机选择一个起始顶点，将其加入生成树中，并将与该顶点相连的边加入候选边集合。
3.从候选边集合中选择权重最小的边，如果该边的另一个顶点不在生成树中，则将该顶点加入生成树，并将与该顶点相连的边加入候选边集合。
4.重复步骤3，直到生成树包含所有的顶点。
克鲁斯卡尔算法的基本思想是从所有边中选取权重最小的边，然后逐步扩展生成树，直到生成树包含所有的顶点。
具体步骤如下：1.初始化一个空的生成树和一个空的候选边集合。
2.将图中的所有边按权重从小到大排序，并加入候选边集合中。
3.从候选边集合中选择权重最小的边，如果该边的两个顶点不在同一个连通分量中，则将该边加入生成树，并将其两个顶点合并到同一个连通分量中。
4.重复步骤3，直到生成树包含所有的顶点。
普里姆算法和克鲁斯卡尔算法都能够求解最小生成树，它们的主要区别在于选择候选边的方式不同。
普里姆算法每次选择与当前生成树相连的权重最小的边，而克鲁斯卡尔算法每次选择整个图中权重最小的边。
因此，普里姆算法适用于稠密图，而克鲁斯卡尔算法适用于稀疏图。
总结起来，最小生成树算法是图论中的一种重要算法，用于求解连通图中的一棵权重最小的生成树。
普里姆算法和克鲁斯卡尔算法是常见的最小生成树算法，它们的主要区别在于选择候选边的方式不同。
这些算法的时间复杂度与图的边数有关，通常为O(ElogE)。
在实际应用中，可以根据具体问题选择适合的算法来求解最小生成树。
(图论)matlab模板程序
第一讲：图论模型程序一：可达矩阵算法%根据邻接矩阵A〔有向图〕求可达矩阵P〔有向图〕function P=dgraf<A>n=size<A,1>;P=A;for i=2:nP=P+A^i;endP<P~=0>=1; %将不为0的元素变为1P;程序二：无向图关联矩阵和邻接矩阵互换算法F表示所给出的图的相应矩阵W表示程序运行结束后的结果f=0表示把邻接矩阵转换为关联矩阵f=1表示把关联矩阵转换为邻接矩阵%无向图的关联矩阵和邻接矩阵的相互转换function W=incandadf<F,f>if f==0 %邻接矩阵转换为关联矩阵m=sum<sum<F>>/2; %计算图的边数n=size<F,1>;W=zeros<n,m>;k=1;for i=1:nfor j=i:nif F<i,j>~=0W<i,k>=1; %给边的始点赋值为1W<j,k>=1; %给边的终点赋值为1k=k+1;endendendelseif f==1 %关联矩阵转换为邻接矩阵m=size<F,2>;n=size<F,1>;W=zeros<n,n>;for i=1:ma=find<F<:,i>~=0>;W<a<1>,a<2>>=1; %存在边,则邻接矩阵的对应值为1 W<a<2>,a<1>>=1;endelsefprint<'Please imput the right value of f'>;W;程序三：有向图关联矩阵和邻接矩阵互换算法%有向图的关联矩阵和邻接矩阵的转换function W=mattransf<F,f>if f==0 %邻接矩阵转换为关联矩阵m=sum<sum<F>>;n=size<F,1>;W=zeros<n,m>;k=1;for i=1:nfor j=i:nif F<i,j>~=0 %由i发出的边,有向边的始点W<i,k>=1; %关联矩阵始点值为1W<j,k>=-1; %关联矩阵终点值为-1k=k+1;endendendelseif f==1 %关联矩阵转换为邻接矩阵m=size<F,2>;n=size<F,1>;W=zeros<n,n>;for i=1:ma=find<F<:,i>~=0>; %有向边的两个顶点if F<a<1>,i>==1W<a<1>,a<2>>=1; %有向边由a<1>指向a<2>elseW<a<2>,a<1>>=1; %有向边由a<2>指向a<1>endendelsefprint<'Please imput the right value of f'>;endW;第二讲：最短路问题程序0：最短距离矩阵W表示图的权值矩阵D表示图的最短距离矩阵%连通图中各项顶点间最短距离的计算function D=shortdf<W>%对于W<i,j>,若两顶点间存在弧,则为弧的权值,否则为inf；当i=j时W<i,j>=0 n=length<W>;m=1;while m<=nfor i=1:nfor j=1:nif D<i,j>>D<i,m>+D<m,j>D<i,j>+D<i,m>+D<m,j>; %距离进行更新 endendendm=m+1;endD;程序一：Dijkstra算法〔计算两点间的最短路〕function [l,z]=Dijkstra<W>n = size <W,1>;for i = 1 :nl<i>=W<1,i>;z<i>=0;endi=1;while i<=nfor j =1 :nif l<i>>l<j>+W<j,i>l<i>=l<j>+W<j,i>;z<i>=j-1;if j<ii=j-1;endendendi=i+1;end程序二：floyd算法〔计算任意两点间的最短距离〕function [d,r]=floyd<a>n=size<a,1>;d=a;for i=1:nfor j=1:nr<i,j>=j;endendr;for k=1:nfor i=1:nfor j=1:nif d<i,k>+d<k,j><d<i,j>d<i,j>=d<i,k>+d<k,j>; r<i,j>=r<i,k>;endendendend程序三：n2short.m 计算指定两点间的最短距离function [P u]=n2short<W,k1,k2>n=length<W>;U=W;m=1;while m<=nfor i=1:nfor j=1:nif U<i,j>>U<i,m>+U<m,j>U<i,j>=U<i,m>+U<m,j>;endendendm=m+1;endu=U<k1,k2>;P1=zeros<1,n>;k=1;P1<k>=k2;V=ones<1,n>*inf;kk=k2;while kk~=k1for i=1:nV<1,i>=U<k1,kk>-W<i,kk>;if V<1,i>==U<k1,i>P1<k+1>=i;kk=i;k=k+1;endendendk=1;wrow=find<P1~=0>;for j=length<wrow>:-1:1P<k>=P1<wrow<j>>;k=k+1;endP;程序四、n1short.m<计算某点到其它所有点的最短距离> function[Pm D]=n1short<W,k>n=size<W,1>;D=zeros<1,n>;for i=1:n[P d]=n2short<W,k,i>;Pm{i}=P;D<i>=d;end程序五：pass2short.m<计算经过某两点的最短距离> function [P d]=pass2short<W,k1,k2,t1,t2>[p1 d1]=n2short<W,k1,t1>;[p2 d2]=n2short<W,t1,t2>;[p3 d3]=n2short<W,t2,k2>;dt1=d1+d2+d3;[p4 d4]=n2short<W,k1,t2>;[p5 d5]=n2short<W,t2,t1>;[p6 d6]=n2short<W,t1,k2>;dt2=d4+d5+d6;if dt1<dt2d=dt1;P=[p1 p2<2:length<p2>> p3<2:length<p3>>]; elsed=dt1;p=[p4 p5<2:length<p5>> p6<2:length<p6>>]; endP;d;第三讲：最小生成树程序一：最小生成树的Kruskal算法function [T c]=krusf<d,flag>if nargin==1n=size<d,2>;m=sum<sum<d~=0>>/2;b=zeros<3,m>;k=1;for i=1:nfor j=<i+1>:nif d<i,j>~=0b<1,k>=i;b<2,k>=j;b<3,k>=d<i,j>;k=k+1;endendendelseb=d;endn=max<max<b<1:2,:>>>;m=size<b,2>;[B,i]=sortrows<b',3>;B=B';c=0;T=[];k=1;t=1:n;for i=1:mif t<B<1,i>>~=t<B<2,i>>T<1:2,k>=B<1:2,i>;c=c+B<3,i>;k=k+1;tmin=min<t<B<1,i>>,t<B<2,i>>>; tmax=max<t<B<1,i>>,t<B<2,i>>>; for j=1:nif t<j>==tmaxt<j>=tmin;endendendif k==nbreak;endendT;c;程序二：最小生成树的Prim算法function [T c]=Primf<a>l=length<a>;a<a==0>=inf;k=1:l;listV<k>=0;listV<1>=1;e=1;while <e<l>min=inf;for i=1:lif listV<i>==1for j=1:lif listV<j>==0 & min>a<i,j>min=a<i,j>;b=a<i,j>;s=i;d=j;endendendendlistV<d>=1;distance<e>=b;source<e>=s;destination<e>=d;e=e+1;endT=[source;destination];for g=1:e-1c<g>=a<T<1,g>,T<2,g>>;endc;第四讲：Euler图和Hamilton图程序一：Fleury算法〔在一个Euler图中找出Euler环游〕注：包括三个文件；fleuf1.m, edf.m, flecvexf.mfunction [T c]=fleuf1<d>%注：必须保证是Euler环游,否则输出T=0,c=0n=length<d>;b=d;b<b==inf>=0;b<b~=0>=1;m=0;a=sum<b>;eds=sum<a>/2;ed=zeros<2,eds>;vexs=zeros<1,eds+1>;matr=b;for i=1:nif mod<a<i>,2>==1m=m+1;endendif m~=0fprintf<'there is not exit Euler path.\n'>T=0;c=0;endif m==0vet=1;flag=0;t1=find<matr<vet,:>==1>;for ii=1:length<t1>ed<:,1>=[vet,t1<ii>];vexs<1,1>=vet;vexs<1,2>=t1<ii>;matr<vexs<1,2>,vexs<1,1>>=0;flagg=1;tem=1;while flagg[flagg ed]=edf<matr,eds,vexs,ed,tem>;tem=tem+1;if ed<1,eds>~=0 & ed<2,eds>~=0T=ed;T<2,eds>=1;c=0;for g=1:edsc=c+d<T<1,g>,T<2,g>>;endflagg=0;break;endendendendfunction[flag ed]=edf<matr,eds,vexs,ed,tem>flag=1;for i=2:eds[dvex f]=flecvexf<matr,i,vexs,eds,ed,tem>;if f==1flag=0;break;endif dvex~=0ed<:,i>=[vexs<1,i> dvex];vexs<1,i+1>=dvex;matr<vexs<1,i+1>,vexs<1,i>>=0;elsebreak;endendfunction [dvex f]=flecvexf<matr,i,vexs,eds,ed,temp> f=0;edd=find<matr<vexs<1,i>,:>==1>;dvex=0;dvex1=[];ded=[];if length<edd>==1dvex=edd;elsedd=1;dd1=0;kkk=0;for kk=1:length<edd>m1=find<vexs==edd<kk>>;if sum<m1>==0dvex1<dd>=edd<kk>;dd=dd+1;dd1=1;elsekkk=kkk+1;endendif kkk==length<edd>tem=vexs<1,i>*ones<1,kkk>;edd1=[tem;edd];for l1=1:kkklt=0;ddd=1;for l2=1:edsif edd1<1:2,l1>==ed<1:2,l2>lt=lt+1;endendif lt==0ded<ddd>=edd<l1>;ddd=ddd+1;endendendif temp<=length<dvex1>dvex=dvex1<temp>;elseif temp>length<dvex1> & temp<=length<ded>dvex=ded<temp>;elsef=1;endend程序二：Hamilton改良圈算法〔找出比较好的Hamilton路〕function [C d1]= hamiltonglf<v>%d表示权值矩阵%C表示算法最终找到的Hamilton圈.%v =[ 51 67;37 84;41 94;2 99;18 54;4 50;24 42;25 38;13 40;7 64;22 60;25 62;18 40;41 26];n=size<v,1>;subplot<1,2,1>hold on;plot <v<:,1>,v<:,2>,'*'>; %描点for i=1:nstr1='V';str2=num2str<i>;dot=[str1,str2];text<v<i,1>-1,v<i,2>-2,dot>; %给点命名endplot <v<:,1>,v<:,2>>;%连线plot<[v<n,1>,v<1,1>],[v<n,2>,v<1,2>]>;for i =1:nfor j=1:nd<i,j>=sqrt<<v<i,1>-v<j,1>>^2+<v<i,2>-v<j,2>>^2>;endendd2=0;for i=1:nif i<nd2=d2+d<i,i+1>;elsed2=d2+d<n,1>;endendtext<10,30,num2str<d2>>;n=size<d,2>;C=[linspace<1,n,n> 1];for nnn=1:20C1=C;if n>3for m=4:n+1for i=1:<m-3>for j=<i+2>:<m-1>if<d<C<i>,C<j>>+d<C<i+1>,C<j+1>><d<C<i>,C<i+1>>+d<C<j>,C<j+1>>>C1<1:i>=C<1:i>;for k=<i+1>:jC1<k>=C<j+i+1-k>;endC1<<j+1>:m>=C<<j+1>:m>;endendendendelseif n<=3if n<=2fprint<'It does not exist Hamilton circle.'>; elsefprint<'Any cirlce is the right answer.'>;endendC=C1;d1=0;for i=1:nd1=d1+d<C<i>,C<i+1>>;endd1;endsubplot<1,2,2>;hold on;plot <v<:,1>,v<:,2>,'*'>; %描点for i=1:nstr1='V';str2=num2str<i>;dot=[str1,str2];text<v<i,1>-1,v<i,2>-2,dot>; %给点命名endv2=[v;v<1,1>,v<1,2>];plot<v<C<:>,1>,v<C<:>,2>,'r'>;text<10,30,num2str<d1>>;第五讲：匹配问题与算法程序一：较大基础匹配算法function J=matgraf<W>n=size<W,1>;J=zeros<n,n>;while sum<sum<W>>~=0a=find<W~=0>;t1=mod<a<1>,n>;if t1==0t1=n;endif a<1>/n>floor<a<1>/n>t2=floor<a<1>/n>+1;elset2=floor<a<1>/n>;endJ<t1,t2>=1,J<t2,t1>=1;W<t1,:>=0;W<t2,:>=0;W<:,t1>=0;W<:,t2>=0;endJ;程序二：匈牙利算法〔完美匹配算法,包括三个文件fc01,fc02,fc03〕function [e,s]=fc01<a,flag>if nargin==1flag=0;endb=a;if flag==0cmax=max<max<b>'>;b=cmax-b;endm=size<b>;for i =1:m<1>b<i,:>=b<i,:>-min<b<i,:>>;endfor j=1:m<2>b<:,j>=b<:,j>-min<b<:,j>>;endd=<b==0>;[e,total]=fc02<d>;while total~=m<1>b=fc03<b,e>;d=<b==0>;[e,total]=fc02<d>;endinx=sub2ind<size<a>,e<:,1>,e<:,2>>;e=[e,a<inx>];s=sum<a<inx>>;function [e,total]=fc02<d>total=0;m=size<d>;e=zeros<m<1>,2>;t=sum<sum<d>'>;nump=sum<d'>;while t~=0[s,inp]=sort<nump>;inq=find<s>;ep=inp<inq<1>>;inp=find<d<ep,:>>;numq=sum<d<:,inp>>;[s,inq]=sort<numq>;eq=inp<inq<1>>;total=total+1;e<total,:>=[ep,eq];inp=find<d<:,eq>>;nump<inp>=nump<inp>-1;nump<ep>=0;t=t-sum<d<ep,:>>-sum<d<:,eq>>+1;d<ep,:>=0*d<ep,:>;d<:,eq>=0*d<:,eq>;endfunction b=fc03<b,e>m=size<b>;t=1;p=ones<m<1>,1>;q=zeros<m<1>,1>;inp=find<e<:,1>~=0>;p<e<inp,1>>=0;while t~=0tp=sum<p+q>;inp=find<p==1>;n=size<inp>;for i=1:n<1>inq=find<b<inp<i>,:>==0>;q<inq>=1;endinp=find<q==1>;n=size<inp>;for i=1:n<1>if all<e<:,2>-inp<i>>==0inq=find<<e<:,2>-inp<i>>==0>;p<e<inq>>=1;endendtq=sum<p+q>;t=tq-tp;endinp=find<p==1>;inq=find<q==0>;cmin=min<min<b<inp,inq>>'>;inq=find<q==1>;b<inp,:>=b<inp,:>-cmin;b<:,inq>=b<:,inq>+cmin;第六讲：最大流最小费用问题程序一：2F算法<Ford-Fulkerson算法>,求最大流%C=[0 5 4 3 0 0 0 0;0 0 0 0 5 3 0 0;0 0 0 0 0 3 2 0;0 0 0 0 0 0 2 0; %0 0 0 0 0 0 0 4;0 0 0 0 0 0 0 3;0 0 0 0 0 0 0 5;0 0 0 0 0 0 0 0 ] function [f wf]=fulkersonf<C,f1>%C表示容量%f1表示当前流量,默认为0%f表示最大流±íʾ×î´óÁ÷%wf表示最大流的流量n=length<C>;if nargin==1;f=zeros<n,n>;elsef=f1;endNo=zeros<1,n>;d=zeros<1,n>;while <1>No<1>=n+1;d<1>=Inf;while <1>pd=1;for <i=1:n>if <No<i>>for <j=1:n>if <No<j>==0 & f<i,j><C<i,j>>No<j>=i;d<j>=C<i,j>-f<i,j>;pd=0;if <d<j>>d<i>>d<j>=d<i>;endelseif <No<j>==0 & f<j,i>>0>No<j>=-i;d<j>=f<j,i>;pd=0;if <d<j>>d<i>>d<j>=d<i>;endendendendendif <No<n>|pd>break;endendif <pd>break;enddvt=d<n>;t=n;while <1>if<No<t>>0>f<No<t>,t>=f<No<t>,t>+dvt;elseif <No<t><0>f<No<t>,t>=f<No<t>,t>-dvt;endif <No<t>==1>for <i=1:n>No<i>=0;d<i>=0;endbreakendt=No<t>;endendwf=0;for <j=1:n>wf=wf+f<1,j>;endf;wf;程序二：Busacker-Gowan算法<求最大流最小费用>%C=[0 15 16 0 0;0 0 0 13 14;0 11 0 17 0;0 0 0 0 8;0 0 0 0 0] %b=[0 4 1 0 0;0 0 0 6 1;0 2 0 3 0;0 0 0 0 2;0 0 0 0 0]%function [f wf zwf]=BGf<C,b>%C表示弧容量矩阵%b表示弧上单位流量的费用%f表示最大流最小费用矩阵%wf最大流量%zwf表示最小费用n=size<C,2>;wf=0;wf0=inf;f=zeros<n,n>;while <1>a=ones<n,n>*inf;for <i=1:n>a<i,i>=0;endfor <i=1:n>for <j=1:n>if<C<i,j>>0 & f<i,j>==0>a<i,j>=b<i,j>;elseif <C<i,j>>0 & f<i,j>==C<i,j>>a<j,i>=-b<i,j>;elseif <C<i,j>>0>a<i,j>=b<i,j>;a<j,i>=-b<i,j>;endendendfor <i=2:n>p<i>=inf;s<i>=i;endfor <k=1:n>pd=1;for <i=2:n>for <j=1:n>if <p<i>>p<j>+a<j,i>>p<i>=p<j>+a<j,i>;s<i>=j;pd=0; endendendif <pd>break;endendif <p<n>==inf>break;enddvt=inf;t=n;while <1>if <a<s<t>,t>>0>dvtt=C<s<t>,t>-f<s<t>,t>;elseif <a<s<t>,t><0>dvtt=f<t,s<t>>;endif <dvt>dvtt>dvt=dvtt;endif <s<t>==1>break;endt=s<t>;endpd=0;if <wf+dvt>=wf0>dvt=wf0-wf;pd=1;endt=n;while <1>if <a<s<t>,t>>0>f<s<t>,t>=f<s<t>,t>+dvt; elseif <a<s<t>,t><0>f<<t>,s<t>>=f<t,s<t>>-dvt; endif <s<t>==1>break;endt=s<t>;endif <pd>break;endwf=0;for <j=1:n>wf=wf+f<1,j>;endendzwf=0;for <i=1:n>for <j=1:n>zwf=zwf+b<i,j>*f<i,j>;endendf;。
Matlab最小生成树
数学建模——Matlab中求解最小生成树关键词：Matlab、最小生成树、破圈法、避圈法、运筹学要求：选择一道编程题自己独立完成，必须自己编写源代码，不能从网上下载。
先编写算法的通用程序，然后以例子运行，论文内容包括程序代码、程序说明、例子运行结果，最终程序文件连同论文一起发至e-mail，便于老师运行程序是否正确。
编程使用C或MATLAB。
选择题目：编写实现生成树、最小生成树的程序（包括避圈法、破圈法）。
题目分析：本题要求编写实现生成树、最小生成树的程序，首先来了解一下关于关于生成树的概念：1、树的概念：树是无向图的特殊情况，即对于一个N个节点的无向图，其中只有N-1条边，且图中任意两点间有且只有一条路径，即图中不存在环，这样的图称为树。
2、生成树的概念：对于一个无向连通图G=(V,E)，其中V代表顶点，E代表边，对它做一次遍历，每个节点经过一次，那么图中的N个节点再加上遍历过程中经过的N-1条边所构成的子图就是图G的一个生成树。
3、最小生成树的概念：对于一个无向连通图G=(V,E),给它的每条边（u,v）赋一个权值w(u,v)。
若图G 的生成树不止一个，那么其中包含的N-1条边的权值之和的最小的生成树就是图G的最小生成树。
4、关于运筹学中最小生成树有2种不错的算法，即避圈法和破圈法，下面来看一下求解最小生成树的算法：先看一下图示法表示的最小生成树：<1>避圈法求解上面无向带权连通图的基本步骤是：每步从未选的边中选取边e，使它与已选边不构成圈，且e是未选边中的最小权边，直到选够n-1条边为止。
<2>破圈法基本思想如下:(1) 每次从图中选取任意一个圈, 然后去掉该圈中权值最大的边(如果存在多条相同权值的最大边，可以任意选择一条去掉即可) 使之不构成圈.(2) 重复上述过程. 直到图中不再含圈且所有顶点均包含在图中为止, 就构成最小生成树.它的算法图解如下：5、我们在用matlab程序求解最小生成树的时候需要用到无向图的邻接矩阵，首先来了解一下邻接矩阵的概念。
最小生成树matlab程序
function [Wt,Pp]=mintree(n,W)%求最小生成树，n为顶点个数，W是权值邻接矩阵，不相邻的用inf表示%Wt是最小生成树的权，Pp（：，1：2）表示最小生成树的两顶点%Pp(:，4)表示最小生成树的序号tmpa=find(W~=inf);[tmpb,tmpc]=find(W~=inf);w=W(tmpa);e=[tmpb,tmpc];[wa,wb]=sort(w);E=[e(wb,:),wa,wb];[nE,mE]=size(E);temp=find(E(:,1)-E(:,2));E=E(temp,:);P=E(1,:);k=length(E(:,1));while rank(E)>0temp1=max(E(1,2),E(1,1));temp2=min(E(1,2),E(1,1));for i=1:kif E(i,1)==temp1E(i,1)=temp2;endif E(i,2)==temp1E(i,2)=temp2;endenda=find(E(:,1)-E(:,2));E=E(a,:);if rank(E)>0P=[P;E(1,:)];k=length(E(:,1));endendWt=sum(P(:,3));Pp=[e(P(:,4),:),P(:,3:4)];for i=1:length(P(:,3))disp(['','e',num2str(P(i,4)),'',...'(v',num2str(P(i,1)),'','v',num2str(P(i,2)),')']);endaxis equal;%画最小生成树hold on[x,y]=cylinder(1,n);xm=min(x(1,:));ym=min(y(1,:));xx=max(x(1,:));yy=max(y(1,:));axis([xm-abs(xm)*,xx+abs(xx)*,ym-abs(ym)*,yy+abs(yy)*]); plot(x(1,:),y(1,:),'ko');for i=1:ntemp=['v',int2str(i)];text(x(1,i),y(1,i),temp);endfor i=1:nEplot(x(1,e(i,:)),y(1,e(i,:)),'b');endfor i=1:length(P(:,4))plot(x(1,Pp(i,1:2)),y(1,Pp(i,1:2)),'r');endtext,,['最小生成树的权为','',num2str(Wt)]);title('红色连线为最小生成树');axis off;hold off;调用此程序要先编写主程序。
最小生成树(MATLAB)
prim算法设置两个集合P和Q，其中P 用于存放G的最小生成树中的顶点，集合Q存放G的最小生成树中的边。
令集合P的初值为P={V1}（假设构造最小生成树时，从顶点V1出发），集合Q的初值为。
Prime算法的思想是，从所有p ∈P，v∈V-P的边中，选取具有最小权值的边pv,将顶点v加入集合P中，将边pv 加入集合Q中，如此不断重复，直到P=V时，最小生成树构造完毕，这时集合Q中包含了最小生成的所有边。
（找最小的权，不连成圈即可）•clc;clear;•M=1000;•a(1,2)=50; a(1,3)=60;•a(2,4)=65; a(2,5)=40;•a(3,4)=52;a(3,7)=45;•a(4,5)=50; a(4,6)=30;a(4,7)=42;•a(5,6)=70;•a=[a;zeros(2,7)];•a=a+a';a(find(a==0))=M;•result=[];p=1;tb=2:length(a);•while length(result)~=length(a)-1•temp=a(p,tb);temp=temp(:);•d=min(temp);•[jb,kb]=find(a(p,tb)==d);•j=p(jb(1));k=tb(kb(1));•result=[result,[j;k;d]];p=[p,k];tb(find(tb==k))=[];•end•result•例、一个乡有7个自然村，其间道路如图所示，要以村为中心建有线广播网络，如要求沿道路架设广播线，应如何架设？Kruskal算法每步从未选的边中选取边e，使它与已选边不构成圈，且e 是未选边中的最小权边，直到选够n-1条边为止。
•clc;clear;•M=1000;•a(1,2)=50; a(1,3)=60;•a(2,4)=65; a(2,5)=40;•a(3,4)=52;a(3,7)=45;•a(4,5)=50; a(4,6)=30;a(4,7)=42;•a(5,6)=70;•[i,j]=find((a~=0)&(a~=M));•b=a(find((a~=0)&(a~=M)));•data=[i';j';b'];index=data(1:2,:);•loop=max(size(a))-1;•result=[];•while length(result)<loop•temp=min(data(3,:));•flag=find(data(3,:)==temp);•flag=flag(1);•v1=data(1,flag);v2=data(2,flag);•if index(1,flag)~=index(2,flag)•result=[result,data(:,flag)];•end•if v1>v2•index(find(index==v1))=v2;•else•index(find(index==v2))=v1;•end•data(:,flag)=[];•index(:,flag)=[];•end•result中国邮递员问题中国邮递员问题也可以表示为：在一个有奇点的连通图中。
最小生成树两种算法详解
最⼩⽣成树两种算法详解最⼩⽣成树众所周知, 树是⼀种特殊的图, 是由n-1条边连通n个节点的图.如果在⼀个有n个节点的⽆向图中, 选择n-1条边, 将n个点连成⼀棵树, 那么这棵树就是这个图的⼀个⽣成树.如果保证树的边权和最⼩, 那么这棵树就是图的最⼩⽣成树.为了求⼀棵树的最⼩⽣成树, 有两种算法, ⼀种是选择点加⼊树的Prim算法, 另⼀种是选择边加⼊树的Kruskal算法.Prim算法这个算法的过程和Dijkstra类似, 但有所不同.⾸先选择任意⼀点作为树的第⼀个节点0, 枚举与它相连的所有点i, 将两点之间的边权记为这个点到⽣成树的距离b[i], 选择距离最近的点加⼊⽣成树, 然后枚举与之相邻的节点j, ⽤边权a[i,j]更新b[j], 使其等于min(b[j],a[i,j]), 这样再继续加⼊当前离⽣成树最近的点, 在更新它相邻的点, 以此类推, 直到所有点全部加⼊⽣成树. 这样, 便求出了最⼩⽣成树.关于正确性我⾃⼰的思路是这样的: 如果⽤Prim算法求出了⼀棵最⼩⽣成树, 将⼀条边u换成另⼀条更⼩的v, 就得到⼀棵边权和更⼩的⽣成树. ⾸先保证树连通, 所以去掉u和v, ⽣成树被分成两个连通块是⼀模⼀样的. 在当时连接u的时候, 已经决策完的⽣成树⼀定也和v相连, 这时v连接的节点⼀定会⽐u连接的节点更早加⼊, 所以⼀开始的假设不成⽴, 算法正确.具体代码实现#include<iostream>#include<cstring>#include<cstdio>using namespace std;int n,m,l,r,x,a[5005][5005]/*邻接矩阵*/,b[5005]/*点到⽣成树的最短边权*/,now/*当前加⼊的点*/,k=1/*⽣成树节点数*/,ans=0/*⽣成树总边权和*/;bool vsd[5005]={0};void update(int at){//⽤节点at更新其他点的b[]值for(int i=1;i<=n;i++) {b[i]=min(a[at][i],b[i]);}vsd[at]=true;return;}int find(){//寻找当前离⽣成树最近的点int ft=0;for(int i=1;i<=n;i++){if(!vsd[i]){//不在树中if(b[i]<=b[ft]){ft=i;}}}return ft;}int main(){cin>>n>>m;memset(a,0x3f,sizeof(a));for(int i=1;i<=n;i++){a[i][i]=0;}for(int i=1;i<=m;i++){cin>>l>>r>>x;a[l][r]=min(a[l][r],x);//防⽌有两个点之间出现边权不同的⼏条边a[r][l]=min(a[r][l],x);}memset(b,0x3f,sizeof(b));update(1);while(k<n){//加⼊n-1个点后返回(第⼀个点本来就在树中, ⽆需加⼊)now=find();//加⼊最近的点nowans+=b[now];//统计答案update(now);//更新其他点k++;//统计点数}cout<<ans<<endl;return 0;}Kruskal算法这个算法和Prim相反, 它是将边记为树上的边, 最终得到⼀棵最⼩⽣成树.将所有边按边权排序, 然后将它们从⼩到⼤讨论是否加⼊⽣成树. 如果该边的两个端点属于同⼀个连通块, 这时加⼊该边就会形成环, 不符合树的定义, 所以舍弃. 如果该边两个端点不属于同⼀个连通块, 那么连接该边, 将两个端点所在连通块连成⼀个.当共加⼊n-1条边的时候, 就得到了⼀棵最⼩⽣成树.对于查找两点是否在同⼀个连通块中的⽅法, 我们可以使⽤并查集来维护点之间的连通关系.正确性简易说明Kruskal相对来说更好理解, 因为从⼩到⼤排序后, 使⽤被舍弃的边连成环是⾮法的, 使⽤排在后⾯的合法的边替换已经选择的边, 得到的答案不是最优的. 所以Kruskal算法正确.代码实现#include<cstdio>#include<cstring>#include<iostream>#include<algorithm>using namespace std;int n,m,fa[10005],s,e,l,k=0,ans=0;struct side{int le,ri,len;//起点, 终点, 边权}a[200005];bool cmp(side x,side y){//结构体sort规则return(x.len<y.len);}int find(int x){//并查集寻找最⽼祖先if(fa[x]==x){//⾃⼰就是当前连通块最⽼祖先return x;}fa[x]=find(fa[x]);//⾃⼰祖先的最⽼祖先return fa[x];}int main(){cin>>n>>m;memset(a,0x3f,sizeof(a));for(int i=1;i<=m;i++){cin>>s>>e>>l;a[i].le=s;//结构体存储边a[i].ri=e;a[i].len=l;}sort(a+1,a+m+1,cmp);//按边权升序排列for(int i=1;i<=n;i++){fa[i]=i;//初始化并查集}int i=0;while((k<n-1/*加⼊了n-1个点跳出*/)&&(i<=m/*枚举完了所有的边跳出*/)){i++;int fa1=find(a[i].le),fa2=find(a[i].ri);//两个端点的最⽼祖先if(fa1!=fa2){//不在同⼀连通块ans+=a[i].len;//记录答案fa[fa1]=fa2;//连接连通块k++;//记录边数}}cout<<ans<<endl;return 0;}之前发的是笔记, 现在发的是实战总结。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
prim算法设置两个集合P和Q，其中P 用于存放G的最小生成树中的顶点，集合Q存放G的最小生成树中的边。
令集合P的初值为P={V1}（假设构造最小生成树时，从顶点V1出发），集合Q的初值为。
Prime算法的思想是，从所有p ∈P，v∈V-P的边中，选取具有最小权值的边pv,将顶点v加入集合P中，将边pv 加入集合Q中，如此不断重复，直到P=V时，最小生成树构造完毕，这时集合Q中包含了最小生成的所有边。
（找最小的权，不连成圈即可）•clc;clear;•M=1000;•a(1,2)=50; a(1,3)=60;•a(2,4)=65; a(2,5)=40;•a(3,4)=52;a(3,7)=45;•a(4,5)=50; a(4,6)=30;a(4,7)=42;•a(5,6)=70;•a=[a;zeros(2,7)];•a=a+a';a(find(a==0))=M;•result=[];p=1;tb=2:length(a);•while length(result)~=length(a)-1•temp=a(p,tb);temp=temp(:);•d=min(temp);•[jb,kb]=find(a(p,tb)==d);•j=p(jb(1));k=tb(kb(1));•result=[result,[j;k;d]];p=[p,k];tb(find(tb==k))=[];•end•result•例、一个乡有7个自然村，其间道路如图所示，要以村为中心建有线广播网络，如要求沿道路架设广播线，应如何架设？Kruskal算法每步从未选的边中选取边e，使它与已选边不构成圈，且e 是未选边中的最小权边，直到选够n-1条边为止。
•clc;clear;•M=1000;•a(1,2)=50; a(1,3)=60;•a(2,4)=65; a(2,5)=40;•a(3,4)=52;a(3,7)=45;•a(4,5)=50; a(4,6)=30;a(4,7)=42;•a(5,6)=70;•[i,j]=find((a~=0)&(a~=M));•b=a(find((a~=0)&(a~=M)));•data=[i';j';b'];index=data(1:2,:);•loop=max(size(a))-1;•result=[];•while length(result)<loop•temp=min(data(3,:));•flag=find(data(3,:)==temp);•flag=flag(1);•v1=data(1,flag);v2=data(2,flag);•if index(1,flag)~=index(2,flag)•result=[result,data(:,flag)];•end•if v1>v2•index(find(index==v1))=v2;•else•index(find(index==v2))=v1;•end•data(:,flag)=[];•index(:,flag)=[];•end•result中国邮递员问题中国邮递员问题也可以表示为：在一个有奇点的连通图中。
要求增加一些重复边，使得新的连通图不含有奇点，并且增加的重复边总权最小。
我们把增加重复边后不含奇点的新的连通图叫做邮递路线，而总权最小的邮递路线叫做最优邮递路线。
求图中所示的中国邮递员问题•Fleury算法（在一个Euler图中找出Euler环游）Fleury算法—算法步骤：（１）任选一个顶点v0，令道路w0=v0（２）假定道路w i=v0e1v1e2…e i v i已经选好，则从E\{e1,e2, …,e i}中选一条边e i+1，使：a）e i+1与v i相关联b）除非不能选择，否则一定要使e i+1不是G i=G[E-{e1,e2, …,e i}]的割边．（３）第（２）步不能进行时就停止．•注：包括三个文件；fleuf1.m, edf.m, flecvexf.m•function [T c]=fleuf1(d)•%注：必须保证是Euler环游，否则输出T=0,c=0•n=length(d);•b=d;•b(b==inf)=0;•b(b~=0)=1;•m=0;•a=sum(b);•eds=sum(a)/2;•ed=zeros(2,eds);•vexs=zeros(1,eds+1);•matr=b;•for i=1:n•if mod(a(i),2)==1•m=m+1;•end•end•if m~=0•fprintf('there is not exit Euler path.\n')•T=0;c=0;•end•if m==0•vet=1;•flag=0;•t1=find(matr(vet,:)==1);•for ii=1:length(t1)•ed(:,1)=[vet,t1(ii)];•vexs(1,1)=vet;vexs(1,2)=t1(ii);•matr(vexs(1,2),vexs(1,1))=0;•flagg=1;tem=1;•while flagg•[flagg ed]=edf(matr,eds,vexs,ed,tem); •tem=tem+1;•if ed(1,eds)~=0 & ed(2,eds)~=0•T=ed;•T(2,eds)=1;•c=0;•for g=1:eds•c=c+d(T(1,g),T(2,g)); •end•flagg=0;•break;•end•end•end•end•function[flag ed]=edf(matr,eds,vexs,ed,tem)•flag=1;•for i=2:eds•[dvex f]=flecvexf(matr,i,vexs,eds,ed,tem);•if f==1•flag=0;•break;•end•if dvex~=0•ed(:,i)=[vexs(1,i) dvex];•vexs(1,i+1)=dvex;•matr(vexs(1,i+1),vexs(1,i))=0;•else•break;•end•end•function [dvex f]=flecvexf(matr,i,vexs,eds,ed,temp) •f=0;•edd=find(matr(vexs(1,i),:)==1);•dvex=0;•dvex1=[];•ded=[];•if length(edd)==1•dvex=edd;•else•dd=1;dd1=0;kkk=0;•for kk=1:length(edd) •m1=find(vexs==edd(kk)); •if sum(m1)==0 •dvex1(dd)=edd(kk); •dd=dd+1; •dd1=1; •else •kkk=kkk+1; •end •end •if kkk==length(edd) •tem=vexs(1,i)*ones(1,kkk); •edd1=[tem;edd]; •for l1=1:kkk •lt=0;ddd=1; •for l2=1:eds •if edd1(1:2,l1)==ed(1:2,l2) •lt=lt+1; •end •end •if lt==0 •ded(ddd)=edd(l1); •ddd=ddd+1; •end •end •end •if temp<=length(dvex1) •dvex=dvex1(temp); •elseif temp>length(dvex1) & temp<=length(ded) •dvex=ded(temp); •else •f=1; •end •end旅行商问题的数学规划模型01(10) (.) s.t. 1,()1,d i j x ij ijd x ij ij i j Ax i V ij j Vx ji j V=∑∈=∈∑∈=∑∈设是与之间的距离，或表示连线，表示不连线.则有:min ; 每个点只有一条边出去； ,()j V ∈ 每个点只有一条边进入（除起点与终点外，各边不构成圈）或实例例 从北京（Pe ）乘飞机到东京(T)、纽约(N)、墨西哥城(M)、伦敦(L)、巴黎(Pa)，五城市做旅游，每城市恰去一次再回北京，应如何安排旅游线，使旅程最短？各城市之间的航线距离如下表：编写程序如下：clc,clear11,min ..1,1,,.1,1,,||1,2||2,{1,2,,}{0,1},,1,,,.n ij ij i j n ij j n ij i ij i j S ij d x s t x i n x j n x S S n S n x i j n i j ≠==∈====≤-≤≤-⊂∈=≠∑∑∑∑a(1,2)=56;a(1,3)=35;a(1,4)=21;a(1,5)=51;a(1,6)=60;a(2,3)=21;a(2,4)=57;a(2,5)=78;a(2,6)=70;a(3,4)=36;a(3,5)=68;a(3,6)=68;a(4,5)=51;a(4,6)=61;a(5,6)=13;a(6,:)=0;a=a+a';c1=[5 1:4 6];L=length(c1);flag=1;while flag>0flag=0;for m=1:L-3for n=m+2:L-1if a(c1(m),c1(n))+a(c1(m+1),c1(n+1))<a(c1(m),c1(m+1))+a(c1(n),c1(n+1)) flag=1;c1(m+1:n)=c1(n:-1:m+1);endendendendsum1=0;for i=1:L-1sum1=sum1+a(c1(i),c1(i+1));endcircle=c1;sum=sum1;c1=[5 6 1:4];%改变初始圈，该算法的最后一个顶点不动flag=1;while flag>0flag=0;for m=1:L-3for n=m+2:L-1if a(c1(m),c1(n))+a(c1(m+1),c1(n+1))<...a(c1(m),c1(m+1))+a(c1(n),c1(n+1))flag=1;c1(m+1:n)=c1(n:-1:m+1);endendendendsum1=0;for i=1:L-1sum1=sum1+a(c1(i),c1(i+1));endif sum1<sumsum=sum1;circle=c1; endcircle,sum。