涓嶆槸鐭ラ亾浠€涔堢殑瀵昏矾绠楁硶

Posted 2021-03-24

鏍囩锛?a href='http://www.mamicode.com/so/1/new' title='new'>new   椤剁偣   matrix   缁熻   tco   collect   lin   remove   鎴愬姛   

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];

        // 璁剧疆鎵€鏈夌偣涓嶅彲杈?/span>
        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++)
                    {
                        // 涓鸿嚜韬椂璺濈涓?
                        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 -- 鍓嶉┍椤剁偣鏁扮粍銆傚嵆锛宲rev[i]鐨勫€兼槸"椤剁偣vs"鍒?椤剁偣i"鐨勬渶鐭矾寰勬墍缁忓巻鐨勫叏閮ㄩ《鐐逛腑锛屼綅浜?椤剁偣i"涔嬪墠鐨勯偅涓《鐐广€?
     *     dist -- 闀垮害鏁扮粍銆傚嵆锛宒ist[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++)
    //    {
    //        // 瀵绘壘褰撳墠鏈€灏忕殑璺緞锛?
    //        // 鍗筹紝鍦ㄦ湭鑾峰彇鏈€鐭矾寰勭殑椤剁偣涓紝鎵惧埌绂籿s鏈€杩戠殑椤剁偣(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): 
", G.vexs[vs]);
    //    for (i = 0; i < G.vexnum; i++)
    //        printf("  shortest(%c, %c)=%d
", G.vexs[vs], G.vexs[i], dist[i]);
    //}

}