DFS模板

DFS模板

题型分类：
我们可以将DFS题分为两大类：
1 . 地图型：这种题型将地图输入，要求完成一定的任务。因为地图的存在。使得题意清楚形象化，容易理清搜索思路。
AOJ 869-迷宫(遍历地图，四向搜索)
HDU 1035-Robot Motion(指定方向搜索，迷路（循环）判断)
HDU 1045-Fire Net(check函数，回溯)
HDU 1010-Tempter of the Bone(奇偶剪枝，回溯)
2 . 数据型：这种题型没有给定地图，一般是一串数字或字母，要求按照一定的任务解题。相对于地图型，这种题型较为抽象，需要在数据中进行搜索。数据以数组的形式存储，那么只要将数组也当作一张图来进行搜索就可以了。
HDU 1016-Prime Ring Problem(回溯、素数筛)
HDU 1258-Sum It Up(双重DFS递归，去重技巧)
HDU 1015-Safecraker(回溯，字符处理)
HDU 2676-Sudoku(抽象，回溯)

核心思想：

void dfs()//参数用来表示状态
{
    if(到达终点状态)
    {
        ...//根据题意添加
        return;
    }
    if(越界或者是不合法状态)
        return;
    if(特殊状态)//剪枝
        return ;
    for(扩展方式)
    {
        if(扩展方式所达到状态合法)
        {
            修改操作;//根据题意来添加
            标记；
            dfs（）；
            (还原标记)；
            //是否还原标记根据题意
            //如果加上（还原标记）就是 回溯法
        }  

    }
}

迷宫（一）

一天蒜头君掉进了一个迷宫里面，蒜头君想逃出去，可怜的蒜头君连迷宫是否有能逃出去的路都不知道。

看在蒜头君这么可怜的份上，就请聪明的你告诉蒜头君是否有可以逃出去的路。

输入格式

第一行输入两个整数 n 和 m，表示这是一个n×m 的迷宫。

接下来的输入一个 n 行m 列的迷宫。其中 'S' 表示蒜头君的位置，'*'表示墙，蒜头君无法通过，'.'表示路，蒜头君可以通过'.'移动，'T'表示迷宫的出口（蒜头君每次只能移动到四个与他相邻的位置——上，下，左，右）。

输出格式

输出一个字符串，如果蒜头君可以逃出迷宫输出"yes"，否则输出"no"。

数据范围

1≤n,m≤10。

样例输入1

3 4

S**.

..*.

***T

样例输出1

no

样例输入2

3 4

S**.

....

***T

样例输出2

Yes

#include<iostream>
#include<bits/stdc++.h>
using namespace std;
int n,m;
char maps[15][15];
int vis[15][15];
int flag=0;
int dir[4][2]={{1,0},{-1,0},{0,-1},{0,1}};
//判断路是否能走
bool check(int x,int y){
    return x>=1&&x<=n&&y>=1&&y<=m&&maps[x][y]!='*'&&vis[x][y]==0;
}
void dfs(int x,int y){
    //终点就退出
    if(maps[x][y]=='T'){
        flag=1;
        return ;
    }
    if(!check(x,y))    return ;
    vis[x][y]=1;
    for(int i=0;i<4;i++){
        int newx=x+dir[i][0];
        int newy=y+dir[i][1];
        dfs(newx,newy);
    }
    return ;
}
int main()
{
    int start,starty;
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>maps[i][j];
            if(maps[i][j]=='S'){
                start=i;
                starty=j;
            }
        }
    }
    dfs(start,starty);
    if(flag==1)
        cout<<"yes"<<endl;
    else
        cout<<"no"<<endl;
}

hdu 1035 Robot Motion

问题描述

机器人已被编程为遵循其路径中的指令。网格中放置了机器人下一步移动方向的说明。可能的指令为

N北（在页面上方）

S南（在页面下方）

E东（在页面右侧）

W西（在页面左侧）

例如，假设机器人从北（顶部）启动网格1的一侧），并向南（向下）开始。显示了机器人遵循的路径。机器人在离开网格之前会先通过网格中的10条指令。

