当前位置:坤哥网-gooditblog-算法系列15天速成——第十五天 图【下】(大结局)

算法系列15天速成——第十五天 图【下】(大结局)

2011/12/26 2:06:00 gooditblog阅读(176) 评论(12)

 

    今天是大结局,说下“图”的最后一点东西,“最小生成树“和”最短路径“。

 

一: 最小生成树

1. 概念

    首先看如下图,不知道大家能总结点什么。

    对于一个连通图G,如果其全部顶点和一部分边构成一个子图G1,当G1满足:

       ① 刚好将图中所有顶点连通。②顶点不存在回路。则称G1就是G的“生成树”。

           其实一句话总结就是:生成树是将原图的全部顶点以最小的边连通的子图,这不,如下的连通图可以得到下面的两个生成树。

       ② 对于一个带权的连通图,当生成的树不同,各边上的权值总和也不同,如果某个生成树的权值最小,则它就是“最小生成树”。

     

2. 场景

      实际应用中“最小生成树”还是蛮有实际价值的,教科书上都有这么一句话,若用图来表示一个交通系统,每一个顶点代表一个城市,

  边代表两个城市之间的距离,当有n个城市时,可能会有n(n-1)/2条边,那么怎么选择(n-1)条边来使城市之间的总距离最小,其实它

  的抽象模型就是求“最小生成树”的问题。

 

3. prim算法

    当然如何求“最小生成树”问题,前人都已经给我们总结好了,我们只要照葫芦画瓢就是了,

    第一步:我们建立集合“V,U",将图中的所有顶点全部灌到V集合中,U集合初始为空。

    第二步: 我们将V1放入U集合中并将V1顶点标记为已访问。此时:U(V1)。

    第三步: 我们寻找V1的邻接点(V2,V3,V5),权值中发现(V1,V2)之间的权值最小,此时我们将V2放入U集合中并标记V2为已访问,

                此时为U(V1,V2)。

    第四步: 我们找U集合中的V1和V2的邻接边,一阵痉挛后,发现(V1,V5)的权值最小,此时将V5加入到U集合并标记为已访问,此时

                 U的集合元素为(V1,V2,V5)。

    第五步:此时我们以(V1,V2,V5)为基准向四周寻找最小权值的邻接边,发现(V5,V4)的权值最小,此时将V4加入到U集合并标记

                 为已访问,此时U的集合元素为(V1,V2,V5,V4)。

    第六步: 跟第五步形式一样,找到了(V1,V3)的权值最小,将V3加入到U集合中并标记为已访问,最终U的元素为(V1,V2,V5,V4,V3),

                最终发现顶点全部被访问,最小生成树就此诞生。

 1 #region prim算法获取最小生成树
2 /// <summary>
3 /// prim算法获取最小生成树
4 /// </summary>
5 /// <param name="graph"></param>
6 public void Prim(MatrixGraph graph, out int sum)
7 {
8 //已访问过的标志
9 int used = 0;
10
11 //非邻接顶点标志
12 int noadj = -1;
13
14 //定义一个输出总权值的变量
15 sum = 0;
16
17 //临时数组,用于保存邻接点的权值
18 int[] weight = new int[graph.vertexNum];
19
20 //临时数组,用于保存顶点信息
21 int[] tempvertex = new int[graph.vertexNum];
22
23 //取出邻接矩阵的第一行数据,也就是取出第一个顶点并将权和边信息保存于临时数据中
24 for (int i = 1; i < graph.vertexNum; i++)
25 {
26 //保存于邻接点之间的权值
27 weight[i] = graph.edges[0, i];
28
29 //等于0则说明V1与该邻接点没有边
30 if (weight[i] == short.MaxValue)
31 tempvertex[i] = noadj;
32 else
33 tempvertex[i] = int.Parse(graph.vertex[0]);
34 }
35
36 //从集合V中取出V1节点,只需要将此节点设置为已访问过,weight为0集合
37 var index = tempvertex[0] = used;
38 var min = weight[0] = short.MaxValue;
39
40 //在V的邻接点中找权值最小的节点
41 for (int i = 1; i < graph.vertexNum; i++)
42 {
43 index = i;
44 min = short.MaxValue;
45
46 for (int j = 1; j < graph.vertexNum; j++)
47 {
48 //用于找出当前节点的邻接点中权值最小的未访问点
49 if (weight[j] < min && tempvertex[j] != 0)
50 {
51 min = weight[j];
52 index = j;
53 }
54 }
55 //累加权值
56 sum += min;
57
58 Console.Write("({0},{1}) ", tempvertex[index], graph.vertex[index]);
59
60 //将取得的最小节点标识为已访问
61 weight[index] = short.MaxValue;
62 tempvertex[index] = 0;
63
64 //从最新的节点出发,将此节点的weight比较赋值
65 for (int j = 0; j < graph.vertexNum; j++)
66 {
67 //已当前节点为出发点,重新选择最小边
68 if (graph.edges[index, j] < weight[j] && tempvertex[j] != used)
69 {
70 weight[j] = graph.edges[index, j];
71
72 //这里做的目的将较短的边覆盖点上一个节点的邻接点中的较长的边
73 tempvertex[j] = int.Parse(graph.vertex[index]);
74 }
75 }
76 }
77 }
78 #endregion


