[小明学算法]4.Dijkstra(迪杰斯特拉)算法

1.定义概念

　　Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。值得注意的是,该算法要求图中不存在负权边.

2.基本思想

　　设置顶点集合S,初始时,S中仅含有起始点,把从起始点到u且中间只经过S中顶点的路称为从起始点到u的特殊路径,并用数组dist记录当前每个顶点所对应的最短特殊路径的长度.Dijkstra算法每次从S外取出对应dist值最小的节点u,将其添加到S中,并对所有与u点直接相连的点重新计算dist值,若变小,则修改.一旦S中包含了所有的顶点,则dist中就记录了从起始点到所有其它顶点的最短路径长度.

　　例如，对下图中的有向图，应用Dijkstra算法计算从源顶点1到其它顶点间最短路径的过程列在下表中。

　　Dijkstra算法的迭代过程：

迭代	s	u	dist[2]	dist[3]	dist[4]	dist[5]
初始	{1}	-	10	maxint	30	100
1	{1,2}	2	10	60	30	100
2	{1,2,4}	4	10	50	30	90
3	{1,2,4,3}	3	10	50	30	60
4	{1,2,4,3,5}	5	10	50	30	60

 3.代码实现:

using System;
using System.Collections.Generic;


namespace 动态规划
{
    internal class Graphic
    {
        public List<Node> Nodes;


        public int[] Dijkstra()
        {
            //1.一个集合S记录了所有的找到最短路径的数据
            var S = new List<Node>();
            //2.一个数组dist记录了所有点当前的最短路径
            var dist = new int[Nodes.Count];
            for (int i = 0; i < dist.Length; i++)
            {
                dist[i] = int.MaxValue;
            }
            //3.先加进去起点
            var curNode = Nodes[0];
            dist[0] = 0;
            S.Add(curNode);

            while (true)
            {
                //当前节点没有边,则应该结束了把?
                if (curNode.Edges == null || curNode.Edges.Count == 0)
                    break;

                //遍历当前节点直接相连的点,更新dist值
                foreach (var edge in curNode.Edges)
                {
                    var nextNode = edge.Next;
                    //1.重新估值
                    if (dist[curNode.Id] + edge.Value < dist[nextNode.Id])
                        dist[nextNode.Id] = dist[curNode.Id] + edge.Value;
                }

                //选择dist中最小的值加入到S中
                curNode = curNode.Edges[0].Next;
                for (int i = 0; i < dist.Length; i++)
                {
                    //不在S中且比当前节点的dist值小,则替换
                    if (!S.Contains(Nodes[i]) &&
                        dist[i] < dist[curNode.Id])
                        curNode = Nodes[i];
                }
                S.Add(curNode);
                //所有元素都加入到S中之后,则结束
                if (S.Count == Nodes.Count)
                    break;
            }

            return dist;
        }

        private static void Main(string[] args)
        {
            Graphic graphic = new Graphic()
            {
                Nodes = new List<Node>()
                {
                    new Node(0),
                    new Node(1),
                    new Node(2),
                    new Node(3),
                    new Node(4),
                }
            };

            graphic.Nodes[0].Edges = new List<Edge>()
            {
                new Edge() {Value = 10, Next = graphic.Nodes[1]},
                new Edge() {Value = 100, Next = graphic.Nodes[4]},
                new Edge() {Value = 30, Next = graphic.Nodes[3]},
            };

            graphic.Nodes[1].Edges = new List<Edge>()
            {
                new Edge() {Value = 50, Next = graphic.Nodes[2]},
            };

            graphic.Nodes[2].Edges = new List<Edge>()
            {
                new Edge() {Value = 10, Next = graphic.Nodes[4]},
            };

            graphic.Nodes[3].Edges = new List<Edge>()
            {
                new Edge() {Value = 20, Next = graphic.Nodes[2]},
                new Edge() {Value = 60, Next = graphic.Nodes[4]},
            };

            graphic.Nodes[4].Edges = new List<Edge>();

            var arr = graphic.Dijkstra();

            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write((i + 1) + ":" + arr[i].ToString() + " ");
            }

            Console.WriteLine();
            Console.Read();
        }
    }


    internal class Node
    {
        public List<Edge> Edges;
        public int Id;

        public Node(int id)
        {
            Id = id;
        }
    }

    internal class Edge
    {
        public Node Next;
        public int Value;
    }
}