比较Grid 2中发生的情况，机器人仅执行3条指令一次，然后通过8条指令开始循环，并且永不退出。

您将编写一个程序，该程序确定机器人离开网格需要多长时间或机器人如何循环。

输入值

将有一个或多个网格供机器人导航。每个数据的格式如下。在第一行上，三个整数用空格隔开：网格中的行数，网格中的列数以及机器人从北方进入的列数。

可能的输入列从左侧的一开始编号。然后出现方向指示的行。每个网格将具有至少一个且最多10个行和列的指令。指令行仅包含字符N，S，E或W，没有空格。

输入的结尾由包含0 0 0的行指示。

输出量

对于输入中的每个网格，只有一行输出。机器人要么遵循一定数量的指令，然后从四个侧面中的任一侧退出网格，要么机器人一次遵循一定数量位置上的指令，

然后重复遵循一定数量位置上的指令。下面的示例输入对应于上面的两个网格，并说明了两种输出形式。单词“ step”总是紧随其后的是“（s）”，无论之前的数字是否为1。

样本输入

3 6 5 NEESWE WWWESS SNWWWW 4 5 1 SESWE EESNW NWEEN EWSEN 0 0

样本输出

10个步骤可在8个步骤的循环之前退出3个步骤

#include<iostream>
#include<bits/stdc++.h>
using namespace std;

char maps[15][15];
int sum,m,n,s,flag,mark,mark_x,mark_y,vis[15][15];
void dfs(int x,int y,int ant){
    if(x<0||y<0||x==m||y==n){//如果出界 就证明能够出去了
        sum=ant;
        return ;
    }
    if(vis[x][y]){//自身成环 记录目前的步数和坐标
        flag=1;
        mark_x=x,mark_y=y;
        mark=ant;
        return ;
    }
    vis[x][y]=ant+1;
    if(maps[x][y]=='W'&&!sum&&!flag)
        dfs(x,y-1,++ant);
    if(maps[x][y]=='E'&&!sum&&!flag)
        dfs(x,y+1,++ant);
    if(maps[x][y]=='N'&&!sum&&!flag)
        dfs(x-1,y,++ant);
    if(maps[x][y]=='S'&&!sum&&!flag)
        dfs(x+1,y,++ant);
}
int main(){
    while(true)
    {
        cin>>m>>n;
        if(m==0||n==0)
            break;
        cin>>s;
        for(int i=0;i<m;i++)
            cin>>maps[i];
        sum=flag=0;
        memset(vis,0,sizeof(vis));
        dfs(0,s-1,0);
        if(!flag)
            cout<<sum<<" step(s) to exit"<<endl;
        else
        cout<<vis[mark_x][mark_y]-1<<" step(s) before a loop of "<<mark-vis[mark_x][mark_y]+1<<" step(s)"<<endl;
    }
}

Tempter of the Bone

小狗在一个古老的迷宫中发现了一根骨头，这使他非常着迷。但是，当他捡起它时，迷宫开始摇晃，小狗可以感觉到地面下沉。他意识到骨头是一个陷阱，

他拼命试图摆脱这个迷宫。迷宫是一个矩形，大小为N×M。迷宫中有一扇门。刚开始时，门是关闭的，它将在第T秒打开一小段时间（少于1秒）。

因此，小狗必须在第T秒精确到达门。每秒钟，他可以将一个块移动到上，下，左和右相邻的块之一。一旦他进入一个街区，该街区的地面将开始下沉并在下一秒消失。

他不能在一个街区停留超过一秒钟，也不能搬到一个拜访的街区。可怜的小狗可以生存吗？请帮助他。

输入值

输入包含多个测试用例。每个测试用例的第一行包含三个整数N，M和T（1 <N，M <7； 0 <T <50），分别表示迷宫的大小和门打开的时间。 。接下来的N行给出迷宫的布局，每行包含M个字符。字符是以下之一：

‘X’: a block of wall, which the doggie cannot enter;

‘S’: the start point of the doggie;

‘D’: the Door; or

‘.’: an empty block.