二: 最短路径

1.   概念

        求最短路径问题其实也是非常有实用价值的,映射到交通系统图中,就是求两个城市间的最短路径问题,还是看这张图,我们可以很容易的看出比如

     V1到图中各顶点的最短路径。

      ① V1  ->  V2              直达,     权为2。

      ② V1  ->  V3              直达        权为3。

      ③ V1->V5->V4           中转       权为3+2=5。

      ④ V1  ->  V5               直达      权为3。

 

2.  Dijkstra算法

      我们的学习需要站在巨人的肩膀上,那么对于现实中非常复杂的问题,我们肯定不能用肉眼看出来,而是根据一定的算法推导出来的。

  Dijkstra思想遵循 “走一步,看一步”的原则。

     第一步: 我们需要一个集合U,然后将V1放入U集合中,既然走了一步,我们就要看一步,就是比较一下V1的邻接点(V2,V3,V5),

                 发现(V1,V2)的权值最小,此时我们将V2放入U集合中,表示我们已经找到了V1到V2的最短路径。

     第二步:然后将V2做中间点,继续向前寻找权值最小的邻接点,发现只有V4可以连通,此时修改V4的权值为(V1,V2)+(V2,V4)=6。

                此时我们就要看一步,发现V1到(V3,V4,V5)中权值最小的是(V1,V5),此时将V5放入U集合中,表示我们已经找到了

                V1到V5的最短路径。

     第三步:然后将V5做中间点,继续向前寻找权值最小的邻接点,发现能连通的有V3,V4,当我们正想修该V3的权值时发现(V1,V3)的权值

                小于(V1->V5->V3),此时我们就不修改,将V3放入U集合中,最后我们找到了V1到V3的最短路径。

     第四步:因为V5还没有走完,所以继续用V5做中间点,此时只能连通(V5,V4),当要修改权值的时候,发现原来的V4权值为(V1,V2)+(V2,V4),而

                现在的权值为5,小于先前的6,此时更改原先的权值变为5,将V4放入集合中,最后我们找到了V1到V4的最短路径。

 

 1 #region dijkstra求出最短路径
2 /// <summary>
3 /// dijkstra求出最短路径
4 /// </summary>
5 /// <param name="g"></param>
6 public void Dijkstra(MatrixGraph g)
7 {
8 int[] weight = new int[g.vertexNum];
9
10 int[] path = new int[g.vertexNum];
11
12 int[] tempvertex = new int[g.vertexNum];
13
14 Console.WriteLine("\n请输入源点的编号:");
15
16 //让用户输入要遍历的起始点
17 int vertex = int.Parse(Console.ReadLine()) - 1;
18
19 for (int i = 0; i < g.vertexNum; i++)
20 {
21 //初始赋权值
22 weight[i] = g.edges[vertex, i];
23
24 if (weight[i] < short.MaxValue && weight[i] > 0)
25 path[i] = vertex;
26
27 tempvertex[i] = 0;
28 }
29
30 tempvertex[vertex] = 1;
31 weight[vertex] = 0;
32
33 for (int i = 0; i < g.vertexNum; i++)
34 {
35 int min = short.MaxValue;
36
37 int index = vertex;
38
39 for (int j = 0; j < g.vertexNum; j++)
40 {
41 //顶点的权值中找出最小的
42 if (tempvertex[j] == 0 && weight[j] < min)
43 {
44 min = weight[j];
45 index = j;
46 }
47 }
48
49 tempvertex[index] = 1;
50
51 //以当前的index作为中间点,找出最小的权值
52 for (int j = 0; j < g.vertexNum; j++)
53 {
54 if (tempvertex[j] == 0 && weight[index] + g.edges[index, j] < weight[j])
55 {
56 weight[j] = weight[index] + g.edges[index, j];
57 path[j] = index;
58 }
59 }
60 }
61
62 Console.WriteLine("\n顶点{0}到各顶点的最短路径为:(终点 < 源点) " + g.vertex[vertex]);
63
64 //最后输出
65 for (int i = 0; i < g.vertexNum; i++)
66 {
67 if (tempvertex[i] == 1)
68 {
69 var index = i;
70
71 while (index != vertex)
72 {
73 var j = index;
74 Console.Write("{0} < ", g.vertex[index]);
75 index = path[index];
76 }
77 Console.WriteLine("{0}\n", g.vertex[index]);
78 }
79 else
80 {
81 Console.WriteLine("{0} <- {1}: 无路径\n", g.vertex[i], g.vertex[vertex]);
82 }
83 }
84 }
85 #endregion



