递归、回溯和DFS(深度优先搜索)

最新推荐文章于 2024-09-28 23:00:16 发布

J-z里奥

最新推荐文章于 2024-09-28 23:00:16 发布

阅读量653

点赞数 2

文章标签：算法 dfs 递归算法经验分享

本文链接：https://blog.csdn.net/weixin_45755232/article/details/111046225

版权

1、递归

递归：简单来说就是自己调用自己。

案例：斐波那契数列

斐波那契数列的是这样一个数列：1、1、2、3、5、8、13、21、34…，即第一项 f(1) = 1,第二项 f(2) = 1…,第 n 项目为 f(n) = f(n-1) + f(n-2)。求第 n 项的值是多少。
(1)、递归函数功能
假设 f(n) 的功能是求第 n 项的值，代码如下：

int f(int n)
{
    
}

(2)、递归结束的条件
显然，由题目可知，当 n = 1 或者 n = 2 ,我们可以知道 f(1) = f(2) = 1。所以递归结束条件可以为 n <= 2 时，f(n)= 1。代码如下：

int f(int n)
{
    if(n <= 2)
    {
        return 1;
    }
}

(3)、找出函数的等价关系式

我们通过题目很容易就能够知道 f(n) = f(n-1) + f(n-2)。
所以最终代码如下：

int f(int n)
{
    // 1.递归结束条件
    if(n <= 2)
    {
        return 1;
    }
    // 2.等价关系式
    return f(n-1) + f(n - 2);
}

2、回溯与DFS(深度优先搜索)

回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来到上一步，换一条路再试。
DFS: dfs也会回溯，但是dfs会将已经访问过的点标记为不可再次连接,不会再撤销，从而使得可搜索路径越来越少，而回溯会在访问初标记，回溯时撤销。
DFS基本模型


  void dfs(int step) 
  {
  		if()//结束的条件//达到题目要求例如迷宫终点组合个数等
  		{
  			return;
  		}
        for (int i=1;i<=n;i++)
        {
            sun++//记录一些数据
            a[i]=1//进行标记
            dfs(step+1);//递归继续下一步
            a[i]=0//回溯撤销标记
        }
        //返回

案例：走迷宫

题目描述

蒙蒙要找对象啦！但是对象在和他玩捉迷藏，现在有一个5*5的地图，蒙蒙就在（0，0）的位置，他的心上人就在（4，4）的位置，当然路上会有各种艰难险阻，现在说明一下规则。蒙蒙按照地图行动，一次走一步，而且他只能前后左右的移动，当然蒙蒙也不能穿越墙壁。地图上有两种图案，一种是‘0’表示可以走的路，另一种是‘1’表示不能走的墙
PS:（0，0）就是左上角，（4，4）就是右下角，都懂吧！

输入

输入一个5*5的矩阵表示地图，‘0’表示可以走的路，‘1’表示不能走的墙，蒙蒙就在（0，0）的位置，他的心上人就在（4，4）的位置

输出

输出蒙蒙到心上人那里最少要走多少步，若蒙蒙永远走不到心上人那里，则输出-1

样例输入

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

样例输出

8

DFS如下：

void dfs(int x,int y,int ans)
{
    if(x==4&&y==4)//结束的条件达到迷宫终点
    {
        if(ans<min1)//min1初始值定义很大
        {
            min1=ans;
        }
        return;
    }
    for(int i=0; i<4; i++)
    {
        int tx,ty;
        tx=x+dx[i];
        ty=y+dy[i];
        if(tx>=0&&tx<=4&&ty>=0&&ty<=4)
        {
         if(a[tx][ty]==0&&b[tx][ty]==0)
        {
 
            b[tx][ty]=1;//对走过的路径进行标记
            dfs(tx,ty,ans+1);//继续下一步
            b[tx][ty]=0;//回溯到上一步并取消标记
        }
        }
    }
    return;
}

完整代码如下：

#include<iostream>
using namespace std;
int dx[4]= {0,-1,0,1};
int dy[4]= {1,0,-1,0};
int a[10][10],b[10][10];
int min1=88888;
int ans;
void dfs(int x,int y,int ans)
{
    if(x==4&&y==4)
    {
        if(ans<min1)
        {
            min1=ans;
        }
        return;
    }
    for(int i=0; i<4; i++)
    {
        int tx,ty;
        tx=x+dx[i];
        ty=y+dy[i];
        if(tx>=0&&tx<=4&&ty>=0&&ty<=4)
        {
         if(a[tx][ty]==0&&b[tx][ty]==0)
        {
 
            b[tx][ty]=1;
            dfs(tx,ty,ans+1);
            b[tx][ty]=0;
        }
        }
 
    }
    return;
}
int main()
{
    for(int i=0; i<5; i++)
    {
        for(int j=0; j<5; j++)
        {
            cin>>a[i][j];
        }
    }
    b[0][0]=1;
    dfs(0,0,0);
    if(min1>0&&min1<8888)
    cout<<min1;
    else
        cout<<-1<<"\n";
}

经典深搜

棋盘问题

Description

在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。

Input

输入含有多组测试数据。每组数据的第一行是两个正整数，n k，用一个空格隔开，表示了将在一个n*n的矩阵内描述棋盘，以及摆放棋子的数目。 n
<= 8 , k <= n 当为-1 -1时表示输入结束。随后的n行描述了棋盘的形状：每行有n个字符，其中 # 表示棋盘区域， .
表示空白区域（数据保证不出现多余的空白行或者空白列）。

Output