Un problema con el programa en lenguaje C

Después de las siguientes modificaciones, no hay problemas de sintaxis ni de vinculación.

main()

{

//clrscr();

camino del laberinto();

}

El siguiente es mi código: (El mismo libro, mi versión C++, consúltelo. Si hay algún problema con la estructura de datos, podemos discutirlo juntos).

¡Cualquiera al que le gusten las matemáticas o la programación es mi amigo!

//Migong.h

//////////////////////////

////////Solución de laberinto//////

/////Autor: Bai Haq////////

/ ///Hora:11.10.2006///

///////////////////////////////// /

/*Categoría:

Matriz:Clase de matriz

Desplazamiento: desplazamiento de búsqueda

Dirección de enumeración: cuatro direcciones

Elemento estructural: Nodo de búsqueda

Migong: clase Laberinto

1. Crea un objeto Migong.

2. Utilice el método Crear para ingresar datos.

3. Utiliza el método de solución para resolver.

Método 4.ShowSolve para mostrar la solución.

5. Puedes reutilizar el método Crear.

6. La entrada sólo puede estar en la esquina superior izquierda.

7. La salida predeterminada está en la esquina inferior derecha.

ShowAllPath: Enumera todas las rutas.

Observaciones:

Por razones de algoritmo, todas las rutas aquí deben estar referenciadas

Entre:

Si dos Si las carreteras son. diferentes en un punto determinado, son caminos diferentes.

B. Si se eliminan uno o más círculos de una carretera, entonces son la misma carretera.

Entre el sentido de la carretera.

*/

# incluir & ltiostream & gt

# incluir & ltstack& gt

# incluir & ltvector & gt

Usar espacio de nombres estándar

#ifndef MIGONG_H

#Define MIGONG_H

///////////// /// ///

//////Clase de matriz/////

///////////////// //

Matriz de categorías {

int * m;

int fila, col

bool iscreate

Público:

matrix(){ m = 0; iscreate = false};

~ Matrix(){ Release();};

bool Create( int, int );

int & ampoperator () (int, int);

int GetRow(){ devolver fila;};

int GetCol( ){ devolver col;};

void release();

void Show(char, char);

};

Matriz booleana: :Create(int r, int c)

{

if(r & lt;= 0 | | c & lt=0) devuelve falso

Liberar ();

fila = r;

col = c;

m = new int[fila * col];

para (int I = 0;i<row*column;i++)

{

*(m+I)= 0;

}

iscreate = true

Devuelve verdadero

}

int & ampMatrix::operator ()(int r, int c)

{

return *(m+r * col+c);

}

void Matrix::Release()

{

Si (iscreate)

{

fila = col = 0;

Si (m) elimina []m; p>

m = 0;

}

iscreate = false

}

matriz vacía ::Show(char blk ='# ', char nblk= ' ')

{

int i, j;

for(I = 0; i & lt fila; i++ )

{

for(j = 0; j & ltcolj++)

{

si (* (m+i*col +j) == 0)

cout & lt& ltnblk

Otros

cout & lt& ltblk

}

cout & lt& ltendl

}

}

/////////////// ////// /////////

////Definición de estructuras de datos relacionadas con el laberinto///

///////// //// /////////////////

Desplazamiento de estructura {

int a, b

};

>Dirección de enumeración {

_S = 0,

_E,

_N,

_W

};

Estructura del elemento {

int fila, col, dir.

};

