训练第二周之DFS(深度优先搜索)

周一听了副会长讲课，讲得不是很清楚，很迷糊的就去刷题去了，在题解和同学帮助下，花了大把大把的时间才刷了那么几题，结果对DFS还是不清楚，感觉事倍功半了。。。

基本简介：

深度优先搜索（Depth-First-Search）是搜索算法的一种。是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所有边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。(这是百度上找的，看完一脸懵逼)所以我有找了个图片，一下就明朗了。

根据图片，很明显是从v1开始，跟着红箭头走，直到到达v5无法再深入了，开始按着蓝箭头返回，返回到v8，没有其他路走，接着返回，回到v1发现第二条路，又按着红箭头到v3，再到v7，最后回到v1，至此所有的点都搜索了一遍。

例题：

1、Placing apples-百练1664

感受：这题代码简单但是我觉得很有难度。

思路：f(n,m)为n个相同苹果m个相同的盘子的放法，就分为两种情况，至少一个盘子是空的，所有盘子都有苹果的。第一种情况，去掉空盘子没影响，就是f(n,m)=f(n,m-1)；第二种情况就是从所有盘子里拿掉一个苹果也没影响，即f(n,m)=f(n-m,m)。最终n会等于0或者m会等于1，以此来递归。

代码：

#include<cstdio>
using namespace std;
int sum(int n,int m)
{
    if(n==0||m==1)//没有苹果或者只有一个盘子
        return 1;
    if(n<m)//苹果比盘子少的情况
        return sum(n,n);
    return sum(n,m-1)+sum(n-m,m);//至少一个盘子是空的，所有盘子都有苹果这两种情况放法加起来
}
int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        int n,m;
        scanf("%d%d",&n,&m);
        printf("%d\n",sum(n,m));
    }
}

2、熄灯问题-百练2811

感受：周三一整天就扑在这上面了，还是想看了思路的。。。不过终究没去看题解代码还是挺赞的

思路：这题有2^64种情况，但是如果(1,j)亮，则(2,j)一定按，(1,j)不亮，(2,j)一定不按，这样一行行看下去，那么从按第一行开始，后面行数的按法就已经确定，所以只要把第一行枚举在分别判断就行，就只有2^6种情况。

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int j=1,k=0,t;
int state[80][10]={0},ans[6][8],light[6][8];
int a[3]={0,1,0};
int b[7]={0,1,0,1,0,0,1};
void situation(int num1,int num0)//将num0个0和num1个1全排列
{
    if(num1==0&&num0==0)
    {
        k++;
        for(int i=1;i<=6;i++)//这里是因为我的k已经加1，然而递归回去是接着state[k-1][j]的，所以把state[k-1]全部赋给state[k]
            state[k][i]=state[k-1][i];
        return;
    }
    if(num0==0)
    {
        state[k][j]=1;
        j++;
        situation(num1-1,num0);
        j--;
    }
    else if(num1==0)
    {
        state[k][j]=0;
        j++;
        situation(num1,num0-1);
        j--;
    }
    else
    {
        state[k][j]=1;
        j++;
        situation(num1-1,num0);
        j--;
        state[k][j]=0;
        j++;
        situation(num1,num0-1);
        j--;
    }
}
int guess(int c[])//判断c[]这种熄灯方式能否使所以得灯灭掉，能则返回true，不能返回false
{
    int i,s,m;
    if(t==6){
        for(s=1;s<=6;s++)
            if(light[t-1][s])//只要判断最后一行能否全熄灭就行
                return false;
        return true;
    }
    for(i=1;i<=6;i++)
    {
        if(c[i])//反正不考虑第0行第0列和第7列
        {
            light[t-1][i]=a[light[t-1][i]+1];
            light[t][i-1]=a[light[t][i-1]+1];
            light[t][i]=a[light[t][i]+1];
            light[t][i+1]=a[light[t][i+1]+1];
            light[t+1][i]=a[light[t+1][i]+1];
        }

    }
    t++;
    m=guess(light[t-1]);
    if(m)
        return true;
    else
        return false;
}
void point(int c[])//将符合条件的按法打印出来
{
    int i;
    if(t==6) return;
    int first=1;
    for(i=1;i<=6;i++)
    {
        if(first)first=0;
        else printf(" ");
        printf("%d",c[i]);
    }
    printf("\n");
    for(i=1;i<=6;i++)
    {
        if(c[i])
        {
            light[t-1][i]=a[light[t-1][i]+1];
            light[t][i-1]=a[light[t][i-1]+1];
            light[t][i]=a[light[t][i]+1];
            light[t][i+1]=a[light[t][i+1]+1];
            light[t+1][i]=a[light[t+1][i]+1];
        }
    }
    t++;
    point(light[t-1]);
    return;
}
int main(){
    int i,s;
    for(i=0;i<=6;i++){
        j=1;
        situation(i,6-i);
    }
    for(i=1;i<=5;i++)
        for(s=1;s<=6;s++)
            scanf("%d",&ans[i][s]);//输入灯的状态
    for(i=0;i<k;i++)
    {
        memcpy(light,ans,sizeof(ans));
        t=1;
        s=guess(state[i]);//判断该按法能否全熄灯
        if(s)
            break;
    }
    memcpy(light,ans,sizeof(ans));
    t=1;
    point(state[i]);//打印该按法
    return 0;
}

