Recherche approfondie et sujets

1. Recherche en profondeur

1. La recherche fait référence à un algorithme qui traverse les états intermédiaires du problème en connaissant l'état initial et l'état cible. En termes simples, la recherche est une énumération plus compliquée.

2. La recherche en profondeur d'abord consiste à rechercher de manière approfondie, c'est-à-dire à énumérer toutes les solutions possibles et à continuer jusqu'à ce que vous trouviez la solution au problème.

Imaginez que vous êtes dans un labyrinthe. Lorsque nous sommes au point de départ, nous devons toujours passer par différentes fourches pour trouver la fin du labyrinthe. Puis à partir du point de départ, avancer le long d'une route. Lorsque vous rencontrez une fourche, choisissez l'une des fourches . Si la fourche sélectionnée est devant la fourche, revenez à la fourche et choisissez une autre fourche. S'il y a un nouveau fork dans le fork, exécutez à nouveau la méthode ci-dessus, afin que nous puissions trouver le point final.

En d'autres termes, lorsque vous rencontrez une bifurcation sur la route, vous utilisez toujours la «profondeur» comme clé pour progresser, et ne regardez pas en arrière sans toucher une impasse .
Eh bien, cette méthode de retour à la dernière fourche après avoir rencontré une impasse est appelée la méthode de retour en arrière .

2. Méthode de recherche-retour en profondeur d'abord.

1. La méthode de retour en arrière consiste à partir d'un certain angle du problème, à rechercher toutes les situations possibles, puis à utiliser l'une d'entre elles comme nouveau point de départ pour continuer à explorer vers le bas, de sorte qu'une "route" soit supprimée. Lorsque vous atteignez la fin, revenez au dernier point de départ et commencez à chercher dans une autre situation. Et grâce à un «retour en arrière» continu pour trouver le but.

Exemple:

L'arrangement complet des nombres: Autrement dit, l'arrangement complet de 123 est 123.132.213.231.312.321. Autrement dit, trois nombres de 1, 2 et 3 sont utilisés pour former un nombre à 3 chiffres et aucun nombre répété n'est autorisé.

Comme le montre la figure, nous stipulons artificiellement que la méthode de sélection de 1, 2 et 3 consiste à sélectionner 1 en premier, puis 2 et enfin 3. Ensuite, si nous voulons effectuer un arrangement complet, c'est comme indiqué.
Nous stipulons que le premier numéro est la première case ... et ainsi de suite, le code pour mettre le numéro dans la case:

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;
}

Alors, quel est le critère de fin, c'est-à-dire que lorsque nous traitons la n + 1ème petite boîte, cela signifie que les n boîtes précédentes ont été mises de côté, nous sortirons cette situation. Soit:

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

Le code complet est le suivant:

#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. Exemple de recherche approfondie, parcourez le labyrinthe.

Autrement dit, nous utilisons un tableau à deux dimensions pour stocker le labyrinthe, la taille du labyrinthe est n * m, les coordonnées du point final sont (p, q), pour trouver le chemin le plus court du point de départ au point final, nous spécifions l'ordre pour aller à droite, vers le bas À gauche, en haut. Dans le tableau bidimensionnel contenant le labyrinthe, 0 représente le chemin qui peut être emprunté et 1 représente l'obstacle.
Le code est le suivant:

#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;
}