Nivel de Migong{

Movimiento de desplazamiento estático[4];

Laberinto de matriz;

Marca de matriz;

int fila;

int col

int desr

desc territorio;

pila & litem & gtstk

bool iscreate

int longitud de ruta;

bool GetPath();

bool IsInPath(int, int);

Público:

migong(){ se resuelve = falso; resultado = 0; longitud de la ruta = fila = col = 0;

~米公(){ Release();};

bool Create(int*, int, int, int, int);

void Solve();

p>

liberación de vacío();

laberinto de salida vacío();

void ShowSolve(char, char);

Público:

Booleano disuelto;

item*resultado;

};

compensaciones Migong::move[4]= { { 1, 0} , {0, 1},

{-1, 0}, {0, -1}};

/////////////// //////////////

//Los datos del laberinto deben ser ilimitados//

/////////// / ////////////////

bool Migong::Create(int* m, int r, int c, int desrow=-1, int descol=- 1 )

{

si(r & lt; = 0 | | c & lt=0) devuelve falso

publicar();

if(desrow = =-1 | | descol = =-1)

{

desr = r;

desc = c;

p>

}

Otro

{

desr = desrow

desc = decoer;

}

fila = r;

col = c;

Laberinto. Crear(r+2,c+2);

Marcar.

Crear(r+2, c+2);

int i, j

for(I = 0; i<r+2; i++)

{

for(j = 0; j & ltc+2; j++)

{

if(j = = 0 | | j = = c +1 | | I = = 0 | I = = r+1)

{

marca(i,j) = laberinto(i,j)= 1;

p>

}En caso contrario

{

marca(i,j)= 0;

laberinto(i,j)= m[ ((I -1)* col+j-1)];

}

}

}

return iscreate = true

}

bool Migong::GetPath()

{

Marca(1,1)= 1;

Temperatura del artículo;

temp .col = 1;

temp .fila = 1;

temp dir = _ S

STK . push(temp);

Y (!stk.empty()

{

temp = STK . top();

STK pop();

int i = temp.row

int j = temp.col

int d = temp.dir

while(d & lt; 4)

{//Determina el siguiente punto de búsqueda en función del estado del punto actual

int g = i. + mover[d].

int h = j + mover[d].

if(g = = desr & amp; & ampdesc)

{

p>

Return true

}

//Si este punto no es un punto de obstáculo y no ha sido buscado, entonces este punto se puede buscar

if ( laberinto(g, h) = = 0 & amp; & ampmark(g, h)==0)

{

mark(g , h)= 1;

temp. fila = g;

Temperatura col = h

dir = d+1;

STK . push(temp);

I = g;

j = h;

d = _ S; punto

}

else d++;

}

}

Devuelve falso

}

void Migong::Solve()

{

se resuelve = GetPath();

si (se resuelve)

{

longitud de la ruta = stk .size();

resultado = nuevo elemento[longitud de la ruta];

for(int i = 0;i<pathlength;i++ )

{

*(resultado+I)= STK . p>

/ /cout <<"(" <<(*(resultado+i)). fila<<","<<(*(resultado+i)).

col & lt& lt")" & lt& ltendl

}

}

Y (!stk.empty()

STK . pop();

}

void Migong::Release()

{

if (iscreate)

{

laberinto.publish();

mark.publish();

fila = col = 0;

si (resultado)

Eliminar[]resultado;

resultado = 0;

while(!stk.empty()

STK . pop();

}

iscreate = false

issolved = false

Longitud de la ruta = 0;

}

void Migong::OutputMaze()

{

Si (!iscreate) devuelve;

Laberinto.

show();

}

bool Migong::IsInPath(int r, int c)

{

if (! iscreate ||! Resuelto)

Devuelve falso

Temperatura del proyecto;

for(int I = 0;i<path length;i++)

{

temp = *(resultado+I);

if((temp . fila = = r)&&(columna de temperatura = = grados Celsius)

Devuelve verdadero

}

Devuelve falso

}

void Migong::show solve(char blk = ' # ', char s='o ')

{

Si (!iscreate) devuelve;

Si (!Resolved)

{

cout & lt& lt"Sin solución"

}

Otros

{

int i,j;

for(i=0;i<row+2;i++)

{

for(j=0;j <col+2;j++)

{

if((I = = 1 &&j ​​​​= = 1)| |(I = = desr &&j ​​==desc))

{

cout & lt& lts;

}

si no (laberinto(i, j) = = 1)

{

cout & lt& ltblk

}else

{

if (IsInPath( i, j))

cout & lt& lts;

Otros

cout & lt& lt' ';

}

}

cout & lt& ltendl

}

}

}

/// //////////// ////////

/////Agotar todos los caminos///

////// /////////// /////

compensaciones mover[4]={ {1, 0}, {0, 1},

{ -1, 0}, {0, -1 }};

Nodo de estructura

{

int fila, col

} ;

vector & ltnode & gt path;

int count;

Booleano es accesible (matriz y laberinto, matriz y . marca, nodo inicio, nodo des)

{

if(beg . fila == des . fila & & ampbeg.col==des.col

{//Si se alcanza, muestra la ruta

count++;

cout & lt& lt"first"

for(int I = 0; i<path.size( );i++)

cout <<"("<<path[i].row<<","<<path[i].

col & lt& lt")";

cout & lt& lt"(" & lt& ltdes.row & lt& lt","& lt& ltdes.col & lt& lt")";

cout & lt& ltendl

Devuelve falso

}

if (laberinto(beg.row, beg.col)==1 | | mark(beg .fila, inicio. col) = = 1

{

Devuelve falso

}

ruta. ;

mark(beg.row,beg.col)=1;

Nodo siguientenodo

for(int I = _ S; i<_ W+ 1; i++ )

{

nextnode.row = comenzar.fila + mover[i].

nextnode.col = comenzar.col + mover[i]. b;

IsReachable(laberinto, marca, siguientenodo, des);

}

ruta . p>

mark(beg. row, beg . col) = 0;

Return false // Si no es exhaustivo, el valor de retorno debe restablecerse de acuerdo con el resultado del bucle for.

}

/*

Parámetro del laberinto, la marca es la matriz del largo y ancho del laberinto más dos

Desir. suma desc es la salida

*/

void FindAllPath(Matrix & Matrix, Matrix&.mark, int desr, int desc)

{

Nodo primero, último;

primera fila = 1;

primera col = 1;

última.fila = desr

. p>

p>

último . col = desc;

IsReachable(laberinto, marca, primero, último

ruta . >

}

/*

m datos de matriz de laberinto

r, c dimensiones de fila y columna

desc desr posición de destino

p>

*/

void ShowAllPath(int* m, int r, int c, int desr=-1, int desc=-1)

{

Laberinto de matrices, marca;

Laberinto. Crear(r+2,c+2);

Marcar.

Crear(r+2, c+2);

if(desr = =-1 | | desc = =-1)

{

desr = r;

desc = c;

}

int i, j

for(I = 0; i<r+ 2; i++ )

{

for(j = 0; j & ltc+2; j++)

{

si( j = = 0 | j = = c+1 | | I = = 0 | I = = r+1)

{

marca(i, j) = laberinto (i, j) = 1;

} En caso contrario {

marca(i, j) = 0;

laberinto(i, j) = m[ ((I) -1)* c+j-1)];

}

}

}

cuenta = 0

FindAllPath(metz,mark,desl,desc);

Laberinto. Publicar();

Marcar. publicar();

}

#endif

//main.cpp

# incluir & ltiostream & gt

#Incluir "Migong.h"

Usar espacio de nombres estándar

int mg[]={

0,0,1,0,0, 0,1,0,//1

0,0,1,0,0,0,1,0,//2

0,0,0,0 , 1,1,0,1,//3

0,1,1,1,0,0,1,0,//4

0,0,0 , 1,0,0,0,0,//5

0,1,0,0,0,0,0,1,//6

0,1 , 1,1,1,0,0,1,//7

1,1,0,0,0,1,0,1,//8

1 , 1,0,0,0,0,0,0,//9

};

void main()

{

Micrómetro m;

Mi (abreviatura de metro)) Create(mg, 9, 8);

Mi (abreviatura de metro)) laberinto de salida(); >

metro (abreviatura de medidor)) solve();

metro (abreviatura de medidor)) show solve()

ShowAllPath(mg, 9, 8 ,9); ,8);

}