Dijkstra Algorithm 实现

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;

public class DijkstraAlgorithm : MonoBehaviour
{
	public string StartPos = "a";
	public string TargetPos = "e";
	public bool CalculateAgain = false;

	// 顶点集
	private List<string> VertexSet = new List<string>(){"a", "b", "c", "d", "e"};
	// 路径值
	private Dictionary<string, int> valueMap = new Dictionary<string, int>();

	//已处理顶点
	private List<string> _AfterCalculate = new List<string>();
	//未处理顶点
	private List<string> _NotCalculte = new List<string>();

	// 顶点权值记录
	private Dictionary<string, int> vertexValue = new Dictionary<string, int>();
	// 第一个是目标节点，后面是路径
	private Dictionary<string, string> PathRecord = new Dictionary<string, string>();

	private void DijkstraAlgo(string startVertex, string targetVertex)
	{
		// 清除掉所有信息
		vertexValue.Clear();
		PathRecord.Clear();
		_NotCalculte.Clear();
		_AfterCalculate.Clear();
		valueMap.Clear();

		// 初始化路径图数据
		InitPathValue();
		InitVertexValue();

		// 设置起点的路径值为0
		vertexValue[startVertex] =  0;
		PathRecord.Add(startVertex, startVertex);

		// 设置未处理的顶点列表为所有的顶点
		_NotCalculte.AddRange(VertexSet);

		while(_NotCalculte.Count > 0)
		{
			// 找到权值最小的作为起点
			// 找到最小权值顶点
			string minVertex = _NotCalculte[0];
			int minVertexValue = vertexValue[minVertex];
			for(int index = 0, imax = _NotCalculte.Count; index < imax; index++)
			{
				string crtVertex = _NotCalculte[index];
				int crtVertexValue = vertexValue[crtVertex];
				
				if(minVertexValue > crtVertexValue)
				{
					minVertex = crtVertex;
					minVertexValue = crtVertexValue;
				}
			}

			string tempStart = minVertex;

			// 以起点开始，计算其它顶点的权值
			for(int index = 0, imax = _NotCalculte.Count; index < imax; index++)
			{
				string targetPos = _NotCalculte[index];

				// 查看当前点到每个点的路径值
				int pathValue = GetPathValue(tempStart, targetPos);
				if(pathValue == int.MaxValue)
				{
					continue;
				}

				// 在有路径的情况下，比较当前的顶点权值
				// 当前点的路径权值直接从记录中查找，新的权值等于开始点的权值+ 路径权值
				int crtValue = vertexValue[targetPos];
				int preVextex = vertexValue[tempStart];
				if(crtValue > preVextex + pathValue)
				{
					vertexValue[targetPos] = preVextex + pathValue;

					// 记录其路径
					if(PathRecord.ContainsKey(targetPos))
					{
						PathRecord.Remove(targetPos);
					}

					// 路径等于前一节点 + 当前节点
					string crtPath = PathRecord[tempStart] + targetPos;
					PathRecord.Add(targetPos, crtPath);
				}
			}

			// 将最小权值点移动到已处理顶点列表中
			_AfterCalculate.Add(tempStart);
			_NotCalculte.Remove(tempStart);
		}

		PrintMinPathRecord(targetVertex);
	}

	void Update()
	{
		if(CalculateAgain)
		{
			CalculateAgain = false;
			DijkstraAlgo(StartPos, TargetPos);
		}
	}

	private void InitPathValue()
	{
		valueMap.Add("ab", 3);
		valueMap.Add("ac", 2);
		valueMap.Add("bc", 2);
		valueMap.Add("cd", 1);
		valueMap.Add("ce", 6);
		valueMap.Add("de", 1);
	}

	private void InitVertexValue()
	{
		for(int index = 0, imax = VertexSet.Count; index < imax; index++)
		{
			string vertex = VertexSet[index];
			vertexValue.Add(vertex, int.MaxValue);
		}
	}

	private void PrintVertexValue()
	{
		foreach(var key in vertexValue.Keys)
		{
			Debug.Log(key + " = " + vertexValue[key]);
		}
	}

	private void PrintMinPathRecord(string targetPos)
	{
		string minPath;
		if(PathRecord.TryGetValue(targetPos, out minPath))
		{
			Debug.Log("PATH = " + minPath);
		}
	}


	private void PrintMinPathRecord()
	{
		Debug.Log("************Min PATH *****************");
		foreach(var key in PathRecord.Keys)
		{
			Debug.Log(key + " = " + PathRecord[key]);
		}

		Debug.Log("************End PATH *****************");
	}

	private string GetVertexMinPath(string vertex)
	{
		string minPath;
		if(!PathRecord.TryGetValue(vertex,out minPath))
		{
			return null;
		}
		return minPath;
	}

	private int GetPathValue(string s, string d)
	{
		foreach(var key in valueMap.Keys)
		{
			string tempS = key.Substring(0, 1);
			string tempD = key.Substring(1, 1);

			if(tempS == s && tempD == d)
			{
				return valueMap[key];
			}
		}

		return int.MaxValue;
	}
}