最近刷題的確發現動態二維陣列是又麻煩又容易出錯，針對這一點還是想提出一些改進的，直接賦一個大的值就好了，省去很多不必要的麻煩，如果你將這個值換為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的那個值再加回去