不是知道什么的寻路算法

using System;
using System.Collections.Generic;

public class PathGraph
{
    public int[] m_Vertices;
    public int m_VertexNum;
    public int m_EdgeNum;
    public int[,] m_Matrix;
    public int m_Row;
    public int m_Col;

    public PathGraph(int row, int col)
    {
        m_Row = row;
        m_Col = col;
        FillMatrix();
    }

    void FillMatrix()
    {
        var length = m_Row * m_Col;
        m_Matrix = new int[length, length];

        // 设置所有点不可达
        for (var i = 0; i < length; i++)
            for (var j = 0; j < length; j++)
                m_Matrix[i, j] = -1;

        for (var i = 0; i < m_Row; i++)
        {
            for (var j = 0; j < m_Col; j++)
            {
                // 遍历每个点周围点， 设置距离
                for (var x = -1; x <= 1; x++)
                {
                    for (var y = -1; y <= 1; y++)
                    {
                        // 为自身时距离为0
                        if (x == 0 && y == 0)
                            m_Matrix[i * m_Col + j, i * m_Col + j] = 0;

                        // 为周围点时距离为1
                        if (i + x >= 0 && i + x < m_Row &&
                            j + y >= 0 && j + y < m_Col)
                        {
                            m_Matrix[(i + x) * m_Col + (j + y), i * m_Col + j] = 1;
                            m_Matrix[i * m_Col + j, (i + x) * m_Col + (j + y)] = 1;
                        }
                    }
                }
            }
        }
    }
}

public class PathMgr
{
    static PathGraph m_Graph;

    public static void Init()
    {
        m_Graph = new PathGraph(5, 8);
    }

    public static void FindPath(int rowIndex, int colIndex, int targetRowIndex, int targetColIndex)
    {
        var startMatrixIndex = rowIndex * m_Graph.m_Col + colIndex;
        var targetMatrixIndex = targetRowIndex * m_Graph.m_Col + targetColIndex;
        if (TryFindPath(startMatrixIndex, targetMatrixIndex) != null)
        {

        }
    }

    static List<int> TryFindPath(int origin, int target, List<int> used)
    {
        if (origin == target)
            return used;

        for (var i = 0; i < m_Graph.m_Row; i++)
        {
            for (var j = 0; j < m_Graph.m_Col; j++)
            {
                var index = i * m_Graph.m_Row + j;

                // 点可达并且未使用
                if (m_Graph.m_Matrix[origin, index] > 0
                    && ! used.Contains(index))
                {
                    used.Add(index);
                    TryFindPath(index, target, used);
                }
            }
        }

        used.Remove(origin);
    }







    /*
     * Dijkstra最短路径。
     * 即，统计图(G)中"顶点vs"到其它各个顶点的最短路径。
     *
     * 参数说明：
     *        G -- 图
     *       vs -- 起始顶点(start vertex)。即计算"顶点vs"到其它顶点的最短路径。
     *     prev -- 前驱顶点数组。即，prev[i]的值是"顶点vs"到"顶点i"的最短路径所经历的全部顶点中，位于"顶点i"之前的那个顶点。
     *     dist -- 长度数组。即，dist[i]是"顶点vs"到"顶点i"的最短路径的长度。
     */
    //void dijkstra(Graph G, int vs, int prev[], int dist[])
    //{
    //    int i, j, k;
    //    int min;
    //    int tmp;
    //    int flag[MAX];      // flag[i]=1表示"顶点vs"到"顶点i"的最短路径已成功获取。

    //    // 初始化
    //    for (i = 0; i < G.vexnum; i++)
    //    {
    //        flag[i] = 0;              // 顶点i的最短路径还没获取到。
    //        prev[i] = 0;              // 顶点i的前驱顶点为0。
    //        dist[i] = G.matrix[vs][i];// 顶点i的最短路径为"顶点vs"到"顶点i"的权。
    //    }

    //    // 对"顶点vs"自身进行初始化
    //    flag[vs] = 1;
    //    dist[vs] = 0;

    //    // 遍历G.vexnum-1次；每次找出一个顶点的最短路径。
    //    for (i = 1; i < G.vexnum; i++)
    //    {
    //        // 寻找当前最小的路径；
    //        // 即，在未获取最短路径的顶点中，找到离vs最近的顶点(k)。
    //        min = INF;
    //        for (j = 0; j < G.vexnum; j++)
    //        {
    //            if (flag[j] == 0 && dist[j] < min)
    //            {
    //                min = dist[j];
    //                k = j;
    //            }
    //        }
    //        // 标记"顶点k"为已经获取到最短路径
    //        flag[k] = 1;

    //        // 修正当前最短路径和前驱顶点
    //        // 即，当已经"顶点k的最短路径"之后，更新"未获取最短路径的顶点的最短路径和前驱顶点"。
    //        for (j = 0; j < G.vexnum; j++)
    //        {
    //            tmp = (G.matrix[k][j] == INF ? INF : (min + G.matrix[k][j])); // 防止溢出
    //            if (flag[j] == 0 && (tmp < dist[j]))
    //            {
    //                dist[j] = tmp;
    //                prev[j] = k;
    //            }
    //        }
    //    }

    //    // 打印dijkstra最短路径的结果
    //    printf("dijkstra(%c): \n", G.vexs[vs]);
    //    for (i = 0; i < G.vexnum; i++)
    //        printf("  shortest(%c, %c)=%d\n", G.vexs[vs], G.vexs[i], dist[i]);
    //}

}