堆棧內存溢出
  簡體   English   中英

回溯迷宮算法在C語言中開始錯誤

[英]Backtracking Maze Algorithm Starts off Wrong in C

 原文  2016-04-22 14:01:33  3   1    c/ maze

問題描述

過去一周一直在從事這個項目。 除了初始化/分配和步進功能外，我的教授都向我提供了一切...

目標不是創建迷宮，而是解決它。 我第一次編譯它時，它似乎運行良好並且可以通過它……然后，它將開始做一些時髦的事情，跳過一堵牆，然后停在那里……

試圖修復它並經歷它。 最終它沒有現在應該采取的第一步。 試圖了解我在做什么錯或為什么我現在在maze_client中沒有正確執行第一步... //提供，但是如果需要我可以更改一下 

#include <stdio.h>
#include "maze.h"

int main(int argc, char **argv)
{
   FILE *fp = fopen(argv[1], "r");
   Maze maze = initializeMaze(fp);
   findPath(maze);// first step.. It was provided to me. It basically calls step() 
   displayMaze(maze);
   return 0;
}

步驟功能...我做了另一個不是for循環的東西，我試圖看看是否也可以擺脫這些廢話。 不能正常工作只是讓它從其他地方隨機開始...第二個文件結束嘗試了，我屏蔽了每個函數...似乎在我的if(getBottom)語句中...我可以寫下我的邏輯如果需要，我希望它執行的步驟... 

static int step(Maze maze, int row, int column)
{
  //TODO: FINISH THE BACKTRACKING ALGORITHM
  int i,j;
  //int st;
  int successful;
 //maze->maze[row][column] = st;

 if(getVisit(maze, row, column) == maze->maze[maze->finishX][maze->finishY])
 {
   displayMaze(maze);
   return 1;
 }

 displayMaze(maze);
 getchar();
 // getVisit(maze, row, column);//gets pos
 for(i = -2; i <= 2; ++i)
 {
   for(j = -2; j <= 2; ++j)
   {
    //i*i != j*j dont move in diagonal
     //row+i >= 0 && row + i < n, bounds checking
     //col+j >= 0 && col+j < n, bounds checking
    if(i*i != j*j && row+i >= 0 && column+j >= 0 ) 
    {
      getVisit(maze, row, column);//Gets position 
        if(getCellHasTop(maze, row, column + 1) != 1)//Wall check, Zero meaning NO WALL
        {
                 //++st;
                 //gets that position and sees if it is unvisited... 
                 //need a test if it is visited.. if it has been visited before.. Set current spot as BAD_PATH
                 if(getVisit(maze,row,column+j) == UNVISITED)
                 {
                    setVisit(maze, row, column+1, GOOD_PATH);
                  successful = step(maze, row, column + 1);
                 }
              // if(getVisit(maze, row, column+j) == GOOD_PATH)
              //   {
              //   setVisit(maze, row-i, column, BAD_PATH);
          //   successful = step(maze, row, column+j);
            //      }
                 if(successful)
                   return 1;  
        }
        if(getCellHasLeft(maze,row - 1,column) != 1)
        {
                 if(getVisit(maze, row-1, column) == UNVISITED)
                 {
                 setVisit(maze, row-1, column, GOOD_PATH);
                 successful = step(maze, row-1, column);
                 }

              //   if(getVisit(maze, row-i, column) == GOOD_PATH)
               //  {
              //setVisit(maze, row-i, column, BAD_PATH);
              // successful = step(maze, row-i, column);
               //  }
                 //++st;
                 if(successful)
                return 1;
        }
        if(getCellHasRight(maze,row + 1, column) != 1)
        {
                 if(getVisit(maze, row+1, column) == UNVISITED)
                 {
                  setVisit(maze, row+1, column, GOOD_PATH);
                  successful = step(maze, row+1, column);
                 }

               //  if(getVisit(maze, row+i, column) == GOOD_PATH)
  //               {
    //            setVisit(maze, row+i, column, BAD_PATH);
      //            successful = step(maze, row+i, column);
        //        }
                 //++st;
                 if(successful)
                return 1;
        }
        if(getCellHasBottom(maze, row, column - 1) != 1)
        {
                 if(getVisit(maze, row, column-1) == UNVISITED)
                 {
                  setVisit(maze, row, column-1, GOOD_PATH);
                  successful = step(maze, row, column-1);
                 }

      //           if(getVisit(maze, row, column-j) == GOOD_PATH)
        //       {
          //        setVisit(maze, row, column-j, BAD_PATH);
            //    successful = step(maze, row, column-j);
              //   }
                 //++st;
                 if(successful)
                return 1;  
        }  
        //PART 2
        //Do not do else if because then each one would require... That is last resort
    if(getCellHasTop(maze, row, column + 1) == 0)//Wall check
        {
                 //++st;
                 //a test if it is visited.. if it has been visited before.. Set current spot as BAD_PATH   
                 if(getVisit(maze,row, column+1) == GOOD_PATH)
               {
                  setVisit(maze, row, column, BAD_PATH);
                  successful = step(maze, row, column + 1);
                }
                if(successful)
              return 1;  
        }
       if(getCellHasLeft(maze,row - 1,column) == 0)
        {
                 if(getVisit(maze, row-1, column) == GOOD_PATH)
                 {
               setVisit(maze, row, column, BAD_PATH);
                successful = step(maze, row-1, column);
                }
   //++st;
               if(successful)
            return 1;
 }
if(getCellHasRight(maze,row + 1, column) == 0)
        {
                if(getVisit(maze, row+1, column) == GOOD_PATH)
                {
                 setVisit(maze, row, column, BAD_PATH);
                 successful = step(maze, row+1, column);
                }
                 //++st;
      if(successful)
     return 1;
       }
       if(getCellHasBottom(maze, row, column - 1) == 0)
   {
                if(getVisit(maze, row, column-1) == GOOD_PATH)
 {
                  setVisit(maze, row, column, BAD_PATH);
                  successful = step(maze, row, column-1);
                }
                 //++st;
                 if(successful)
              return 1;  
       }  
        //Part 3
       if(getCellHasRight(maze, row + 1, column) != 0 && getCellHasLeft(maze,row - 1, column) != 0)// If there is a wall at those locationsZZ
        {
                if(getVisit(maze,row, column+1) == BAD_PATH)
                 {
                 setVisit(maze, row, column, BAD_PATH);
      successful = step(maze, row, column-1); 
                 }
                 if(successful)
                return 1;
 }
       if(getCellHasTop(maze, row, column + 1) != 0 && getCellHasBottom(maze, row, column - 1) != 0)
   {
                 if(getVisit(maze, row-1, column) == BAD_PATH)
                 {
                 setVisit(maze, row, column, BAD_PATH);
                  successful = step(maze, row+1, column);
                }
               if(successful)
              return 1;
     }
        if(getCellHasTop(maze, row, column +1) != 0 && getCellHasBottom(maze, row, column - 1) != 0)
      {
              if(getVisit(maze, row+1, column) == BAD_PATH)
           {
         setVisit(maze, row, column, BAD_PATH);
             successful = step(maze, row-1, column);
              }
         if(successful)
      return 1;
       }
      }  
     } 
     }
      displayMaze(maze);
      getchar();
    return 0;
    }