最后上一下总的运行代码

View Code
  1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5
6 namespace MatrixGraph
7 {
8 public class Program
9 {
10 static void Main(string[] args)
11 {
12 MatrixGraphManager manager = new MatrixGraphManager();
13
14 //创建图
15 MatrixGraph graph = manager.CreateMatrixGraph();
16
17 manager.OutMatrix(graph);
18
19 int sum = 0;
20
21 manager.Prim(graph, out sum);
22
23 Console.WriteLine("\n最小生成树的权值为:" + sum);
24
25 manager.Dijkstra(graph);
26
27 //Console.Write("广度递归:\t");
28
29 //manager.BFSTraverse(graph);
30
31 //Console.Write("\n深度递归:\t");
32
33 //manager.DFSTraverse(graph);
34
35 Console.ReadLine();
36
37 }
38 }
39
40 #region 邻接矩阵的结构图
41 /// <summary>
42 /// 邻接矩阵的结构图
43 /// </summary>
44 public class MatrixGraph
45 {
46 //保存顶点信息
47 public string[] vertex;
48
49 //保存边信息
50 public int[,] edges;
51
52 //深搜和广搜的遍历标志
53 public bool[] isTrav;
54
55 //顶点数量
56 public int vertexNum;
57
58 //边数量
59 public int edgeNum;
60
61 //图类型
62 public int graphType;
63
64 /// <summary>
65 /// 存储容量的初始化
66 /// </summary>
67 /// <param name="vertexNum"></param>
68 /// <param name="edgeNum"></param>
69 /// <param name="graphType"></param>
70 public MatrixGraph(int vertexNum, int edgeNum, int graphType)
71 {
72 this.vertexNum = vertexNum;
73 this.edgeNum = edgeNum;
74 this.graphType = graphType;
75
76 vertex = new string[vertexNum];
77 edges = new int[vertexNum, vertexNum];
78 isTrav = new bool[vertexNum];
79 }
80
81 }
82 #endregion
83
84 /// <summary>
85 /// 图的操作类
86 /// </summary>
87 public class MatrixGraphManager
88 {
89 #region 图的创建
90 /// <summary>
91 /// 图的创建
92 /// </summary>
93 /// <param name="g"></param>
94 public MatrixGraph CreateMatrixGraph()
95 {
96 Console.WriteLine("请输入创建图的顶点个数,边个数,是否为无向图(0,1来表示),已逗号隔开。");
97
98 var initData = Console.ReadLine().Split(',').Select(i => int.Parse(i)).ToList();
99
100 MatrixGraph graph = new MatrixGraph(initData[0], initData[1], initData[2]);
101
102 //我们默认“正无穷大为没有边”
103 for (int i = 0; i < graph.vertexNum; i++)
104 {
105 for (int j = 0; j < graph.vertexNum; j++)
106 {
107 graph.edges[i, j] = short.MaxValue;
108 }
109 }
110
111 Console.WriteLine("请输入各顶点信息:");
112
113 for (int i = 0; i < graph.vertexNum; i++)
114 {
115 Console.Write("\n第" + (i + 1) + "个顶点为:");
116
117 var single = Console.ReadLine();
118
119 //顶点信息加入集合中
120 graph.vertex[i] = single;
121 }
122
123 Console.WriteLine("\n请输入构成两个顶点的边和权值,以逗号隔开。\n");
124
125 for (int i = 0; i < graph.edgeNum; i++)
126 {
127 Console.Write("" + (i + 1) + "条边:\t");
128
129 initData = Console.ReadLine().Split(',').Select(j => int.Parse(j)).ToList();
130
131 int start = initData[0];
132 int end = initData[1];
133 int weight = initData[2];
134
135 //给矩阵指定坐标位置赋值
136 graph.edges[start - 1, end - 1] = weight;
137
138 //如果是无向图,则数据呈“二,四”象限对称
139 if (graph.graphType == 1)
140 {
141 graph.edges[end - 1, start - 1] = weight;
142 }
143 }
144
145 return graph;
146 }
147 #endregion
148
149 #region 输出矩阵数据
150 /// <summary>
151 /// 输出矩阵数据
152 /// </summary>
153 /// <param name="graph"></param>
154 public void OutMatrix(MatrixGraph graph)
155 {
156 for (int i = 0; i < graph.vertexNum; i++)
157 {
158 for (int j = 0; j < graph.vertexNum; j++)
159 {
160 if (graph.edges[i, j] == short.MaxValue)
161 Console.Write("∽\t");
162 else
163 Console.Write(graph.edges[i, j] + "\t");
164 }
165 //换行
166 Console.WriteLine();
167 }
168 }
169 #endregion
170
171 #region 广度优先
172 /// <summary>
173 /// 广度优先
174 /// </summary>
175 /// <param name="graph"></param>
176 public void BFSTraverse(MatrixGraph graph)
177 {
178 //访问标记默认初始化
179 for (int i = 0; i < graph.vertexNum; i++)
180 {
181 graph.isTrav[i] = false;
182 }
183
184 //遍历每个顶点
185 for (int i = 0; i < graph.vertexNum; i++)
186 {
187 //广度遍历未访问过的顶点
188 if (!graph.isTrav[i])
189 {
190 BFSM(ref graph, i);
191 }
192 }
193 }
194
195 /// <summary>
196 /// 广度遍历具体算法
197 /// </summary>
198 /// <param name="graph"></param>
199 public void BFSM(ref MatrixGraph graph, int vertex)
200 {
201 //这里就用系统的队列
202 Queue<int> queue = new Queue<int>();
203
204 //先把顶点入队
205 queue.Enqueue(vertex);
206
207 //标记此顶点已经被访问
208 graph.isTrav[vertex] = true;
209
210 //输出顶点
211 Console.Write(" ->" + graph.vertex[vertex]);
212
213 //广度遍历顶点的邻接点
214 while (queue.Count != 0)
215 {
216 var temp = queue.Dequeue();
217
218 //遍历矩阵的横坐标
219 for (int i = 0; i < graph.vertexNum; i++)
220 {
221 if (!graph.isTrav[i] && graph.edges[temp, i] != 0)
222 {
223 graph.isTrav[i] = true;
224
225 queue.Enqueue(i);
226
227 //输出未被访问的顶点
228 Console.Write(" ->" + graph.vertex[i]);
229 }
230 }
231 }
232 }
233 #endregion
234
235 #region 深度优先
236 /// <summary>
237 /// 深度优先
238 /// </summary>
239 /// <param name="graph"></param>
240 public void DFSTraverse(MatrixGraph graph)
241 {
242 //访问标记默认初始化
243 for (int i = 0; i < graph.vertexNum; i++)
244 {
245 graph.isTrav[i] = false;
246 }
247
248 //遍历每个顶点
249 for (int i = 0; i < graph.vertexNum; i++)
250 {
251 //广度遍历未访问过的顶点
252 if (!graph.isTrav[i])
253 {
254 DFSM(ref graph, i);
255 }
256 }
257 }
258
259 #region 深度递归的具体算法
260 /// <summary>
261 /// 深度递归的具体算法
262 /// </summary>
263 /// <param name="graph"></param>
264 /// <param name="vertex"></param>
265 public void DFSM(ref MatrixGraph graph, int vertex)
266 {
267 Console.Write("->" + graph.vertex[vertex]);
268
269 //标记为已访问
270 graph.isTrav[vertex] = true;
271
272 //要遍历的六个点
273 for (int i = 0; i < graph.vertexNum; i++)
274 {
275 if (graph.isTrav[i] == false && graph.edges[vertex, i] != 0)
276 {
277 //深度递归
278 DFSM(ref graph, i);
279 }
280 }
281 }
282 #endregion
283 #endregion
284
285 #region prim算法获取最小生成树
286 /// <summary>
287 /// prim算法获取最小生成树
288 /// </summary>
289 /// <param name="graph"></param>
290 public void Prim(MatrixGraph graph, out int sum)
291 {
292 //已访问过的标志
293 int used = 0;
294
295 //非邻接顶点标志
296 int noadj = -1;
297
298 //定义一个输出总权值的变量
299 sum = 0;
300
301 //临时数组,用于保存邻接点的权值
302 int[] weight = new int[graph.vertexNum];
303
304 //临时数组,用于保存顶点信息
305 int[] tempvertex = new int[graph.vertexNum];
306
307 //取出邻接矩阵的第一行数据,也就是取出第一个顶点并将权和边信息保存于临时数据中
308 for (int i = 1; i < graph.vertexNum; i++)
309 {
310 //保存于邻接点之间的权值
311 weight[i] = graph.edges[0, i];
312
313 //等于0则说明V1与该邻接点没有边
314 if (weight[i] == short.MaxValue)
315 tempvertex[i] = noadj;
316 else
317 tempvertex[i] = int.Parse(graph.vertex[0]);
318 }
319
320 //从集合V中取出V1节点,只需要将此节点设置为已访问过,weight为0集合
321 var index = tempvertex[0] = used;
322 var min = weight[0] = short.MaxValue;
323
324 //在V的邻接点中找权值最小的节点
325 for (int i = 1; i < graph.vertexNum; i++)
326 {
327 index = i;
328 min = short.MaxValue;
329
330 for (int j = 1; j < graph.vertexNum; j++)
331 {
332 //用于找出当前节点的邻接点中权值最小的未访问点
333 if (weight[j] < min && tempvertex[j] != 0)
334 {
335 min = weight[j];
336 index = j;
337 }
338 }
339 //累加权值
340 sum += min;
341
342 Console.Write("({0},{1}) ", tempvertex[index], graph.vertex[index]);
343
344 //将取得的最小节点标识为已访问
345 weight[index] = short.MaxValue;
346 tempvertex[index] = 0;
347
348 //从最新的节点出发,将此节点的weight比较赋值
349 for (int j = 0; j < graph.vertexNum; j++)
350 {
351 //已当前节点为出发点,重新选择最小边
352 if (graph.edges[index, j] < weight[j] && tempvertex[j] != used)
353 {
354 weight[j] = graph.edges[index, j];
355
356 //这里做的目的将较短的边覆盖点上一个节点的邻接点中的较长的边
357 tempvertex[j] = int.Parse(graph.vertex[index]);
358 }
359 }
360 }
361 }
362 #endregion
363
364 #region dijkstra求出最短路径
365 /// <summary>
366 /// dijkstra求出最短路径
367 /// </summary>
368 /// <param name="g"></param>
369 public void Dijkstra(MatrixGraph g)
370 {
371 int[] weight = new int[g.vertexNum];
372
373 int[] path = new int[g.vertexNum];
374
375 int[] tempvertex = new int[g.vertexNum];
376
377 Console.WriteLine("\n请输入源点的编号:");
378
379 //让用户输入要遍历的起始点
380 int vertex = int.Parse(Console.ReadLine()) - 1;
381
382 for (int i = 0; i < g.vertexNum; i++)
383 {
384 //初始赋权值
385 weight[i] = g.edges[vertex, i];
386
387 if (weight[i] < short.MaxValue && weight[i] > 0)
388 path[i] = vertex;
389
390 tempvertex[i] = 0;
391 }
392
393 tempvertex[vertex] = 1;
394 weight[vertex] = 0;
395
396 for (int i = 0; i < g.vertexNum; i++)
397 {
398 int min = short.MaxValue;
399
400 int index = vertex;
401
402 for (int j = 0; j < g.vertexNum; j++)
403 {
404 //顶点的权值中找出最小的
405 if (tempvertex[j] == 0 && weight[j] < min)
406 {
407 min = weight[j];
408 index = j;
409 }
410 }
411
412 tempvertex[index] = 1;
413
414 //以当前的index作为中间点,找出最小的权值
415 for (int j = 0; j < g.vertexNum; j++)
416 {
417 if (tempvertex[j] == 0 && weight[index] + g.edges[index, j] < weight[j])
418 {
419 weight[j] = weight[index] + g.edges[index, j];
420 path[j] = index;
421 }
422 }
423 }
424
425 Console.WriteLine("\n顶点{0}到各顶点的最短路径为:(终点 < 源点) " + g.vertex[vertex]);
426
427 //最后输出
428 for (int i = 0; i < g.vertexNum; i++)
429 {
430 if (tempvertex[i] == 1)
431 {
432 var index = i;
433
434 while (index != vertex)
435 {
436 var j = index;
437 Console.Write("{0} < ", g.vertex[index]);
438 index = path[index];
439 }
440 Console.WriteLine("{0}\n", g.vertex[index]);
441 }
442 else
443 {
444 Console.WriteLine("{0} <- {1}: 无路径\n", g.vertex[i], g.vertex[vertex]);
445 }
446 }
447 }
448 #endregion
449 }
450 }

 

算法速成系列至此就全部结束了,公司给我们的算法培训也于上周五结束,呵呵,赶一下同步。最后希望大家能对算法重视起来,

学好算法,终身收益。


原文:http://www.cnblogs.com/huangxincheng/p/2301476.html
分类: 算法

发表评论 没有账号,注册评论