前段時間遇到一個跨地圖尋路的需求，需要在任意兩個地圖之間自動尋路。我們的尋路演算法用的是AStar,每個地圖都有一份格子資料，地圖之間有傳送門通過。

首先這是一個最短路徑問題，常用的最短路徑演算法有Dijkstra、Floyd。這裡我的思路是選擇Dijkstra來實現。

具體的Dijkstar演算法原理可以參考這兩篇文章：（反正我是學完就忘記了 笑哭~）

1.定義圖的資料結構

    int MAXV;//最大頂點個數
    const int INF = int.MaxValue;    //INF表示∞ 無窮大

    struct MGraph                    //圖的定義
    {
        public
 
 int[][] edges;       //鄰接矩陣
        public int n, e;             //頂點數,弧數
        public VexterMapId[] vexs; //存放頂點資訊
    };

把mapID設定到每個頂點資料裡

        for (int i = 0; i < MAXV; i++)
        {
            g.vexs[i].mapID = mapNodeList[i];
        }

2.根據傳送門配置，生成邊（連通頂點之間）。這裡我是沒有計算AStar權值的，也就是預設每張相鄰地圖連線邊的權值都是1。這樣其實是不精確的，如果你們遊戲對精確度要求比較高的話，就要計算同一個地圖裡的傳送點之間AStar路徑的權值。

        //建立圖的臨接矩陣
        for (int i = 0; i < g.n; i++)
        {
            g.edges[i] = new int[MAXV];
            for (int j = 0; j < g.n; j++)
            {
                //計算i到j的權值
                int mapI = mapNodeList[i];
                int mapJ = mapNodeList[j];
                if (linkDic.ContainsKey(mapI))
                {
                    if
 
 (linkDic[mapI].ContainsKey(mapJ))//判斷地圖I到地圖J能不能走通
                    {
                        g.edges[i][j] = 1;//預設給權值都為1
                        continue;
                    }
                }
                g.edges[i][j] = INF;
            }
        }

3.生成所有地圖之間的最短路徑作為一個靜態配置，這樣在執行時就不需要運算Dijkstra演算法去查詢了，直接進入遊戲的時候解析配置，後面就可以隨便查詢都不影響效能。

    /// <summary>
    /// 所有路徑放這裡儲存
    /// </summary>
    public Dictionary<string, List<int>> allPathDic = new Dictionary<string, List<int>>();

    public void ExportPath()
    {
        float time = Time.realtimeSinceStartup;
        for (int i = 0; i < MAXV; i++)
        {
            Dijkstra(g, i);
        }
        Debug.Log("跨地圖資料生成耗時：" + ((Time.realtimeSinceStartup - time) * 1000) + "ms");
    }

    void Dijkstra(MGraph g, int v)
    {
        int[] dist = new int[MAXV];//從原點v到其他的各定點當前的最短路徑長度
        int[] path = new int[MAXV];//path[i]表示從原點到定點i之間最短路徑的前驅節點
        int[] s = new int[MAXV];   //選定的頂點的集合
        int mindis, i, j, u;
        u = 0;
        for (i = 0; i < g.n; i++)
        {
            dist[i] = g.edges[v][i];       //距離初始化
            s[i] = 0;                        //s[]置空  0表示i不在s集合中
            if (g.edges[v][i] < INF)        //路徑初始化
                path[i] = v;
            else
                path[i] = -1;
        }
        s[v] = 1;                  //源點編號v放入s中
        path[v] = 0;
        for (i = 0; i < g.n; i++)                //迴圈直到所有頂點的最短路徑都求出
        {
            mindis = INF;                    //mindis置最小長度初值
            for (j = 0; j < g.n; j++)         //選取不在s中且具有最小距離的頂點u
                if (s[j] == 0 && dist[j] < mindis)
                {
                    u = j;
                    mindis = dist[j];
                }
            s[u] = 1;                       //頂點u加入s中
            for (j = 0; j < g.n; j++)         //修改不在s中的頂點的距離
                if (s[j] == 0)
                    if (g.edges[u][j] < INF && dist[u] + g.edges[u][j] < dist[j])
                    {
                        dist[j] = dist[u] + g.edges[u][j];
                        path[j] = u;
                    }
        }

        PutBothpath(g, dist, path, s, g.n, v);//獲取路徑
    }

    void PutBothpath(MGraph g, int[] dist, int[] path, int[] s, int n, int v)
    {
        int i;
        for (i = 0; i < n; i++)
        {
            if (s[i] == 1 && dist[i] < INF)
            {
                List<int> pathVexsList = new List<int>(4);
                pathVexsList.Add(g.vexs[v].mapID);//起點
                Ppath(g, path, i, v, pathVexsList);
                pathVexsList.Add(g.vexs[i].mapID);//終點
                //StringBuilder pathStr = new StringBuilder();
                //for (int j = 0; j < pathVexsList.Count; j++)
                //{
                //    pathStr.Append(g.vexs[pathVexsList[j]].mapID);
                //    if (j != pathVexsList.Count - 1)//不是結尾就加間隔符
                //    {
                //        pathStr.Append("-");
                //    }
                //}
                string pathKey = g.vexs[v].mapID + "-" + g.vexs[i].mapID;
                if (!allPathDic.ContainsKey(pathKey))//不存在
                {
                    allPathDic.Add(pathKey, pathVexsList);
                }
                //Debug.Log(string.Format(" 從 {0} 到 {1} 的最短路徑長度為:{2}\t路徑為:{3}", g.vexs[v].mapID, g.vexs[i].mapID, dist[i], pathStr));
            }
            //else
            //    Debug.Log(string.Format("從{0}到{1}不存在路徑\n", v, i));
        }
    }

    void Ppath(MGraph g, int[] path, int i, int v, List<int> pathVexsList)  //前向遞迴查詢路徑上的頂點
    {
        int k;
        k = path[i];
        if (k == v) return;    //找到了起點則返回
        Ppath(g, path, k, v, pathVexsList);    //找頂點k的前一個頂點v
        pathVexsList.Add(g.vexs[k].mapID);
    }

這樣其他地方呼叫就只需要查詢這個字典，就能查到最短路徑了~

public Dictionary<string, List<int>> allPathDic = new Dictionary<string, List<int>>();