深度优先搜索DFS


文章目录


算法思想

从初始状态开始，一直往深处走，直到找到解或走不下去为止

递归框架

dfs(dep, ...){ // dep代表目前dfs的深度
    if(找到解||走不下去){
        ...
        return ;
    }
    dfs(dep+1, ...);// 枚举下一种情况
}

CodeForces-1097B Petr and a Combination Lock

中文可提交链接：​​组合锁​​

描述

2019302120031YU 刚刚买了一辆新车，他把车开到加油站准备加油，突然发现油箱上有一把密码锁！但他不知道怎么解锁。锁的刻度为360度，指针一开始指向0。



于是2019302120031YU 给他的汽车经销商打了个电话，他的经销商让他把锁准确地转动n次。第 i 次旋转应该是 ai 度，顺时针或逆时针转都可以，n次旋转之后指针应该再次指向0，即可解锁。

这让2019302120031YU 有点困惑，他不确定哪次旋转应该顺时针，哪次应该逆时针，因为旋转锁的方法有很多。已知输入的数据是每1次锁应该旋转的度数，请你帮助他判断一下是否至少存在一种旋转方法，在n次旋转之后指针会再次指向0。

输入

第 1 行输入 1 个整数 n (1 <= n <= 15)—— 代表旋转次数。

接下来的 n 行里，每 1 行包含 1 个整数 ai (1<=ai<=180)—— 代表旋转度数。

输出

如果做完所有的旋转后，指针能指向0，那么输出一个单词“YES”。否则，输出“NO”。在这种情况下，2019302120031YU 会要求经销商给它换一辆新车。

样例

输入样例1

3
10
20
30

输出样例1

YES

输入样例2

3
10
10
10

输出样例2

NO

输入样例3

3
120
120
120

输出样例3

YES

参考题解

#include <iostream>
using namespace std;
int n;
int a[30];
bool isExist=0; // 
void dfs(int dep, int sum){
    if(dep==n){
        if(sum%360==0)isExist=1;
        return;
    }
    dep++;
    dfs(dep,sum+a[dep]);
    dfs(dep,sum-a[dep]);
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];

    dfs(0,0);
    if(isExist)cout<<"YES";
    else cout<<"NO";
    return 0;
}

POJ-3984 迷宫问题 dfs版

中文可提交链接：​​迷宫问题​​

描述

定义一个二维数组：

int maze[5][5] = {

  0, 1, 0, 0, 0,

  0, 1, 0, 1, 0,

  0, 0, 0, 0, 0,

  0, 1, 1, 1, 0,

  0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

Output

左上角到右下角的最短路径，格式如样例所示。

Sample Input

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

Sample Output

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

参考题解

#include <iostream>
#include <stack>
using namespace std;
int map[7][7];
bool isVis[7][7]; // 用于标记是否被访问过
const int dx[]={0, 1, 0, -1};
const int dy[]={1, 0, -1, 0}; // 方向数组，顺序是下右上左（逆时针）
struct point{
    int x, y;
};
point visLine[30]; // 用于存储当前的最段路径
stack<point> s;
int minLen=30; // 记录最短路径的长度

void dfs(){
    point p=s.top(); // 取栈顶元素

    if(p.x==5&&p.y==5){ // 找到终点
        if(s.size()<minLen){ // 更新最小值和路径
            minLen=s.size();
            for(int i=minLen-1;i>=0;i--)
                visLine[i]=s.top(),s.pop(); // 存储最短路径
            for(int i=0;i<minLen;i++)
                s.push(visLine[i]); // 存好后恢复栈
        }
        s.pop();
        return; // 结束
    }

    point next;
    while (!s.empty()){
        bool canVis= false; //判断是否有路可走
        for(int i=0;i<4;i++){ // 方向数组派上用场
            next.x=p.x+dx[i];
            next.y=p.y+dy[i];
            if(!map[next.x][next.y]&&!isVis[next.x][next.y]){ // 不是障碍物&&没被访问过
                s.push(next); // 入栈
                isVis[next.x][next.y]= true; // 标记该点已访问
                dfs();
                canVis= true; // 有路可走
            }
        }
        if(!canVis) // 无路可走则出栈
            s.pop();
    }
}
int main(){
    for(int i=1;i<=5;i++)
        for(int j=1;j<=5;j++)
            cin>>map[i][j];
    for(int i=0;i<=6;i++)
        map[0][i]=map[6][i]=map[i][0]=map[i][6]=1; // 给四周加墙以防越界
    point begin={1,1};
    s.push(begin);
    isVis[1][1]= true;
    dfs();
    for(int i=0;i<minLen;i++)
        cout<<'('<<visLine[i].x-1<<", "<<visLine[i].y-1<<')'<<endl; //由于加墙了，坐标需要减一

    return 0;
}