Descripción Título original

narrativa tema

Cosas tienen un mapa, hermana de papel para encontrar el mapa. Pantalla de mapa, 0 puede ir, no puede ir 1 representa la esquina superior izquierda es la entrada a la esquina inferior derecha es el papel de la hermana, estas dos posiciones para asegurar cero. Ahora que conocemos el mapa, y luego rellenarlo no es difícil encontrar el papel de la hermana, compila un programa, material de escritura para encontrar la ruta de papel hermana menor.

ENTRADA

De entrada es una matriz de 5 x 5 en dos dimensiones, a sólo los dos números 0,1, las posiciones de representación en la figura.

SALIDA

Una pluralidad de líneas de salida, representa el camino más corto desde la parte superior izquierda para bajar coordenadas esquina derecha secuencialmente pases, con formato como se muestra en la muestra. Garantizar que los datos tiene una solución única.

Ejemplo de entrada

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

Ejemplo de salida

(0, 0)
(1, 0)
(2, 0)
(3, 0)
(3, 1)
(3, 2)
(2, 2)
(1, 2)
(0, 2)
(0, 3)
(0, 4)
(1, 4)
(2, 4)
(3, 4)
(4, 4)

reiteración

Es un laberinto simple, encontrar un camino más corto, registrar el camino trazado, porque es el camino más corto requiere que lo más conveniente es la BFS.

Ideas de resolución de problemas

Descripción general de la

BFS BFS parte bordo está desnudo no de largo alcance proceso de tratamiento, una matriz, bidimensional con VIS [] [] sobrevivir, no puede acceder al estándar local -2 accesible lugar superíndice -1, n representa el número después de acceder la distancia desde el punto de partida en él.
Tenga en cuenta que la selección de la sección de salida del programa, cuando estaba más inclinado a escribir una salida recursiva, pero se puede pensar a mí mismo deriva de resolución de problemas, la salida es siempre un desastre, simplemente abrió una del vector <struct Punto>
, con matriz bidimensional de la estructura dis [] [] para mantener un punto de origen, a continuación, imprimir () en el tratamiento de retrocesión es buena, aunque cuota de espacio mucho, pero sin pensar en la resolución de frontera recursivo es también bastante factible.
versión recursiva de la función print () a continuación

point dis[maxn][maxn];
vector<point> v;
void print(point &p)
{
	point target=p;
	v.push_back(p);
	while(target.x!=0 | target.y!=0)
	{
		target=dis[target.x][target.y];
		v.push_back(target);
	}
	for(int i=v.size()-1;i>=0;i--)
	{
		printf("(%d, %d)\n",v[i].x,v[i].y);
	}
}

Más tarde se encontró recursiva mal array (estúpida .jpg grito), la escritura recursiva más programación de EE.UU., la despierta el cerebro, entonces es más factible escribir
una versión recursiva de la impresión () de la siguiente

point dis[maxn][maxn];
vector<point> v;
void print(point &p)
{
    point target=p;
    if(target.x==0 && target.y==0)
    {
        printf("(%d, %d)\n",target.x,target.y);
        return;
    }
    print(dis[target.x][target.y]);
    printf("(%d, %d)\n",target.x,target.y);
}

El almacenamiento de datos

El título utilizado en el almacenamiento de datos y

Nombre del tipo y nombre de la variable	El significado práctico
int dx [], dy []	del array
int fuerza [] []	Distancia de un punto de origen
dis punto struct [] []	Un punto de origen en el curso de BFS

resumen

Comparativa de agua un problema de asistencia, prestar atención a buen formato PE no aparece, básicamente, no puede salir mal.

punto mejorada

Esta pregunta es para No.

título de la fuente

#include<iostream>
#include<queue>
#include<stdio.h>
#include<string.h>
#include<map>
#include<vector>
using namespace std;
struct point
{
    /* data */
    int x;
    int y; 
};
const int maxn=10;
int dx[]={+1,-1,0,0};
int dy[]={0,0,+1,-1};
int vis[maxn][maxn];
point dis[maxn][maxn];
vector<point> v;
void print(point &p)
{
	point target=p;
	v.push_back(p);
	while(target.x!=0 | target.y!=0)
	{
		target=dis[target.x][target.y];
		v.push_back(target);
	}
	for(int i=v.size()-1;i>=0;i--)
	{
		printf("(%d, %d)\n",v[i].x,v[i].y);
	}
}
void bfs(int sx,int sy,int tx,int ty)
{
	point target={tx,ty};
    point the_begin={sx,sy};
    queue<point> Q;
    Q.push(the_begin);
    vis[sx][sy]=0;
    while(!Q.empty()){
        point now=Q.front(); Q.pop();
        if(now.x==tx &&now.y==ty)
        print(target);
        for(int i=0;i<4;i++){
            int newx=now.x+dx[i],
                newy=now.y+dy[i];
                point start={now.x,now.y};
                point finish={newx,newy};
                if(newx>=0 && newx<=4 && newy>=0 && newy<=4 && vis[newx][newy]==-1){
                	vis[newx][newy]=vis[now.x][now.y]+1;
                    Q.push(finish);
                    dis[newx][newy]=start;
            }
        }
    }
}
int main()
{
    memset(vis,-1,sizeof(vis));
    for(int i=0;i<5;i++)
    {
        for(int j=0;j<5;j++)
        {
            int number=0;
            cin>>number;
            if(number==1)
            {
                vis[i][j]=-2;
            }
        }
    }
	bfs(0,0,4,4);
    return 0;
}