Syins写的dfs

dfs(深度优先搜索)

深度优先搜索，就是一条道走到底然后慢慢返回，以历遍所有的可能，开始可能觉得dfs和bfs很高大上，应该很难，但实际上它们和所有的算法一样，入门都非常简单，难点无非是在于如何写出判别条件。
dfs通过函数的递归来实现，先判别当前这一步的走法，然后到下一步，考虑之前带来的影响的同时，走出这一步，直到走到尽头，再返回，经历另一种可能
我这里用一个数的全排列来说明dfs的操作过程：

代码👇

#include<iostream>
using namespace std;
int n,b[10],a[10];
void dfs(int s);//dfs函数
int main()
{
    while(cin>>n){
        dfs(0);//个人习惯，从零开始
    }
    return 0;
}
void dfs(int s)
{
    int i;
    if(s==n){//如果到了尾，就输出一次
        for(i=0;i<n;i++){
            if(i!=0)cout<<' ';
            cout<<a[i];
        }
        cout<<endl;
        return;
    }
    for(i=0;i<n;i++){//这里的0-n是对数来说的
        if(b[i]==0){
            a[s]=i+1;//这里别忘了是当前步数，而不是i，否则你会打出来一堆一样的结果
            b[i]=1;//如果放入了，就更新b这个标记数组
            dfs(s+1);//调用下一步
            b[i]=0;//这里别忘了对b这个标记数组的这一个点重置
        }
    }
    return;
}

这里不得不说我看过《Aha！Algorithms》这本书，例子也是从中来的，下面写一下该书中的一段伪代码👇
void dfs（int step）
{
判断边界
尝试每一种可能 for(i=1;i<=n;i++)
{
继续下一步 dfs（step+1）
}
}
这里已经讲的非常详细了，虽然可能有些时候会进行一些微调，但不得不说，这就是dfs的完整思想；
附带zoj1002题解:

代码：

#include<iostream>
using namespace std;
int n,ma,jg;
char a[5][5];
void dfs(int s);
bool pd(int i,int j);
int main()
{
    while(cin>>n){
        if(n==0) break;
        jg=ma=0;
        for(int i=0;i<n;i++){
            cin>>a[i];
        }
        dfs(0);
        cout<<ma<<endl;
    }
    return 0;
}
bool pd(int i,int j)
{
    int m,n;
    if(a[i][j]=='.'){
        for(m=i-1;m>=0;m--){
            if(a[m][j]=='O')return false;
            if(a[m][j]=='X')break;
        }
        for(n=j-1;n>=0;n--){
            if(a[i][n]=='O')return false;
            if(a[i][n]=='X')return true;
        }
        return true;
    }
    return false;
}
void dfs(int s)
{
    int h,l;
    if(s==n*n){
        if(jg>ma)ma=jg;
        return;
    }
    h=s/n;
    l=s%n;
    if(pd(h,l)){
        a[h][l]='O';
        jg++;
        dfs(s+1);
        a[h][l]='.';
        jg--;
    }
    dfs(s+1);
}

dfs的题目，我感觉都差别不大，这题对比上一题最大的区别就是采用了n*n并且只有一个判断，而不是循环（这是因为在一个点只有两种可能：放和不放）其实本质是一样的。
再附：经典题解——八皇后问题

代码：

#include<iostream>
using namespace std;
int t,hh;
char a[9][9];
void dfs(int s);
bool pd(int h,int l);
int main()
{
    int i,j;
    for(i=0;i<8;i++){
        for(j=0;j<8;j++){
            a[i][j]='#';
        }
    }
    dfs(0);
    cout<<"--------"<<endl;
    cout<<"总共有"<<t<<"种解法"<<endl;
    return 0;
}
bool pd(int h,int l)
{
    int i,j;
    for(i=h-1;i>=0;i--)
        if(a[i][l]=='Q')return false;
    for(i=l-1;i>=0;i--)
        if(a[h][i]=='Q')return false;
    for(j=l-1,i=h-1;i>=0&&j>=0;i--,j--)
        if(a[i][j]=='Q')return false;
    for(i=h-1,j=l+1;i>=0&&j<8;i--,j++)
        if(a[i][j]=='Q')return false;
    return true;
}
void dfs(int s)
{
    int i,h,l;
    if(s==8*8){
        if(hh==8){
            t++;
            cout<<"--------"<<endl;
            for(i=0;i<8;i++)
                cout<<a[i]<<endl;
        }
        return;
    }
    h=s/8;
    l=s%8;
    if(pd(h,l)){
        hh++;
        a[h][l]='Q';
        dfs(s+1);
        hh--;
        a[h][l]='#';
    }
    dfs(s+1);
}

这个就没什么好说了吧，真的是非常经典的dfs问题。