1 個解決方案

解決方案1
 0 已采納  2016-04-22 18:36:44

我認為您的問題出在這樣的代碼中： 

    if(getCellHasTop(maze, row, column + 1) != 1)//Wall check, Zero meaning NO WALL
    {
             //++st;
             //gets that position and sees if it is unvisited... 
             //need a test if it is visited.. if it has been visited before.. Set current spot as BAD_PATH
             if(getVisit(maze,row,column+j) == UNVISITED)
             {
                setVisit(maze, row, column+1, GOOD_PATH);
              successful = step(maze, row, column + 1);
             }
          // if(getVisit(maze, row, column+j) == GOOD_PATH)
          //   {
          //   setVisit(maze, row-i, column, BAD_PATH);
      //   successful = step(maze, row, column+j);
        //      }
             if(successful)
               return 1;  
    }

首先，您要從-2迭代到+2。 但是我認為迷宮細胞是連續的，因此您不應該這樣做。 相反，請執行以下操作：首先，測試行col以確保它們在迷宮中是有效位置。 接下來，測試當前單元格的位，以查看是否允許您向上運動或執行任何方向操作。 然后測試以查看目標單元格是否有效。 然后測試以查看目標單元格是否已被您通過的路徑所阻擋。 然后跳進去。 

enum {
    TOP_BLOCKED    = 0x01,
    RIGHT_BLOCKED  = 0x02,
    BOTTOM_BLOCKED = 0x04,
    LEFT_BLOCKED   = 0x08,
};

#define ABOVE(r,c)     (r),((c)+1)
#define BELOW(r,c)     (r),((c)-1)
#define LEFT_OF(r,c)   ((r)-1),(c)
#define RIGHT_OF(r,c)  ((r)+1),(c)

#define IN_MAZE(m,r,c) ((r)>=0 && (c)>=0 && (r)<(m)->rows && (c)<(m)->cols)
#define CELL(m,r,c) ((m)->maze[(r)][(c)])
#define TOP_OPEN(m,r,c) (in_maze(m, r, c) \
                        && !(CELL(m,r,c) & TOP_BLOCKED) 
                        && in_maze(m,ABOVE(r,c)))
#define VISITED(m,r,c) (getVisit(m,r,c) != UNVISITED)


// ... later, in your step function ...

#define POS  row,column

setVisit(maze, POS, GOOD_PATH);

if (TOP_OPEN(maze, POS) && !VISITED(maze, ABOVE(POS)) && step(maze, ABOVE(POS))) {
    // We found a successful path! Stop looking.
    return 1;
}

if (RIGHT_OPEN(maze, POS) ... && step(maze, RIGHT_OF(POS))) {
    return 1;
}

if (BOTTOM_OPEN ...

if (LEFT_OPEN ...
    return 1;
}

// There is no path from here that solves the maze.
setVisit(maze, POS, UNVISITED);
#undef POS

return 0;

暫無
暫無

聲明:本站的技術帖子網頁，遵循CC BY-SA 4.0協議，如果您需要轉載，請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.

相關問題 C ++ DFS中的迷宮回溯算法？ 在C中回溯迷宮求解器 C中的迷宮求解算法 帶有DFS的c中的迷宮生成算法 C中迷宮求解器的遞歸回溯算法不是回溯而是卡住 解決迷宮回溯 迷宮般的回溯 C語言迷宮生成算法中的隨機性細微缺失 C語言中的遞歸回溯算法，用於解決數獨問題 使用DFS算法（C編程）在迷宮中尋找汽車的方法
相關標簽
 
粵ICP備18138465號  © 2020-2024 STACKOOM.COM