3、拨钟问题-百练2814

感受：这题错了n次，样例能过，但也只是样例能过，我知道我的dfs写错了，最后只能抄题解

思路：按照每种移动的使用次数一次次递归下去，知道所有的钟全在12点。

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
void dfs(int t,int dep);
int mi=2e9;//记录最小步数
int b[20][20]={{},{1,2,4,5},{1,2,3},{2,3,5,6},{1,4,7},{2,4,5,6,8},{3,6,9},{4,5,7,8},{7,8,9},{5,6,8,9}};//9种移动
int times[10],ans[10],state[10];//每种移动的次数，最小步数的移动序列，九个时钟的状态
int first=1;
int main()
{

    int i,j;
    for(i=1;i<=9;i++)
        scanf("%d",&state[i]);//输入开始时钟状态
    dfs(1,0);
    for(i=1;i<=9;i++)
        for(j=0;j<ans[i];j++)
        {
            if(first) first=0;//第一个前面不输出空格，其他的前面都输出空格，可以学习这种技巧，因为\b没用。。。
            else
                printf(" ");
            printf("%d",i);
        }
    printf("\n");
    return 0;
}

void dfs(int t,int dep)//t为移动的序号，dep为总移动步数
{
    int i,s;
    if(t==10)
    {
        for(i=1;i<=9;i++)//只要有一个时钟没到12点都返回
            if(state[i]%4!=0)
                return;
        if(dep<mi)//记录最小步数的移动序列
        {
            mi=dep;
           for(i=1;i<=9;i++)
                ans[i]=times[i];
        }
        return;
    }
    for(times[t]=0;times[t]<4;times[t]++){//第t种移动的次数，不可能大于4，大于4就回到原状态了
            for(s=0;b[t][s]!=0;s++)
            {
                state[b[t][s]]+=times[t];//记录第s个时钟的状态，转动了times[t]次
            }
            dfs(t+1,dep+times[t]);
            for(s=0;b[t][s]!=0;s++)//还原回溯
            {
                state[b[t][s]]-=times[t];
            }
        }
    return;
}

4、二叉树-百练2756

感受：比较简单，一次过的，直接贴代码了，不过副会长有说可以尝试用bfs，不过我不会

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int xi=1;
void dfs(int x,int y)
{
    if(x==y){
        xi=x;
        return;
    }
    if(x>y)
        swap(x,y);
    if(y%2)
        y=(y-1)/2;
    else
        y=y/2;
    dfs(x,y);
}
int main()
{
    int x,y;
    scanf("%d%d",&x,&y);
    dfs(x,y);
    printf("%d\n",xi);
}

5、八皇后-百练2754

感受：讲到bfs怎么能少了八皇后呢，不过我觉得我写得太复杂了，看来我在学校dfs上还有很长的路走啊

代码：

#include<cstdio>
using namespace std;
int a[100]={0},t=0;
int position[10][10]={0};
void dfs(int n)
{
    int i,j,flag,k;
    if(n==8)
    {
        for(i=0;i<8;i++){
            for(j=0;j<8;j++)
                if(position[i][j])
                    a[t]=a[t]*10+j+1;
        }
        t++;
        return;
    }
    else
    {

            for(j=0;j<8;j++){
                    flag=1;
                for(i=0;i<n;i++)
                    for(k=0;k<8;k++)
                    {
                        if(position[i][k])
                            if(i+k==n+j||i-k+8==n-j+8||position[n][j]||k==j)
                                flag=0;
                    }
                if(flag)
                {
                    position[n][j]=1;
                    dfs(n+1);
                    position[n][j]=0;
                }
            }
            return;
    }
}
int main(){
    int t;
    dfs(0);
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d",&n);
        printf("%d\n",a[n-1]);
    }
    return 0;
}