输入以三个0终止。该测试用例将不被处理。

输出

对于每个测试用例，如果小狗可以存活，则在一行中打印“YES”，否则打印为“NO”。

样例输入：

4 4 5

S.X.

..X.

..XD

....

3 4 5

S.X.

..X.

...D

0 0 0

样例输出：

NO

YES

奇偶剪枝

把矩阵看成如下形式： 
0 1 0 1 0 1 
1 0 1 0 1 0 
0 1 0 1 0 1 
1 0 1 0 1 0 
0 1 0 1 0 1 
从为 0 的格子走一步，必然走向为 1 的格子 。
从为 1 的格子走一步，必然走向为 0 的格子 。
即： 
从 0 走向 1 必然是奇数步，从 0 走向 0 必然是偶数步。

所以当遇到从 0 走向 0 但是要求时间是奇数的或者 从 1 走向 0 但是要求时间是偶数的，都可以直接判断不可达！

#include<iostream>
#include<bits/stdc++.h>
using namespace std;

int n,m,t,escape;
int dx,dy,sx,sy;
char maps[15][15];
int dir[4][2] = {{1,0}, {-1,0}, {0,1}, {0,-1}};        //上下左右4个方向
void dfs(int sx,int sy,int cnt){
    int tmp;
    //不满足要求超过地图范围
    if(sx>n||sx<1||sy>m||sy>m||sy<1){
        return;
    }
    //完成条件
    if(sx==dx&&sy==dy&&cnt==t){
        escape=1;
        return;
    }
    if(escape) return;
    //T−k−f<0
    tmp=(t-cnt)-abs(sx-dx)-abs(sy-dy);
    if(tmp<0||tmp&1)return;
    for(int i=0; i<4; i++ ){
        int newx = sx+dir[i][0];
        int newy = sy+dir[i][1];
        if( maps[newx  ][ newy ] != 'X'){
            maps[ newx ][ newy ] = 'X';
            dfs(newx, newy, cnt+1);
            maps[ newx ][newy ] = '.';
        }
    }
    return;
}
int main(){
    while (scanf("%d %d %d",&n,&m,&t)&&(m+n+t)){
        int wall=0;
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= m; j++){
                cin>>maps[i][j];
                if(maps[i][j]=='S') {
                    sx=i;
                    sy=j;
                }
                else if( maps[i][j]=='D' ) {
                    dx=i;
                    dy=j;
                }
                else if( maps[i][j]=='X' )
                    wall++;
            }
        }
        if( n*m-wall <= t ){
            cout << "NO" << endl;
            continue;
        }
        escape = 0;
        maps[sx][sy] = 'X';
        dfs(sx,sy,0);
        if( escape )
            cout << "YES" << endl;
        else
            cout << "NO" << endl;
    }
}

HDU 1016-Prime Ring Problem

#include<iostream>
#include<bits/stdc++.h>
using namespace std;
int n;
int a[123],used[123];
int ok(int n){
    int i;
    for(i=2;i<n;i++){
        if(n%i==0) return 0;
    }
    return 1;//素数
}
void dfs(int x){
    int i;
    if(x==n){
        int j;
        if(ok(1+a[x-1])==1){  //头尾和判断
            cout<<"1";
            for(j=1;j<n;j++)  cout<<" "<<a[j];  //构造够n个了 输出数组。
            cout<<endl;
            return ;
        }
    }
    for(i=2;i<=n;i++){
        if(used[i]==0&&ok(i+a[x-1])==1) { //加上判断和是不是素数
            a[x]=i;
            used[i]=1;  //标记使用了
            dfs(x+1);    //对第x+1个进行构造
            used[i]=0;  //标记复原
        }
    }
    return ;
}
int main(){
    int cas=1;
    while(scanf("%d",&n)!=-1){
        memset(used,0,sizeof(used)); // 赋值都没被使用过。
        used[1]=1;
        a[0]=1;
        printf("Case %d:\n",cas++);
        dfs(1);  //从第1个数开始构造，因为以1开始
        cout<<endl;
    }
    return 0;
}