深度搜索刷题小结

最近刷题的确发现动态二维数组是又麻烦又容易出错，针对这一点还是想提出一些改进的，直接赋一个大的值就好了，省去很多不必要的麻烦，如果你将这个值换为2，则会出现访问冲突的情况。
迷宫（洛谷-P1605）

#include<iostream>
using namespace std;
 
int start_x,start_y,end_x,end_y;
int map[101][101]={0};
int sum=0;
int a[100][2];
void dfs(int a,int b);
 
int main()
{
    int n,m,t;
    int i,j;
    int x,y;
    
    cin>>n>>m>>t;//输入行、列、障碍数
    cin>>start_x>>start_y>>end_x>>end_y;//输入起点坐标、终点坐标


    
    for(i=1;i<=n;i++)//地图初始化，为1时表示可以通过
        for(j=1;j<=m;j++)
            map[i][j]=1;
 
    for(i=1;i<=t;i++)
    {
        cin>>a[i][0]>>a[i][1];//输入障碍物坐标
        map[a[i][0]][a[i][1]]=0;//将障碍物坐标记录在地图上
    }
    
    dfs(start_x,start_y);//从起点处开始搜索
 
    cout<<sum<<endl;//输出方案数
 
    return 0;
}
 
void dfs(int x,int y)
{
    if(x==end_x&&y==end_y)//搜索终止条件
    {
        sum++;
        return;
    }
    else//进行回溯
    {
        map[x][y]=0;//保存当前坐标
       
        if(map[x][y-1]!=0)//左方，这一步限制了不等于0其实也就是把越界的情况排除了
        {
            dfs(x,y-1);//左方搜索
            map[x][y-1]=1;//还原坐标
        }
        if(map[x][y+1]!=0)//右方
        {
            dfs(x,y+1);//右方搜索
            map[x][y+1]=1;//还原坐标
        }
        if(map[x-1][y]!=0)//上方
        {
            dfs(x-1,y);//上方搜索
         	map[x-1][y]=1;//还原坐标
        }
        if(map[x+1][y]!=0)//下方
        {
            dfs(x+1,y);//下方搜索
            map[x+1][y]=1;//还原坐标
        }
    }
}

另一道深度搜索的题 单词接龙（洛谷-P1019）

# include<iostream>
# include<cstdio>
# include<string>
using namespace std;
int n;
string str[30];
int len_str,sum=0;
int times[30]={0};//存储单词出现次数
 
void dfs(int x)
{
    int i,j;
    int p,q;
    int num;//存储不匹配的字符串个数
    int work;
    
    for(i=1;i<str[x].length();i++)
    {
        num=0;
        for(j=1;j<=n;j++)
        {
            if(times[j]<2)//出现次数少于2次
            {
                if(str[x][i]==str[j][0])//依次比较当前字符串与字符串[j]的头是否相同
                {
                    p=i,q=0,work=0;
                    while(p<=str[x].length()-1)//相同继续比较
                    {
                        if(str[x][p]!=str[j][q])//如果不同
                        {
                            num++;//不匹配的字符串个数+1
                            work++;
                            break;//终止
                        }
                        p++;
                        q++;
                    }
                    if(!work&&q!=str[j].length())//符合条件，进行操作
                    {
                        len_str+=str[j].length()-q;//累加长度
                        times[j]++;//累加次数
                        
                        dfs(j);//继续向下搜索
                        
                        len_str-=str[j].length()-q;//还原长度
                        times[j]--;//还原次数
                    }
                }
                else num++;//不同，不匹配的字符串个数+1
              }
              else num++;//大于两次，不匹配的字符串个数+1
        }
        
        if(num==n&&i==str[x].length()-1)//当不匹配个数与所给个数相同并且长度与所给的长度相同时
        {
              if(sum<len_str) sum=len_str;//如果最大长度小于字符串长度，令最大长度等于字符串长度
              return;
        }
    }
}
int main()
{
    int i;
 
    cin>>n;//输入单词个数n
    for(i=1;i<=n+1;i++)      cin>>str[i];//输入n个单词
    
    for(i=1;i<=n;i++)//令最后一个单词为龙头，寻找以龙头开头的字符串
        if(str[i][0]==str[n+1][0])
        {
            times[i]++;//找到后，出现次数+1
            len_str=str[i].length();//记录字符串长度
            dfs(i);//开始搜索
        }
    
    cout<<sum<<endl;//输出最长长度
    return 0;
}

深度搜索思想还是固定的，就是要注意dfs在进行嵌套后，一定要注意把dfs的那个值再加回去