蓝桥杯dfs+回溯算法

回溯算法

回溯和递归是相辅相成的

纯暴力的搜索

• 组合问题
• 切割问题
• 子集问题
• 排列问题
• 棋盘问题（n皇后，解数独）

回溯法理解

都可以抽象成一个n叉树

for循环是树的宽度，递归是树的深度

回溯法模板

void backtracking(参数){
    if(终止条件){
        收集结果;
        return;
    }
    for(集合的元素集)
        处理节点；
        递归函数；
        回溯操作；
       return；
}

组合问题

for(i=1;i<size;i++){
    for(j=i+1;j<size;j++){
        for(k=j+1;k<size;k++)
    }
}

回溯算法其实就是通过递归来控制有多少个for循环

递归里的每一层其实就是一个for循环

回溯算法就相当于递归里面又嵌套个for循环，for循环里又有递归

回溯三部曲

• 确定递归参数和返回值
• 确定终止条件
• 单层递归逻辑

void  backtraking(n,k,startIndex)
    if(path.size()==k)
    	result.add(path);
		return;
    for(i=startIndex; i<=n; i++){
        path.add(i);
        backtraking(n,k,i+1);
        最重要的一步，回溯的过程要把之前的元素pop出去
        path.pop(i);
    }

DFS与递归

DFS一般用递归实现，“DFS=递归”

递归函数“自己调用自己“，不断重复。把大问题逐步缩小，直到变成最小的同类问题。最后的小问题是已知的，一般是给定的初始条件。

大问题和小问题的解决方法完全一样，大问题的代码和小问题的代码写成一样。

斐波那契数列

f(n) = f(n-1) + f(n-2)

用递归写斐波那契额

int cnt = 0;
int fib(int n){
    cnt++;
    if(n==1||n==2)
        return 1;终止条件
    return fib(n-1)+fib(n-2);递归两次
}

计算第20个斐波那契，递归了13529

递归的工作做了很多次重复工作

fib(3)计算了二次，其实只算1次就够了

递归的优化：记忆化

• 为避免递归时重复计算子问题，可以再子问题得到解决时，保存结果，再次需要这个结果时，直接返回保存的结果就行了
• 这种存储已经解决的子问题结果的技术称为记忆化
• 记忆化是DFS的常用优化（剪枝）技术

int cnt = 0;
int data[25];
int fib(int n){
    cnt++;
    if(n==1||n==2){
        data[n]=1;
        return data[n];
    }
    if(data[n]!=0)return data[n];
    data[n] = fib(n-1)+fib(n-2);
    return data[n];
}

自写全排列算法（递归）

int a[20]={1,2,3,4,5,6,7,8,9,10,11,12,13};
bool vis[20];//记录第i个数是否用过
int b[20];
void dfs(int s, int t){
    if(s == t){
        for(int i = 0; i < t; i++)cout<<b[i]<<" "
            cout<<endl; return;
    }
    for(int i = 0; i <t; i++){
        if(!vis[i]){
            vis[i]=true;记忆化搜索
            b[s]=a[i];//第一次进入dfs时，b[0]在n个数中选一个
            		  //第二次进入dfs时，b[1]在剩下的n-1个数中选一个
            dfs(s+1,t);
            vis[i]=false;记忆化搜索
        }
    }
}
int main(){
    int n = 3;
    dfs(0,n);
    return 0;
}

• 递归的使用
• 复杂度分析
• 路径标记

给出一个迷宫，每个点上有一个指示牌，必须按指示牌走。迷宫的每个点上站着一个人，问有多少人能走出来。

迷宫如下:其中L表示向左走，R表示向右走，U表示向上走，D表示向下走

• 某個人沿着指示牌一直走，或者能走出去，或者没走出去又兜兜转转回来
• “一路到底”：典型dfs

const int n  = 10;
char mp[n+2][n+2];//用矩阵mp[][]存迷宫图,把静态数组定义在全局
bool vis[n+2][n+2];//判断点是否曾经走过，是记忆化功能
int ans = 0;
int cnt = 0;
bool dfs(int i, int j){
    if(i<0 || i>n-1 || j<0 || j>n-1)return fasle;
    if(vis[i][j]) return false;//如果已经搜索过，则说明在兜圈子
    cnt++;//统计dfs了多少次
    vis[i][j] = true;
    if(mp[i][j]=='L') return dfs(i,j-1);
    if(mp[i][j]=='R') return dfs(i,j+1);
    if(mp[i][j]=='U') return dfs(i-1,j);
    if(mp[i][j]=='D') return dfs(i+1,j);
}
int main(){
    for(int i = 0;i <n;i++)
        for(int j = 0;j<n ;j++)
            cin>>mp[i][j];
    for(int i = 0;i<n;i++)
        for(int j = 0; j < n;j++){
            
        }
}

dfs记忆化是必须的

复杂度分析：

• 迷宫有nxn列，做一次dfs()，最多需要走遍所有的点，即o(n^2)
• nxn个点，每个点都做一次dfs(),总复杂度o(n^4)

回溯与路径标记

• 用不着对每个点都做一次dfs
• 例如：从一个点出发，走过一条路径，最后走出了迷宫，那么以这条路径上所有的店为起点，都能走出迷宫
• 如果有办法对走过路径进行记录，就能大大减少计算量
• 如何标记一条dfs？回溯

麻烦在于：从起点出发的一条路径，必须要走到最后一个点，才能知道这条路径上前面的点的情况

如果最后一个点能走出去：回溯整条路径，把路径上的点都标记为能走出去

如果最后一个点走不出去，回溯整条路径，把路径上的点都标记为走不出去

路径记录

方格分割 蓝桥杯2017年省赛C++A组

6x6的方格，沿着格子的边线剪开成两部分，要求这两部分的形状完全相同。如图就是可行的分割法

试计算，一共有多少种不同的分割方法

注意：旋转对称的属于同一种分割法

切割线一定会经过图的中心点，只要确定半条边到达边界的分割线，就能根据这半条对称画出另外半条。

一道简单的dfs

dfs操作：中心点(3,3) 从(3,3)出发，向右，向左，向上，向下四个方向dfs

int x[]={0,-1,1,0,0};//上下左右四个方向
int y[]={0,0,0,-1,1};
bool vis[10][10];//标记点是否被访问过
int res=0;
void dfs(int x,int y){
    if(x==0||y==0||x==6||y==6){
        res++;
        return;
    }
    for(int i = 1;i<=4;i++){
        x+=X[i];
        y+=Y[i];//走一步
        if(!vis[x][y]){
            vis[x][y]=true;//当前的点标注为已经访问
            vis[6-x][6-y]=true;
            dfs(x,y);
            vis[6-x][6-y]=false;
            vis[x][y]=false;
        }
        x-=X[i];
        y-=Y[i];
    }
}