深度优化搜索DFS（2023.4.6）

假如有编号为1,2,3的3张扑克牌和编号为1,2,3的3个盒子。将这3张扑克牌分别放入3个盒子一共有几种不同的放法呢？

DFS会首先把一种可能的情况尝试到底，才会回溯去尝试下一种情况，只要找到一种情况，就可以返回了。但是BFS必须所有可能的情况同时尝试，在找到一种满足条件的结果的同时，也尝试了很多不必要的路径；如果只是要找到某一个结果是否存在，那么DFS会更高效。

例题代码

#include<stdio.h>
int a[10],book[10],n;
//这里还有需要注意的地方C语言全局变量默认为0

void  dfs(int step){ //此时在第step盒子面前，需要往里面放第i张扑克牌
    int i;
    if(step==n+1){    //这里说明前面的n个盒子已经放好了，这是dfs结束的标志 
        for(i=1;i<=n;i++)
            printf("%d",a[i]);
        printf("\n");
        
        return ;
        /* 
        注意这个 return 它的作用不是返回主函数，而是返回上一级的dfs函数
        
        例：如果此时是  dfs(5),遇到这个 return 就会回到上一级的 dfs函数 
        也就是dfs(4),但此时dfs(4)的大部分语句已经执行了，只需要接着执行 book[i]=0
        然后继续进入for循环进入下一次的 dfs函数，直到结束。         
        */ 
        
    }
     for(int i=1;i<=n;i++){
        if(book[i]==0){  //说明i号扑克牌还在手里，需要放入step号盒子
            a[step]=i;//将i号扑克牌放到第step个盒子中
            book[i]=1;//此时i号扑克牌已经被使用        
            dfs(step+1);
            /*注意这里是自己调用自己，表示此时走到了第step+1个盒子面前*/        
            book[i]=0;
            /*book[i]=0表示dfs调用结束了，换句话说就是扑克牌已经全部放完了
              需要按照顺序将扑克牌收回，重新放，也就是前面所说的
             */
        }
    }
    return;//这里表示这一级别的dfs函数已经结束了，返回上一级 dfs函数 

}
int main(){
    scanf("%d",&n);
    dfs(1);   //dfs函数的开始 
    return 0;
}
 

**DFS基本模型**

void dfs(int step){
    //判断边界
    //尝试每一种可能 for(i=1;i<=n;i++){
        //继续下一步 dfs(step+1)
        }
    返回
}
 

迷宫问题

处于迷宫入口的小明（1,1），寻找位于（p，q）的小红，也就是最短路径问题 其中n表示行，m表示列

解析

首先要把这个迷宫看作一个二维数组，每走一步就相当于x或者y变化

使用二维数组表示小明的下一步。

int next[4][2]={
 {0,1), //向右走一步
 {1,0},//向下走一步
 {0,-1},//向左走一步
 {-1,0}};//向上走一步

通过这个方向数组，使用循环就很容易获得下一步的坐标。这里可以用tx，xy来表示。

for(k=0;k<=3;k++){   //下一步的坐标
    tx=x+next[k][0]; //下一步的坐标：当前的+下一步要走的
    ty=y+next[k][1];//下一步坐标：当前的+下一步要走的
}
 

下面来对下一点（tx,ty） 进行一些判断。
包括是否越界，是否为障碍物，已经这个点是否被访问。所以也要一个book[tx][ty]来记录点是否被访问。如果这个点符合所有要求，就继续寻找下一个点，也就是 dfs( tx,ty,step+1)。
注意：a[][]等于0表示该点不是障碍
还有book[][]等于0表示该点还没走过

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;  
        //运行到这里，说明这条路，则需要换个方向，也就是重新进入for循环
    if(a[tx][ty]==0 && book[tx][ty]==0){
        book[tx][ty]=1; //标记这个点走过
        dfs(tx,ty,step+1); //进行下一步
        book[tx][ty]=0;   //重新尝试，退回到上一个点的位置
        }
    
}

最后一步，如何判断小明已经找到小红了。
void dfs(int x,int y,int step){   //step用来表示找到小红，小明走了多少步
    if(x==p&& y==q){  //说明已经找到了小红   
        if(step<min)
            min=step;
        return ;   //返回上一步，继续寻找其他路径
        }
    return 0;
    }

话不多说，直接上源代码。

#include<stdio.h>
int book[51][51],a[51][51];
int n,m,p,q,min=99999;
    int next[4][2]={
                     {0,1}, //向右走一步
                    {1,0},//向下走一步
                    {0,-1},//向左走一步
                    {-1,0}};//向上走一步

void dfs(int x,int y,int step){   //step用来表示找到小红，小明走了多少步
    int tx,ty,k;
    if(x==p&& y==q){  //说明已经找到了小红  
    /*
    还要说明一点：这里 为什么是（x，y），而不是（tx，xy） 
    其实很简单 就是上一个dfs()函数传过来的坐标 ，做了这个dfs()函数的形参 
    换句话说：就是判断点是否找到小红 
    */ 
        if(step<min)
            min=step;
        return ;   
        /*返回上一步，继续寻找其他路径（就是退回到上一个坐标，重新找其他路径）
           回到上一个dfs()函数 
        
        */ 
        }
        
    for(k=0;k<=3;k++){   //下一步的坐标
        tx=x+next[k][0]; 
        ty=y+next[k][1];
    
            //判断是否越界,越界则重新进入for循环 
            if(tx<1 || tx>n || ty<1 || ty>m)
                continue;  
                //运行到这里，说明这条路，则需要换个方向，也就是重新进入for循环
            if(a[tx][ty]==0 && book[tx][ty]==0){
                book[tx][ty]=1; //标记这个点走过
                dfs(tx,ty,step+1); //进行下一步
                book[tx][ty]=0;   //重新尝试，退回到上一个点的位置
        }
    
        }
        return ;   //执行到这里，这层dfs()函数已经结束，则要回到上一层dfs()函数 
    }

int main(){
    int i,j,startx,starty;
    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",&startx,&starty);  //小明的坐标 
    scanf("%d %d",&p,&q);            //小红的坐标 
    
    book[startx][starty]=1;         //起始点标记，就不会回到这个点了 
    dfs(startx,starty,0);      //开始寻找最短路径 
    
    printf("%d",min);        //输出最短路径 
    return 0;
}
 

洛谷实战

任何一个大于1的自然数n，总可以拆分成若干个小于n的自然数之和。
当n=7共14种拆分方法：
7=1+1+1+1+1+1+1
7=1+1+1+1+1+2
7=1+1+1+1+3
7=1+1+1+2+2
7=1+1+1+4
7=1+1+2+3
7=1+1+5
7=1+2+2+2
7=1+2+4
7=1+3+3
7=1+6
7=2+2+3
7=2+5
7=3+4
total=14

#include<stdio.h>
int sum=0,n;
int a[10];
void dfs(int x,int y)
{
    a[y]=x;
    if(sum==n)
    {
        printf("%d=",n);
        for(int i=1;i<y;i++)
        {
            printf("%d+",a[i]);
        }
        printf("%d\n",a[y]);
    }
    
    else
    {
        for(int i=a[y];i<n;i++)
        {
            if(sum+i<=n)
            {
                sum+=i;
                dfs(i,y+1);
                sum-=i;
            }
        }
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        sum+=i;
        dfs(i,1);
        sum-=i;
    }
    return 0;
}