Question

我正在编写一个路径查找算法，我需要一些帮助，以便在创建异常情况时避免递归继续，从而弄清楚如何加速它。

我有1个矩阵（空格=墙;哈希=集团; 2 =实际位置） “2”需要收集所有的“＃”，每次他走上“＃”就会消失。

我自愿产生了一个不可能的解释我的问题。

{  ,  ,  ,  ,  ,  ,  ,   };
{  , #, #, #, #, #, #,   };
{  , #,  ,  ,  ,  , #,   };
{  , #,  , #, #,  , #,   };
{  , #,  , #, #,  , #,   };
{  , #,  , #, #,  , #,   };
{  , #,  , #, #,  , #,   };
{  , #,  ,  ,  ,  , #,   };
{  , #, #, #, 2, #, #,   };
{  ,  ,  ,  ,  ,  ,  ,   };

如您所见，地图中间有一个无法到达的岛屿。

如果你们有任何想法如何检测这种情况，我想。我无法想办法。

以下是我的实际代码：

检查一些例外情况并返回true或false：

static bool BreakCaseFound() {
    int EndCases = 0;   // 3 blocs with 3 empty slots around
    bool BreakCases = false;    // 1 bloc with 4 empty slots around
    int temp = 0;
    for(int i = 1; i<17; i++) {
        for(int j = 1; j<17; j++) {
            if(matrice[j, i] == bloc) {
                if (matrice[j+1, i] == empty) {
                    temp++;
                }
                if (matrice[j-1, i] == empty) {
                    temp++;
                }
                if (matrice[j, i+1] == empty) {
                    temp++;
                }
                if (matrice[j, i-1] == empty) {
                    temp++;
                }
            }
            switch(temp) {
                case 3:
                    EndCases++;
                    temp = 0;
                    break;
                case 4:
                    temp = 0;
                    BreakCases = true;
                    break;
                default:
                    temp = 0;
                    break;
            }

            if(BreakCases || EndCases >= 3) {
                return true;
            }
        }
    }
    return false;
}

我的显示功能（MS-DOS窗口）

static void show() {
    Console.Clear();
    for(int i =0; i<18; i++) {
        for(int j = 0; j<18; j++) {
            if(matrice[j,i] == empty) {
                Console.Write(" ");
            }
            else {
                if (matrice[j, i] == 2) { matrice[j, i] = bloc ; }
                if (matrice[j, i] == 3) { matrice[j, i] = 5 ; }
                Console.Write(matrice[j, i]);
            }
        }
        Console.Write("\n");
    }
}

我的算法：

static dynamic move(int actualPosCol, int actualPosLigne, List<int[]> path, List<int[]> RealPath)
{
    matrice[path[path.Count()-1][0], path[path.Count()-1][1]] = 5;
    show();
    if(nbBlocs > 0) {
        show();

        //Left move
        if( (matrice[path[path.Count() - 1][0]-1, path[path.Count() - 1][1]] == bloc)
        && (!BreakCaseFound()) ) { 
            nbBlocs--;
            matrice[actualPosCol, actualPosLigne] = empty;
            int[] posNext = new int[2] {actualPosCol-1, actualPosLigne};
            path.Add(posNext);
            move(actualPosCol-1, actualPosLigne, path, RealPath);
        }
        //Right move
        if( (matrice[path[path.Count() - 1][0]+1, path[path.Count() - 1][1]] == bloc)
        && (!BreakCaseFound()) ) { 
            nbBlocs--;
            matrice[actualPosCol, actualPosLigne] = empty;
            int[] posNext = new int[2] {actualPosCol+1, actualPosLigne};
            path.Add(posNext);
            move(actualPosCol+1, actualPosLigne, path, RealPath);

        }

        //Down move
        if ( (matrice[path[path.Count() - 1][0], path[path.Count() - 1][1]+1] == bloc)
        && (!BreakCaseFound()) ) { 
            nbBlocs--;
            matrice[actualPosCol, actualPosLigne] = empty;
            int[] posNext = new int[2] {actualPosCol, actualPosLigne+1};
            path.Add(posNext);
            move(actualPosCol, actualPosLigne+1, path, RealPath);
        }
        //Up move
        if ( (matrice[path[path.Count() - 1][0], path[path.Count() - 1][1]-1] == bloc)
        && (!BreakCaseFound()) ) { 
            nbBlocs--;
            matrice[actualPosCol, actualPosLigne] = empty;
            int[] posNext = new int[2] {actualPosCol, actualPosLigne-1};
            path.Add(posNext);
            move(actualPosCol, actualPosLigne-1, path, RealPath);
        }

        if(nbBlocs > 0) {
            //Can't move right, left, up or down
            matrice[path[path.Count() - 1][0], path[path.Count() - 1][1]] = 3;
            show();
            path.Remove(path.Last());   //remove last move from the List
            nbBlocs++;
        }

        return path;
    }
    else {  //No more blocs, path found.
        foreach(int[] way in path) {
            if(!RealPath.Contains(way)) {
                RealPath.Add(way);
            }
        }
        return path;
    }
}

Answer 1

也许我疯了，但每当我看到涉及断开的连续区域的问题时，我认为disjoint sets。不相交集是为非常有效的合并而设计的集合，如果你试图找出＃的许多区域是否已连接，那么合并就是你做的很多。

将地图上的每个位置放入自己的不相交集中。包含位置的任何集合最终都将包含您可以从中移动的所有位置。怎么样？我们在地图上走动，任何时候我们可以从一个地方移动到另一个地方，我们合并集合。

您应该采用这些步骤的顺序？从某个地方填充整个地图 - 从每个位置进行洪水填充，再到您不是来自的任何邻居。如果X与Y在同一设置中，则从点X到点Y的泛洪填充应该不执行任何操作，否则，如果可以在它们之间移动，则应合并X和Y的集合。如果以前从未访问过Y，那么从Y进行递归。

此解决方案将在地图中的n个位置以约O（n inverse-ackermann（n））运行。

递归路径查找问题

1 个答案: