Существует матрица, содержащая белые клетки (представленные как 1), черные клетки (представленные как 0), и только одна серая клетка (представленная как 2), должна идти от (0,0) до (N-1, N-1 ) в массиве [N] [N].
Ограничения:
1) Путь должен охватывать только белые ячейки и должен проходить через серию клеток (эта серая ячейка может находиться где угодно в массиве)
2) Неоднократно посещенный узел не может быть посещен.
Ниже приведено типичное решение проблемы с лабиринтом, но это решение не справляется с конкретным случаем пересечения ячейки GRAY... так что вы можете помочь мне в модификации приведенного ниже кода для обработки конкретного случая.
Моя проблема в том, что я не уверен, как поставить чек для серой ячейки?
#include "stdafx.h"
#include "algorithm"
#include <iostream>
#include <fstream>
using namespace std;
#include<stdio.h>
// Maze size
#define N 4
bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N]);
/* A utility function to print solution matrix 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");
}
}
/* A utility function to check if x,y is valid index for N*N maze */
bool isSafe(int maze[N][N], int x, int y)
{
//solveMazeUtil() to solve the problem. It returns false if no path is possible,
//otherwise return true and prints the path in the form of 1s. Please note that
//there may be more than one solutions, this function prints one of the feasible
if(x >= 0 && x < N && y >= 0 && y < N && maze[x][y] == 1)
// if (x,y outside maze) return false
return true;
return false;
}
/* This function solves the Maze problem using Backtracking. It mainly uses
solutions.*/
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;
}
/* A recursive utility function to solve Maze problem */
bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N])
{
// if (x,y is goal) return true
if(x == N-1 && y == N-1)
{
sol[x][y] = 1;
return true;
}
// Check if maze[x][y] is valid
if(isSafe(maze, x, y) == true)
{
// mark x,y as part of solution path
sol[x][y] = 1;
/* Move forward in x direction */
if (solveMazeUtil(maze, x+1, y, sol) == true)
return true;
/* If x moving in x direction doesn't give solution then
Move down in y direction */
if (solveMazeUtil(maze, x, y+1, sol) == true)
return true;
/* If none of the above movements work then BACKTRACK:
unmark x,y as part of solution path */
sol[x][y] = 0;
return false;
}
return false;
}
// driver program to test above function
int main()
{
int maze[N][N] = { {1, 0, 0, 0},
{1, 1, 0, 1},
{0, 1, 0, 0},
{1, 1, 1, 1}
};
solveMaze(maze);
getchar();
return 0;
}
Одним из решений я считаю:
Произведите все возможные пути (которые проходят через 1 или 2).
Затем выясните, какой из путей имеет в нем 2. и затем напечатайте этот путь как выход.
Но я не думаю, что это будет хороший подход... Итак, пожалуйста, дайте мне знать, как достичь моей цели достойным образом. благодаря
Поскольку в вашем коде вы используете только два возможных движения: вниз и вправо, это будет DAG. DAG подходит для подхода с динамическим программированием: у каждой ячейки есть две возможности добраться туда, одна идет сверху, а другая идет слева. Таким образом, минимальное расстояние для ячейки:
cost[i][j] = min(cost[i][j-1],cost[i-1][j]) + 1
Это предполагает, что стоимость движения - 1. Если ячейка черная, вы можете дать ей бесконечную стоимость, и вам нужно всего лишь найти путь от P1(start)
до P2(gray cell)
а затем путь от P2
- P3(goal)
.
Для восстановления пути вы можете создать еще одну родительскую матрицу pi[N][N]
, если самый короткий путь исходит сверху, тогда pi[i][j] = (i-1, j)
если идет от левого pi[i][j] = (i, j-1)
если невозможно достичь этой ячейки pi[i][j] = null(whatever you want)
.
В общем, мой подход:
P1
между начальной вершиной (той, которая представляет Array [0] [0]), и будет использоваться серая вершина (A *).P2
между серой вершиной и конечной вершиной (той, которая представляет Array [N-1] [N-1]).P1
и P2
не пересекаются, то P1
за которым следует P2
является оптимальным решением.P1
и P2
пересекаются, то удалите вершины в пересеченной части, повторите действия 2 и 3 снова, чтобы найти новые кратчайшие пути P3
и P4
соответственно. оптимальным решением является минимум между P1
за которым следуют P4
и P3
за которыми следует P2
.