Búsqueda en profundidad y temas

1. Búsqueda de profundidad primero

1. La búsqueda se refiere a un algoritmo que atraviesa los estados intermedios del problema al conocer el estado inicial y el estado objetivo. En términos simples, la búsqueda es una enumeración más complicada.

2. La búsqueda de profundidad primero es buscar de manera profunda, es decir, enumerar todas las soluciones factibles y seguir intentando hasta encontrar la solución al problema.

Imagina que estás en un laberinto. Cuando estamos en el punto de partida, siempre tenemos que pasar por varios tenedores para encontrar el final del laberinto. Luego, desde el punto de partida, avanza por una carretera. Cuando encuentres un tenedor, elige uno de los tenedores para avanzar. . Si la bifurcación seleccionada está delante de la bifurcación, vuelva a la bifurcación y elija otra bifurcación. Si hay una nueva bifurcación en la bifurcación, ejecute el método anterior nuevamente, para que podamos encontrar el punto final.

En otras palabras, cuando te encuentras con una bifurcación en el camino, siempre usas "profundidad" como la clave para progresar, y no mires atrás sin tocar un callejón sin salida .
Bueno, este método de regresar a la última bifurcación después de encontrar un callejón sin salida se llama método de retroceso .

2. Profundidad: primer método de búsqueda y retroceso.

1. El método de retroceso se refiere a comenzar desde un cierto ángulo del problema, buscar todas las situaciones posibles y luego usar una de ellas como un nuevo punto de partida para continuar explorando hacia abajo. Cuando llegue al final, regrese al último punto de partida y comience a buscar desde otra situación. Y a través de "retroceso" continuo para encontrar el objetivo.

Ejemplo:

La disposición completa de los números: es decir, la disposición completa de 123 es 123,132,213,231,312,321. Es decir, se usan tres números de 1, 2 y 3 para formar un número de 3 dígitos, y no se permiten números repetidos.

Como se muestra en la figura, estipulamos artificialmente que el método de selección de 1, 2 y 3 es seleccionar 1 primero, luego seleccionar 2 y finalmente seleccionar 3. Entonces, si queremos realizar un arreglo completo, es como se muestra.
Estipulamos que el primer número es el primer cuadro ... y así sucesivamente, el código para poner el número en el cuadro:

void  dfs(int step)   
{
  for(i=1;i<=n;i++)   //一共有n个数字，在这里，n=3
  {
    if(book[i]==0)    //等于0表示这个数字还未被放入盒子中
    {
      a[step]=i;      //将数字i放在第step个盒子
      book[i]=1;
      dfs(step+1);      //放下一个数字
      book[i]=0;
     }
  }
  return;
}

Entonces, ¿cuál es el criterio final, es decir, cuando procesamos el n + 1o cuadro pequeño, significa que los n cuadros anteriores se han guardado, entonces daremos salida a esta situación. Eso es:

if(step==n+1)
 {
  for(i=1;i<=n;i++)
     printf("%d ",a[i]);
  printf("\n");
  return;
  }

El código completo es el siguiente:

#include<stdio.h>
int a[10],book[10],n;

void dfs(int step)
{
     int i;
     if(step==n+1)
     {
     	for(i=1;i<=n;i++)  //将这种情况打印出来
     	    printf("%d ",a[i]);
     	printf("\n");
     	return;
     }

   for(i=1,i<=n;i++)
   {
      if(book[i]==0)
      {
         a[step]=i;
         book[i]=1;
         dfs(step+1);
         book[i]=0;
      }
   }
   return;
}

int main()
{
   scanf("%d",&n);
   dfs(1）；
   return 0;
  }

3. Ejemplo de búsqueda profunda, ve a través del laberinto.

Es decir, utilizamos una matriz bidimensional para almacenar el laberinto, el tamaño del laberinto es n * m, las coordenadas del punto final son (p, q), para encontrar la ruta más corta desde el punto inicial hasta el punto final, especificamos el orden para ir a la derecha, abajo, Izquierda, arriba. En la matriz bidimensional que almacena el laberinto, 0 representa el camino que se puede tomar y 1 representa el obstáculo.
El código es el siguiente:

#include<stdio.h>
int n,m,p,q,min=1000000;
int a[20][20],book[20][20];
void dfs(int x,int y,int step)        //x,y为当前点的横纵坐标，step表示已经走过的步数。
{
  int next[4][2]={{0,1),{1,0},{0,-1},{-1,0}};          //分别为向右走，向下，向左，向上
  int tx,ty,k;         //tx,ty为下一个点的横纵坐标
  if(x==p&&y==q)       //判断是否到达终点
  {
     if(step<min)
     	min=step;
     return;
   }

  for(k=0;k<=3;k++)
  {
     tx=x+next[k][0];
     ty=y+next[k][1];
     if(tx<1||tx>n||ty<1||ty>m)
        continue;
     if(a[tx][ty]==0&&book[tx][ty]==0)
     {
        book[tx][ty]=1;
        dfs(tx,ty,step+1);
        book[tx][ty]=0;
     }
  }
  return;
  }

int main()
{
 int i,j,x,y;
 scanf("%d %d",&n,&m);   
 for(i=1;i<=n;i++)
   for(j=1;j<=m;j++)
     scanf("%d",&a[i][j]);       //读入迷宫
 scanf("%d %d %d %d",&x,&y,&p,&q);   //读入起点和终点
 book[x][y]=1;    //标记起点已经走过了，防止重复走
 dfs(x,y,0);
 printf("%d ",min);
 return 0;
}