Рубрики

Программа для крыс в лабиринте | Откат-2

Мы обсудили проблему с возвратом и туром Найта в Сете 1 . Давайте обсудим Крысу в Лабиринте как еще одну примерную проблему, которую можно решить с помощью Backtracking.

Лабиринт задается в виде N * N двоичной матрицы блоков, где исходный блок является самым верхним левым блоком, т. Е. Лабиринт [0] [0], а целевой блок является самым правым нижним блоком, т. Е. Лабиринт [N-1] [N-1] , Крыса начинается с источника и должна достигнуть места назначения. Крыса может двигаться только в двух направлениях: вперед и вниз.
В матрице лабиринта 0 означает, что блок является тупиком, а 1 означает, что блок может использоваться на пути от источника к месту назначения. Обратите внимание, что это простая версия типичной проблемы лабиринта. Например, более сложная версия может заключаться в том, что крыса может двигаться в 4 направлениях, а более сложная версия может иметь ограниченное количество ходов.

Ниже приведен пример лабиринта.

 Gray blocks are dead ends (value = 0). 

Ниже приведено двоичное матричное представление вышеуказанного лабиринта.

                {1, 0, 0, 0}
                {1, 1, 0, 1}
                {0, 1, 0, 0}
                {1, 1, 1, 1}

Далее идет лабиринт с выделенным путем решения.

Ниже приведена матрица решения (вывод программы) для вышеуказанного входного матрицы.

                {1, 0, 0, 0}
                {1, 1, 0, 0}
                {0, 1, 0, 0}
                {0, 1, 1, 1}
 All enteries in solution path are marked as 1.

/ * C / C ++ программа для решения Rat in Maze с помощью задачи

   возвращение назад * /

#include <stdio.h>

  
// Размер лабиринта
#define N 4

  

bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N]);

  
/ * Вспомогательная функция для печати решения матрицы sol [N] [N] * /

void printSolution(int sol[N][N])

{

    for (int i = 0; i < N; i++) {

        for (int j = 0; j < N; j++)

            printf(" %d ", sol[i][j]);

        printf("\n");

    }

}

  
/ * Полезная функция для проверки, является ли x, y допустимым индексом для N * N лабиринта * /

bool isSafe(int maze[N][N], int x, int y)

{

    // if (x, y вне лабиринта) возвращает false

    if (x >= 0 && x < N && y >= 0 && y < N && maze[x][y] == 1)

        return true;

  

    return false;

}

  
/ * Эта функция решает проблему лабиринта с помощью Backtracking. Это в основном

   решает проблему с помощью solveMazeUtil (). Возвращает false если нет

   путь возможен, иначе возвращает true и печатает путь в

   форма 1с. Обратите внимание, что может быть более одного решения,

   эта функция печатает одно из возможных решений. * /

bool solveMaze(int maze[N][N])

{

    int sol[N][N] = { { 0, 0, 0, 0 },

                      { 0, 0, 0, 0 },

                      { 0, 0, 0, 0 },

                      { 0, 0, 0, 0 } };

  

    if (solveMazeUtil(maze, 0, 0, sol) == false) {

        printf("Solution doesn't exist");

        return false;

    }

  

    printSolution(sol);

    return true;

}

  
/ * Рекурсивная функция полезности для решения задачи Лабиринта * /

bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N])

{

    // если (x, y - цель), верните true

    if (x == N - 1 && y == N - 1) {

        sol[x][y] = 1;

        return true;

    }

  

    // Проверяем, действительно ли maze [x] [y]

    if (isSafe(maze, x, y) == true) {

        // помечаем x, y как часть пути решения

        sol[x][y] = 1;

  

        / * Двигаться вперед в направлении х * /

        if (solveMazeUtil(maze, x + 1, y, sol) == true)

            return true;

  

        / * Если движение в направлении х не дает решения, то

           Двигаться вниз в направлении y * /

        if (solveMazeUtil(maze, x, y + 1, sol) == true)

            return true;

  

        / * Если ни одно из вышеперечисленных движений не сработало, тогда НАЗАД:

            снять метку x, y как часть пути решения * /

        sol[x][y] = 0;

        return false;

    }

  

    return false;

}

  
// программа драйвера для проверки вышеуказанной функции

int main()

{

    int maze[N][N] = { { 1, 0, 0, 0 },

                       { 1, 1, 0, 1 },

                       { 0, 1, 0, 0 },

                       { 1, 1, 1, 1 } };

  

    solveMaze(maze);

    return 0;

}

Выход:

1  0  0  0 
1  1  0  0 
0  1  0  0 
0  1  1  1

Пожалуйста, обратитесь полную статью о крысе в лабиринте | Backtracking-2 для более подробной информации!

Рекомендуемые посты:

Программа для крыс в лабиринте | Откат-2

0.00 (0%) 0 votes