好久， 没写blog了，今天，多写点。
上节说到那里了，是不是说图的遍历，这节，我们来通过图的具体的应用了。
首先，看看最小生成树的应用了。 什么是最小生成树了？
由生成树的定义可知，无向连通图的生成树不是唯一的，对连通图的不同遍历就得到不同的生成树。图 b 所示是图 (a)所示的无向连通图的部分生成树。
所谓最小生成树是 如果是一个无向连通网， 那么它的所有生成树中必有一棵边的权值总和最小的生成树，我们称这棵生成树为最小代价生成树(Minimum Cost Spanning Tree).
许多应用问题都是一个求无向连通网的最小生成树问题。例如，要在 n个城市之间铺设光缆， 铺设光缆的费用很高， 并且各个城市之间铺设光缆的费用不同。一个目标是要使这 n个城市的任意两个之间都可以直接或间接通信， 另一个目标是要使铺设光缆的总费用最低。如果把 n个城市看作是图的 n个顶点，两个城市之间铺设的光缆看作是两个顶点之间的边， 这实际上就是求一个无向连通网的最小生成树问题。
由最小生成树的定义可知， 构造有 n个顶点的无向连通网的最小生成树必须满足以下三个条件：
（1）构造的最小生成树必须包括 n个顶点；
（2）构造的最小生成树有且仅有 n-1条边；
（3）构造的最小生成树中不存在回路。
构造最小生成树的方法有许多种，典型的方法有两种，一种是普里姆(Prim)算法，一种是克鲁斯卡尔(Kruskal)算法。
一普里姆(Prim)算法
假设 G=（V，E）为一无向连通网，其中，V 为网中顶点的集合，E 为网中边的集合。设置两个新的集合 U 和 T，其中，U 为 G 的最小生成树的顶点的集合，T 为 G 的最小生成树的边的集合。普里姆算法的思想是：令集合 U 的初值为 U={u1}（假设构造最小生成树时从顶点 u1开始） ，集合 T 的初值为 T={}。从所有的顶点 u∈U 和顶点 v∈V-U 的带权边中选出具有最小权值的边（u,v） ，将顶点 v 加入集合 U 中，将边（u,v）加入集合 T 中。如此不断地重复直到 U=V 时，最小生成树构造完毕。此时，集合 U 中存放着最小生成树的所有顶点，集合 T中存放着最小生成树的所有边。
以下图(a)为例，说明用普里姆算法构造图的无向连通网的最小生成树的过程。
为了分析问题的方便,无向连通网如图(a)所示。 初始时， 算法的集合 U={A}， 集合 V-U={B,C,D,E}， 集合 T={}，如图(b)所示。在所有 u 为集合 U 中顶点、v 为集合 V-U 中顶点的边(u,v)中寻找具有最小权值的边，寻找到的边是(A,D)，权值为 20，把顶点 B 加入到集合U 中， 把边(A,D)加入到集合 T 中， 如图 (c)所示。 在所有 u为集合 U 中顶点、v 为集合 V-U 中顶点的边(u,v)中寻找具有最小权值的边， 寻找到的边是(D,E)， 权值为 10，把顶点 E 加入到集合 U 中，把边(D,E)加入到集合 T 中，如图(d)所示。随后依次从集合 V-U 中加入到集合 U 中的顶点为 B、C，依次加入到集合T中的边为(A,B)（权值为 60） 、(E,C) （权值为 70） ，分别如图 (e)、(f)所示。最后得到的图(f)所示就是原无向连通网的最小生成树。
本书以无向网的邻接矩阵类 NetAdjMatrix<T>来实现普里姆算法。NetAdjMatrix<T>类的成员字段与无向图邻接矩阵类 GraphAdjMatrix<T>的成员字段一样，不同的是，当两个顶点间有边相连接时，matirx 数组中相应元素的值是边的权值，而不是 1
无向网邻接矩阵类 NetAdjMatrix<T>源代码的实现如下所示：
public class NetAdjMatrix<T> : IGraph<T>//继承与图形的接口
{
private Node<T>[] nodes; //顶点数组 存取相应的结点的 泛型数组
private int numEdges; //边的数目 上图边数字是6
private int[,] matrix; //邻接矩阵数组 存取相应的互相的权值
//构造器 进行数据的初始化 边的数目是0
public NetAdjMatrix (int n)
{
nodes = new Node<T>[n];
matrix = new int[n,n];
numEdges = 0;
}
//获取索引为index的顶点的信息 算法的时间复杂度是O(1)
public Node<T> GetNode(int index)
{
return nodes[index];
}
//设置索引为index的顶点的信息 算法的时间复杂度是O(1)
public void SetNode(int index, Node<T> v)
{
nodes[index] = v;
}
//边的数目属性 可读可写的属性
public int NumEdges
{
get
{
return numEdges;
}
set
{
numEdges = value;
}
}
//获取matrix[index1, index2]的值 算法的时间复杂度是O（1）
public int GetMatrix(int index1, int index2)
{
return matrix[index1, index2];
}
//设置matrix[index1, index2]的值 算法的复杂度是O(1)
public void SetMatrix(int index1, int index2, int v)
{
matrix[index1, index2] = v;
}
//获取顶点的数目 算法的时间的复杂度是O(1)
public int GetNumOfVertex()
{
return nodes.Length;
}
//获取边的数目 算法的时间的复杂度是O(1)
public int GetNumOfEdge()
{
return numEdges;
}
//v是否是无向网的顶点
//如果包含这个顶点 返回为真，否则返回为假。
//由于这是一层循环，算法的复杂度是O(n)
public bool IsNode(Node<T> v)
{
//遍历顶点数组
foreach (Node<T> nd in nodes)
{
//如果顶点nd与v相等，则v是图的顶点，返回true
if (v.Equals(nd))
{
return true;
}
}
return false;
}
//获得顶点v在顶点数组中的索引
// 如果相等，返回相应的索引。
//由于是一层循环，时间的复杂度是O(n)
public int GetIndex(Node<T> v)
{
int i = -1;
//遍历顶点数组
for (i = 0; i < nodes.Length; ++i)
{
//如果顶点nd与v相等，则v是图的顶点，返回索引值
if (nodes[i].Equals(v))
{
return i;
}
}
return i;
}
//在顶点v1、v2之间添加权值为v的边
//添加相应的权值的v的边， 这是一个对称矩阵。
public void SetEdge(Node<T> v1, Node<T> v2, int v)
{
//v1或v2不是无向网的顶点
if (!IsNode(v1) || !IsNode(v2))
{
Console.WriteLine("Node is not belong to Graph!");
return;
}
//矩阵是对称矩阵
matrix[GetIndex(v1), GetIndex(v2)] = v;
matrix[GetIndex(v2), GetIndex(v1)] = v;
++numEdges;
}
//删除v1和v2之间的边
// 删除对称矩阵。
public void DelEdge(Node<T> v1, Node<T> v2)
{
//v1或v2不是无向网的顶点
if (!IsNode(v1) || !IsNode(v2))
{
Console.WriteLine("Node is not belong to Graph!");
return;
}
//v1和v2之间存在边
if (matrix[GetIndex(v1), GetIndex(v2)] != int.MaxValue)
{
//矩阵是对称矩阵
matrix[GetIndex(v1), GetIndex(v2)] = int.MaxValue;
matrix[GetIndex(v2), GetIndex(v1)] = int.MaxValue;
--numEdges;
}
}
//判断v1和v2之间是否存在边
//判断相应 不是 最大值 返回为真 否则 为假 算法的时间复杂度O(1)
public bool IsEdge(Node<T> v1, Node<T> v2)
{
//v1或v2不是无向网的顶点
if (!IsNode(v1) || !IsNode(v2))
{
Console.WriteLine("Node is not belong to Graph!");
return false;
}
//v1和v2之间存在边
if (matrix[GetIndex(v1), GetIndex(v2)] != int.MaxValue)
{
return true;
}
Else //v1和v2之间不存在边
{
return false;
}
}
}
具体如图所示：
为实现普里姆算法， 需要设置两个辅助一维数组 lowcost和 closevex， lowcost用来保存集合 V-U 中各顶点与集合 U 中各顶点构成的边中具有最小权值的边的权值；closevex 用来保存依附于该边的在集合 U 中的顶点。假设初始状态时，U={u1}（u1为出发的顶点） ，这时有 lowcost[0]=0，它表示顶点 u1已加入集合 U中。数组 lowcost 元素的值是顶点 u1 到其他顶点所构成的直接边的权值。然后不断选取权值最小的边(ui,uk)(ui∈U,uk∈V-U)，每选取一条边，就将 lowcost[k]置为 0，表示顶点 uk 已加入集合 U 中。由于顶点 uk 从集合 V-U 进入集合 U 后，这两个集合的内容发生了变化， 就需要依据具体情况更新数组lowcost和closevex中部分元素的值。把普里姆算法 PrimNetAdjMatrix<T>类的成员方法，实现的源代码如下：
public int[] Prim()
{
int[] lowcost = new int[nodes.Length]; //权值数组 保存权值的数组
int[] closevex = new int[nodes.Length]; //顶点数组 保存 相应各个顶点的数组
int mincost = int.MaxValue; //最小权值 默认是 int的最大值 表示无穷大
//辅助数组初始化 对摸个 权值数组赋值 保存 最小值
for (int i = 1; i < nodes.Length; ++i)
{
lowcost[i] = matrix[0, i];
closevex[i] = 0;
}
//某个顶点加入集合U
lowcost[0] = 0;
closevex[0] = 0;
//判断最小的权值通过的顶点的循环就此开始
for(int i=0; i<nodes.Length; ++i)
{
int k = 1;
int j = 1;
//选取权值最小的边和相应的顶点
while(j < nodes.Length)
{
if (lowcost[j] < mincost && lowcost[j] != 0)
{
k = j;
}
++j;
}
//新顶点加入集合U
lowcost[k] = 0;
//重新计算该顶点到其余顶点的边的权值
for (j = 1; j < nodes.Length; ++j)
{
if (matrix[k, j] < lowcost[j])
{
lowcost[j] = matrix[k, j];
closevex[j] = k;
}
}
}
return closevex;
}
//我们明显的看出来，由于用到了双重循环，其算法的时间的复杂度是O(n^2)具体实现，如图所示：
在普里姆算法中，第一个for循环的执行次数为n-1，第二个for循环中又包括了一个while循环和一个for循环，执行次数为 2(n-1)2，所以普里姆算法的时间复杂度为O(n2)。
这节，我们队图的引用做了一个抛砖引玉的介绍，主要是普利姆算法，解决 最小生成树问题。下节，我们介绍一下克鲁斯卡尔算法解决最小生成树的问题，和其他的应用。对图做一个总结等等。
扫一扫
1047
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
