API tools faq
paste
Advertisement
Noam_15

Solve_The_Maze_V012

Noam_15
Jun 21st, 2018
167
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 15.14 KB | None | 0 0
raw download clone embed print report
  1. // Solve The Maze
  2. // V0.1.2
  3. //
  4. // Date: 2018.06.21
  5. // (Based on: https://symbolsprogrammingblog.wordpress.com/2010/06/20/%D7%9E%D7%A6%D7%99%D7%90%D7%AA-%D7%94%D7%93%D7%A8%D7%9A-%D7%94%D7%A7%D7%A6%D7%A8%D7%94-%D7%91%D7%99%D7%95%D7%AA%D7%A8-%D7%91%D7%9E%D7%91%D7%95%D7%9A/ )
  6.  
  7.  
  8. #include <stdio.h>
  9. #include <memory.h>
  10. #include <time.h>
  11.  
  12. #define HEIGHT   50
  13. #define WIDTH    9
  14.  
  15. #define WALL     -1
  16. #define PATH     0
  17. #define START    83  // 'S'
  18. #define END      69  // 'E'
  19. #define ARROW    176
  20.  
  21. #define UP       30
  22. #define DOWN     40
  23. #define RIGHT    50
  24. #define LEFT     60
  25.  
  26. #define true 1
  27. #define false 0
  28. typedef int Boolean;
  29.  
  30. struct Point {
  31.    int Row;
  32.    int Column;
  33. };
  34.  
  35. int SolveMaze(int Maze[HEIGHT][WIDTH]);
  36. struct Point FindStartingPoint(int Maze[HEIGHT][WIDTH]);
  37. struct Point FindStartingPathPoint(int Maze[HEIGHT][WIDTH]);
  38. int SolveMazeREC(int Maze[HEIGHT][WIDTH], int h, int w, Boolean saveChanges);
  39. void ShowBoard(int Board[HEIGHT][WIDTH]);
  40. void CopyBoard(int targetBoard[HEIGHT][WIDTH], int sourceBoard[HEIGHT][WIDTH]);
  41. void InitMinStepsInMazeArray();
  42.  
  43. int MinStepsToEachPositionInMaze[HEIGHT][WIDTH]; // Fast the code...
  44.  
  45.  
  46. // This function try to solve the maze with minimum steps.
  47. //
  48. // If succeeded - fill the given board with 'ARROW' in the path that is found,
  49. //                and return the number of steps.
  50. // If failed    - return -1
  51. int SolveMaze(int Maze[HEIGHT][WIDTH])
  52. {
  53.     int h, w;
  54.     int steps = 2;
  55.     int lowestSteps = -1;
  56.     int lowestStepsSide = DOWN;
  57.     int NewMaze[HEIGHT][WIDTH];
  58.     int tmp;
  59.     struct Point startingPathPoint;
  60.     struct Point startingPoint;
  61.  
  62.     InitMinStepsInMazeArray();
  63.  
  64.     // Search start position
  65.     startingPathPoint = FindStartingPathPoint(Maze);
  66.     startingPoint = FindStartingPoint(Maze);
  67.     h = startingPathPoint.Row;
  68.     w = startingPathPoint.Column;
  69.  
  70.     MinStepsToEachPositionInMaze[h][w] = steps-1;
  71.  
  72.     // So the START position will not bother us
  73.     Maze[startingPoint.Row][startingPoint.Column] = ARROW;
  74.  
  75.     Maze[h][w] = ARROW;
  76.  
  77.     // UP
  78.     if (Maze[h-1][w] != WALL && Maze[h-1][w] != ARROW)
  79.     {
  80.         CopyBoard(NewMaze, Maze);
  81.         tmp = SolveMazeREC(NewMaze, h-1, w, steps, false, NULL);
  82.         if (tmp != -1)
  83.             if (tmp < lowestSteps || lowestSteps == -1)
  84.             {
  85.                 lowestSteps = tmp;
  86.                 lowestStepsSide = UP;
  87.             }  
  88.     }
  89.  
  90.     // DOWN
  91.     if (Maze[h+1][w] != WALL && Maze[h+1][w] != ARROW)
  92.     {
  93.         CopyBoard(NewMaze, Maze);
  94.         tmp = SolveMazeREC(NewMaze, h+1, w, steps, false, NULL);
  95.         if (tmp != -1)
  96.             if (tmp < lowestSteps || lowestSteps == -1)
  97.             {
  98.                 lowestSteps = tmp;
  99.                 lowestStepsSide = DOWN;
  100.             }
  101.     }
  102.  
  103.     // RIGHT
  104.     if (Maze[h][w+1] != WALL && Maze[h][w+1] != ARROW)
  105.     {
  106.         CopyBoard(NewMaze, Maze);
  107.         tmp = SolveMazeREC(NewMaze, h, w+1, steps, false, NULL);
  108.         if (tmp != -1)
  109.             if (tmp < lowestSteps || lowestSteps == -1)
  110.             {
  111.                 lowestSteps = tmp;
  112.                 lowestStepsSide = RIGHT;
  113.             }
  114.     }
  115.    
  116.     // LEFT
  117.     if (Maze[h][w-1] != WALL && Maze[h][w-1] != ARROW)
  118.     {
  119.         CopyBoard(NewMaze, Maze);
  120.         tmp = SolveMazeREC(NewMaze, h, w-1, steps, false, NULL);
  121.         if (tmp != -1)
  122.             if (tmp < lowestSteps || lowestSteps == -1)
  123.             {
  124.                 lowestSteps = tmp;
  125.                 lowestStepsSide = LEFT;
  126.             }
  127.     }
  128.  
  129.     // (If all directions are blocked, lowestSteps = -1)
  130.     if (lowestSteps == -1)
  131.     {
  132.         // Reset the START position // (We dont realy need this here)
  133.         Maze[startingPoint.Row][startingPoint.Column] = START;
  134.  
  135.         return -1;
  136.     }
  137.     else
  138.     {
  139.         InitMinStepsInMazeArray();
  140.         switch(lowestStepsSide)
  141.         {
  142.             case UP  :
  143.                 SolveMazeREC(NewMaze, h-1, w, steps, true, Maze);
  144.                 break;
  145.  
  146.             case DOWN  :
  147.                 SolveMazeREC(NewMaze, h+1, w, steps, true, Maze);
  148.                 break;
  149.  
  150.             case RIGHT :
  151.                 SolveMazeREC(NewMaze, h, w+1, steps, true, Maze);
  152.                 break;
  153.  
  154.             case LEFT :
  155.                 SolveMazeREC(NewMaze, h, w-1, steps, true, Maze);
  156.                 break;
  157.         }
  158.  
  159.         // Reset the START position
  160.         Maze[startingPoint.Row][startingPoint.Column] = START;
  161.         return steps + lowestSteps;
  162.     }
  163. }
  164.  
  165. struct Point FindStartingPoint(int Maze[HEIGHT][WIDTH])
  166. {
  167.     int startRow;
  168.     int startColumn;
  169.     struct Point StartingPoint;
  170.     for (startRow = 0; startRow < HEIGHT; startRow++)
  171.     {
  172.         for (startColumn = 0; startColumn < WIDTH; startColumn++)
  173.         {
  174.             if (Maze[startRow][startColumn] == START)
  175.             {
  176.                 StartingPoint.Column = startColumn;
  177.                 StartingPoint.Row = startRow;
  178.                 return StartingPoint;
  179.             }
  180.         }
  181.     }
  182.  
  183.     printf("Error in  FindStartingPoint\n");
  184.     return StartingPoint;
  185. }
  186.  
  187. struct Point FindStartingPathPoint(int Maze[HEIGHT][WIDTH])
  188. {
  189.     struct Point StartingPathPoint;
  190.     StartingPathPoint = FindStartingPoint(Maze);
  191.  
  192.     if (Maze[StartingPathPoint.Row + 1][StartingPathPoint.Column] == PATH)
  193.     {
  194.         StartingPathPoint.Row += 1;
  195.         return StartingPathPoint;
  196.     }
  197.     else if (Maze[StartingPathPoint.Row - 1][StartingPathPoint.Column] == PATH)
  198.     {
  199.         StartingPathPoint.Row -= 1;
  200.         return StartingPathPoint;
  201.     }
  202.     else if (Maze[StartingPathPoint.Row][StartingPathPoint.Column + 1] == PATH)
  203.     {
  204.         StartingPathPoint.Column += 1;
  205.         return StartingPathPoint;
  206.     }
  207.     else if (Maze[StartingPathPoint.Row][StartingPathPoint.Column - 1] == PATH)
  208.     {
  209.         StartingPathPoint.Column -= 1;
  210.         return StartingPathPoint;
  211.     }
  212.     else
  213.     {
  214.         printf("Error in  FindStartingPathPoint\n");
  215.         return StartingPathPoint;
  216.     }
  217. }
  218.  
  219. int SolveMazeREC(int Maze[HEIGHT][WIDTH], int h, int w, int stepsUntilNow,
  220.                  Boolean saveChanges, int MainMaze[HEIGHT][WIDTH])
  221. {
  222.     int lowestSteps = -1;
  223.     int NewMaze[HEIGHT][WIDTH];
  224.     int lowestStepsSide = DOWN;
  225.     int tmp;
  226.  
  227.     if (MinStepsToEachPositionInMaze[h][w] <= stepsUntilNow)
  228.     {
  229.         return -1;
  230.     }
  231.     else
  232.     {
  233.         MinStepsToEachPositionInMaze[h][w] = stepsUntilNow;
  234.     }
  235.  
  236.     // -- END
  237.     if (Maze[h][w] == END)
  238.         return 1;
  239.  
  240.     Maze[h][w] = ARROW;
  241.     if (saveChanges == true)
  242.     {
  243.         MainMaze[h][w] = ARROW;
  244.     }
  245.  
  246.     // UP
  247.     if (Maze[h-1][w] != WALL && Maze[h-1][w] != ARROW)
  248.     {
  249.         CopyBoard(NewMaze, Maze);
  250.         tmp = SolveMazeREC(NewMaze, h-1, w, stepsUntilNow+1, false, NULL);
  251.         if (tmp != -1)
  252.             if (tmp < lowestSteps || lowestSteps == -1)
  253.             {
  254.                 lowestSteps = tmp;
  255.                 lowestStepsSide = UP;
  256.             }
  257.     }
  258.  
  259.     // DOWN
  260.     if (Maze[h+1][w] != WALL && Maze[h+1][w] != ARROW)
  261.     {
  262.         CopyBoard(NewMaze, Maze);
  263.         tmp = SolveMazeREC(NewMaze, h+1, w, stepsUntilNow+1, false, NULL);
  264.         if (tmp != -1)
  265.             if (tmp < lowestSteps || lowestSteps == -1)
  266.             {
  267.                 lowestSteps = tmp;
  268.                 lowestStepsSide = DOWN;
  269.             }
  270.     }
  271.  
  272.     // RIGHT
  273.     if (Maze[h][w+1] != WALL && Maze[h][w+1] != ARROW)
  274.     {
  275.         CopyBoard(NewMaze, Maze);
  276.         tmp = SolveMazeREC(NewMaze, h, w+1, stepsUntilNow+1, false, NULL);
  277.         if (tmp != -1)
  278.             if (tmp < lowestSteps || lowestSteps == -1)
  279.             {
  280.                 lowestSteps = tmp;
  281.                 lowestStepsSide = RIGHT;
  282.             }
  283.     }
  284.    
  285.     // LEFT
  286.     if (Maze[h][w-1] != WALL && Maze[h][w-1] != ARROW)
  287.     {
  288.         CopyBoard(NewMaze, Maze);
  289.         tmp = SolveMazeREC(NewMaze, h, w-1, stepsUntilNow+1, false, NULL);
  290.         if (tmp != -1)
  291.             if (tmp < lowestSteps || lowestSteps == -1)
  292.             {
  293.                 lowestSteps = tmp;
  294.                 lowestStepsSide = LEFT;
  295.             }
  296.     }
  297.    
  298.     Maze[h][w] = PATH;
  299.     if (saveChanges == true)
  300.     {
  301.         if (lowestSteps != -1)
  302.         {
  303.             InitMinStepsInMazeArray();
  304.             switch(lowestStepsSide)
  305.             {
  306.                 case UP  :
  307.                     SolveMazeREC(NewMaze, h-1, w, stepsUntilNow+1, true, MainMaze);
  308.                     break;
  309.  
  310.                 case DOWN  :
  311.                     SolveMazeREC(NewMaze, h+1, w, stepsUntilNow+1, true, MainMaze);
  312.                     break;
  313.  
  314.                 case RIGHT :
  315.                     SolveMazeREC(NewMaze, h, w+1, stepsUntilNow+1, true, MainMaze);
  316.                     break;
  317.  
  318.                 case LEFT :
  319.                     SolveMazeREC(NewMaze, h, w-1, stepsUntilNow+1, true, MainMaze);
  320.                     break;
  321.             }
  322.         }
  323.     }
  324.    
  325.  
  326.     // (If all directions are blocked, lowestSteps = -1)
  327.     if (lowestSteps == -1)
  328.     {
  329.         // MinStepsToEachPositionInMaze[h][w] = -1; // maybe give us bag?
  330.         return -1;
  331.     }
  332.     else
  333.     {
  334.         return 1 + lowestSteps;
  335.     }
  336. }
  337.  
  338. void InitMinStepsInMazeArray()
  339. {
  340.     int i, j;
  341.     for (i = 0; i < HEIGHT; i++)
  342.     {
  343.         for (j = 0; j < WIDTH; j++)
  344.         {
  345.             MinStepsToEachPositionInMaze[i][j] = 100000; // Any number greater than number of positions in maze
  346.         }
  347.     }
  348. }
  349.  
  350. void ShowBoard(int Board[HEIGHT][WIDTH])
  351. {
  352.     int row;
  353.     int col;
  354.  
  355.     printf("Full maze:\n\n\n");
  356.  
  357.     for (row = 0; row < HEIGHT; row++)    // Loop through every row
  358.     {
  359.         for (col = 0; col < WIDTH; col++) // And every column
  360.         {
  361.             switch(Board[row][col])
  362.             {
  363.                 case WALL  :
  364.                   putchar('\xDB');
  365.                   break;
  366.  
  367.                 case PATH  :
  368.                   putchar(' ');
  369.                   break;
  370.  
  371.                 case ARROW :
  372.                   putchar(ARROW);
  373.                   break;
  374.                
  375.                 case START :
  376.                   putchar(START);
  377.                   break;
  378.                
  379.                 case END   :
  380.                   putchar(END);
  381.                   break;
  382.                
  383.                 default    :
  384.                   putchar('?');
  385.                   break;
  386.             }
  387.         }
  388.         putchar('\n');
  389.     }
  390.     printf("\n\n\n");
  391. }
  392.  
  393. void CopyBoard(int targetBoard[HEIGHT][WIDTH], int sourceBoard[HEIGHT][WIDTH])
  394. {
  395.     //int i, j;
  396.     //for (i = 0; i < HEIGHT; i++)
  397.     //{
  398.     //  for (j = 0; j < WIDTH; j++)
  399.     //  {
  400.     //      targetBoard[i][j] = sourceBoard[i][j];
  401.     //  }
  402.     //}
  403.  
  404.     // Fast copy:
  405.     memcpy(targetBoard, sourceBoard, WIDTH * HEIGHT * sizeof(int));
  406. }
  407.  
  408. void InitializeTheMaze(int Board[HEIGHT][WIDTH])
  409. {
  410.     // Maze Option A:
  411.     // #define HEIGHT   50
  412.     // #define WIDTH    9
  413.     int TmpBoard[HEIGHT][WIDTH] = {
  414.         { WALL , WALL , START, WALL, WALL , WALL , WALL , WALL , WALL  },
  415.         { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  416.         { WALL , PATH , WALL , WALL, WALL , PATH , WALL , WALL , WALL  },
  417.         { WALL , PATH , WALL , PATH, WALL , PATH , PATH , PATH , WALL  },
  418.         { WALL , WALL , WALL , PATH, WALL , PATH , WALL , PATH , WALL  },
  419.         { WALL , PATH , WALL , PATH, PATH , PATH , PATH , PATH , WALL  },
  420.         { WALL , PATH , WALL , WALL, WALL , WALL , WALL , PATH , WALL  },
  421.         { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  422.         { WALL , PATH , WALL , WALL, WALL , WALL , WALL , WALL , WALL  },
  423.         { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  424.         { WALL , WALL , WALL , WALL, WALL , WALL , WALL , PATH , WALL  },
  425.         { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  426.         { WALL , PATH , WALL , WALL, PATH , WALL , WALL , PATH , WALL  },
  427.         { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  428.         { WALL , PATH , WALL , PATH, WALL , PATH , WALL , PATH , WALL  },
  429.         { WALL , PATH , WALL , PATH, PATH , PATH , WALL , PATH , WALL  },
  430.         { WALL , PATH , WALL , WALL, WALL , WALL , WALL , PATH , WALL  },
  431.         { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  432.         { WALL , WALL , WALL , WALL, WALL , WALL , WALL , PATH , WALL  },
  433.         { WALL , PATH , PATH , PATH, PATH , PATH , WALL , PATH , WALL  },
  434.         { WALL , WALL , PATH , WALL, WALL , WALL , WALL , PATH , WALL  },
  435.         { WALL , PATH , PATH , PATH, WALL , PATH , PATH , PATH , WALL  },
  436.         { WALL , PATH , WALL , WALL, WALL , PATH , WALL , WALL , WALL  },
  437.         { WALL , PATH , PATH , PATH, WALL , PATH , PATH , PATH , WALL  },
  438.         { WALL , PATH , WALL , PATH, WALL , PATH , WALL , PATH , WALL  },
  439.         { WALL , PATH , WALL , PATH, PATH , PATH , PATH , PATH , WALL  },
  440.         { WALL , WALL , WALL , WALL, WALL , PATH , WALL , PATH , WALL  },
  441.         { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  442.         { WALL , PATH , WALL , PATH, PATH , WALL , PATH , WALL , WALL  },
  443.         { WALL , PATH , PATH , PATH, WALL , WALL , PATH , WALL , WALL  },
  444.         { WALL , WALL , WALL , PATH, WALL , WALL , PATH , WALL , WALL  },
  445.         { WALL , PATH , PATH , PATH, PATH , WALL , PATH , PATH , WALL  },
  446.         { WALL , WALL , WALL , PATH, WALL , WALL , PATH , PATH , WALL  },
  447.         { WALL , PATH , PATH , PATH, WALL , WALL , WALL , PATH , WALL  },
  448.         { WALL , PATH , WALL , PATH, WALL , PATH , WALL , PATH , WALL  },
  449.         { WALL , PATH , WALL , PATH, PATH , PATH , PATH , PATH , WALL  },
  450.         { WALL , PATH , PATH , PATH, PATH , WALL , PATH , PATH , WALL  },
  451.         { WALL , PATH , WALL , PATH, PATH , PATH , PATH , PATH , WALL  },
  452.         { WALL , WALL , WALL , WALL, PATH , WALL , PATH , WALL , WALL  },
  453.         { WALL , PATH , PATH , PATH, PATH , WALL , PATH , PATH , WALL  },
  454.         { WALL , PATH , WALL , WALL, WALL , WALL , PATH , WALL , WALL  },
  455.         { WALL , PATH , PATH , PATH, WALL , PATH , PATH , PATH , WALL  },
  456.         { WALL , PATH , WALL , WALL, WALL , WALL , PATH , WALL , WALL  },
  457.         { WALL , PATH , PATH , PATH, WALL , PATH , PATH , PATH , WALL  },
  458.         { WALL , PATH , WALL , PATH, WALL , PATH , WALL , PATH , WALL  },
  459.         { WALL , PATH , WALL , PATH, PATH , PATH , PATH , PATH , WALL  },
  460.         { WALL , WALL , WALL , WALL, WALL , WALL , WALL , PATH , WALL  },
  461.         { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  462.         { WALL , PATH , PATH , WALL, WALL , WALL , PATH , PATH , WALL  },
  463.         { WALL , END  , WALL , WALL, WALL , WALL , WALL , WALL , WALL  },
  464.     };
  465.  
  466.  
  467.  
  468.     // Maze Option B:
  469.     //// #define HEIGHT   9
  470.     //// #define WIDTH    9
  471.     //int TmpBoard[HEIGHT][WIDTH] = {
  472.     //  { WALL , WALL , START, WALL, WALL , WALL , WALL , WALL , WALL  },
  473.     //  { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  474.     //  { WALL , PATH , WALL , WALL, WALL , PATH , WALL , WALL , WALL  },
  475.     //  { WALL , PATH , WALL , PATH, WALL , PATH , PATH , PATH , WALL  },
  476.     //  { WALL , WALL , WALL , PATH, WALL , PATH , WALL , PATH , WALL  },
  477.     //  { WALL , PATH , WALL , PATH, PATH , PATH , PATH , PATH , WALL  },
  478.     //  { WALL , PATH , WALL , WALL, WALL , WALL , WALL , PATH , WALL  },
  479.     //  { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  480.     //  { WALL , END  , WALL , WALL, WALL , WALL , WALL , WALL , WALL  },
  481.     //};
  482.  
  483.  
  484.     // Maze Option C:
  485.     //// #define HEIGHT   19
  486.     //// #define WIDTH    9
  487.     //int TmpBoard[HEIGHT][WIDTH] = {
  488.     //  { WALL , WALL , START, WALL, WALL , WALL , WALL , WALL , WALL  },
  489.     //  { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  490.     //  { WALL , PATH , WALL , WALL, WALL , PATH , WALL , WALL , WALL  },
  491.     //  { WALL , PATH , WALL , PATH, WALL , PATH , PATH , PATH , WALL  },
  492.     //  { WALL , WALL , WALL , PATH, WALL , PATH , WALL , PATH , WALL  },
  493.     //  { WALL , PATH , WALL , PATH, PATH , PATH , PATH , PATH , WALL  },
  494.     //  { WALL , PATH , WALL , WALL, WALL , WALL , WALL , PATH , WALL  },
  495.     //  { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  496.     //  { WALL , PATH , WALL , WALL, WALL , WALL , WALL , WALL , WALL  },
  497.     //  { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  498.     //  { WALL , WALL , WALL , WALL, WALL , WALL , WALL , PATH , WALL  },
  499.     //  { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  500.     //  { WALL , PATH , WALL , WALL, PATH , WALL , WALL , PATH , WALL  },
  501.     //  { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  502.     //  { WALL , WALL , WALL , PATH, WALL , PATH , WALL , PATH , WALL  },
  503.     //  { END  , PATH , WALL , PATH, PATH , PATH , WALL , PATH , WALL  },
  504.     //  { WALL , PATH , WALL , WALL, WALL , WALL , WALL , PATH , WALL  },
  505.     //  { WALL , PATH , PATH , PATH, PATH , PATH , PATH , PATH , WALL  },
  506.     //  { WALL , WALL , WALL , WALL, WALL , WALL , WALL , WALL , WALL  },
  507.     //};
  508.  
  509.     CopyBoard(Board, TmpBoard);
  510. }
  511.  
  512. int main()
  513. {
  514.     int Board[HEIGHT][WIDTH];
  515.     int Steps;
  516.     clock_t begin, end;
  517.     double time_spent;
  518.  
  519.     InitializeTheMaze(Board);
  520.  
  521.     printf("* Start:\n\n");
  522.     ShowBoard(Board);
  523.  
  524.     printf("* Program Answer:\n\n");
  525.  
  526.     begin = clock();
  527.     Steps = SolveMaze(Board);
  528.     end = clock();
  529.     time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
  530.  
  531.     if (Steps != -1) // Path found
  532.     {
  533.         printf("Number of steps: %d\n-----------------------\n", Steps);
  534.         ShowBoard(Board);
  535.     }
  536.     else
  537.     {
  538.         printf("Maze cannot be solved! :(\n\n");
  539.     }
  540.  
  541.     printf("Time:  %lf Seconds\n", time_spent);
  542.     getchar();
  543. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!