《算法笔记》DFS、BFS

最新推荐文章于 2024-08-09 21:26:42 发布
最新推荐文章于 2024-08-09 21:26:42 发布
阅读量174 收藏
点赞数
分类专栏： # 《算法笔记》胡凡
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43705697/article/details/105361774
版权

目录

选择问题（DFS）

背包问题(不剪枝)
问题描述：
给你一些物品，以及这些物品的重量和价值，求在不超过最大重量的前提下所选物品的最大价值

#include <iostream>
using namespace std;
const int maxn = 30;
int n, V, maxValue = 0;//n代表物品数量，V代表最大重量， maxValue记录最大价值
int w[maxn], c[maxn];
//index是当前处理物品的编号， sumW是之前已选物品总的重量，sumC是之前已选物品总的价值
void DFS(int index, int sumW, int sumC){
    //不采用回溯剪枝的算法，不论结果怎样，都会进行到最后一个物品的选择
    if(index == n){
        if(sumW <= V && sumC > maxValue){
            maxValue = sumC;
        }
        return;
    }
    DFS(index + 1, sumW , sumC);//代表不选择当前物品
    DFS(index + 1, sumW + w[index], sumC + c[index]);//代表选择当前物品
}

int main()
{
    scanf("%d%d", &n, &V);
    for(int  i = 0; i < n; i ++) scanf("%d", &w[i]);
    for(int  i = 0; i < n; i ++) scanf("%d", &c[i]);
    DFS(0, 0, 0);
    cout << maxValue;
    system("pause");
    return 0;
}
背包问题(剪枝)
#include <iostream>
using namespace std;
const int maxn = 30;
int n, V, maxValue = 0;//n代表物品数量，V代表最大重量， maxValue记录最大价值
int w[maxn], c[maxn];
//index是当前处理物品的编号， sumW是之前已选物品总的重量，sumC是之前已选物品总的价值
void DFS(int index, int sumW, int sumC){
    //采用回溯剪枝的算法
    if(index == n) return;
    DFS(index + 1, sumW , sumC);//代表不选择当前物品
    //只有选择当前物品不超过最大重量时，才进行选择的后续步骤
    if(sumW + w[index] <= V){
        //如果超过最大值，则更新最大值
        if(sumC + c[index] > maxValue) maxValue = sumC + c[index];
        DFS(index + 1, sumW + w[index], sumC + c[index]);
    }
}

int main()
{
    scanf("%d%d", &n, &V);
    for(int  i = 0; i < n; i ++) scanf("%d", &w[i]);
    for(int  i = 0; i < n; i ++) scanf("%d", &c[i]);
    DFS(0, 0, 0);
    cout << maxValue;
    system("pause");
    return 0;
}

还有另一种剪枝算法，就是不预先判断后果，直接进行选择，选择后在进行剪枝，代码可能会好理解一点，
就跟判断树的叶节点一样，如果当前节点为空，就证明已经是叶节点的下一层了，直接返回，而不是去判断他有没有孩子节点，
这样虽然会多循环一下，但理解起来好理解一些
代码如下，注意因为是后剪枝，所以在判断index == n之前，应该更新一下上一次留下的结果：
void DFS(int index, int sumW, int sumC){
//采用回溯剪枝的算法
if(sumW > V)return;
if(sumC > maxValue) maxValue = sumC;
if(index == n) return;
DFS(index + 1, sumW , sumC);//代表不选择当前物品
DFS(index + 1, sumW + w[index], sumC + c[index]);//代表选择当前物品
}
求解最优子序列问题
问题描述：给定一个序列，求这个问题的所有子序列，从中选择最优子序列；等价于从N个数中选择K个数的所有方案；
给定N个整数，从中选择K个数，令其和为X，若存在多种情况，返回平方和最大的一组。

#include <iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
const int maxn = 30;
int n, k, x, maxSumSqu = -1, A[maxn];
vector<int> temp, ans;//temp记录每一种临时情况，ans记录最优情况
//index代表当前处理元素的下标， nowk记录一选择元素个数， sum代表已选元素的总和，sumSqu代表平方和
void DFS(int index, int nowK, int sum, int sumSqu){
    //对于后剪枝问题，每次循环前要先判断上次的结果是不是最大值
    if(nowK == k &&  sum == x){
        if(sumSqu > maxSumSqu){
            maxSumSqu = sumSqu;
            ans = temp;
            return;
        }
    }
    //如果已经处理完n个元素 或者 总和大于x 或者 总个数大于k，则返回
    if(index == n || sum > x || nowK > k) return;
    //不选index号元素
    DFS(index + 1, nowK, sum, sumSqu);
    //选择index元素
    temp.push_back(A[index]);//将A[index]放入temp中
    //如果一个元素可以选多次，这句话改为:
    //DFS(index , nowK +1, sum + A[index], sumSqu + A[index] * A[index]);
    DFS(index +1, nowK +1, sum + A[index], sumSqu + A[index] * A[index]);
    temp.pop_back();//将A[index]从temp中弹出
}
int main()
{
    scanf("%d%d%d", &n, &k, &x);
    for(int  i = 0; i < n; i ++) scanf("%d", &A[i]);
    DFS(0, 0, 0, 0);
    cout << maxSumSqu <<endl;
    for(int i = 0; i < ans.size(); i ++) cout << ans[i] <<' ';
    system("pause");
    return 0;
}

遍历问题

求连通块问题（BFS）
如果要保证每个元素只能被访问一次，则不论是DFS还是BFS都要额外开一个数组存储当前节点是否被处理过；
BFS遍历时判断的依据是节点有没有入过队；DFS遍历时判断的依据是节点有没有被DFS过；
如果遍历一遍所有元素用DFS进行后剪枝代码比较简洁，不需要自己维护栈；
如果是要求到达终点的最少步数，则用BFS简单；如果用DFS则需要找到所有能到达终点的路径，并进行比较，运算量很大，且每个节点需要多次访问；

#include <iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn = 30;
int m, n, matrix[maxn][maxn];
bool iqu[maxn][maxn] = {false};//iqu存储是否入过队，false没入过，true代表入过
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
struct node{
    int x, y;
};
//BFS 不是用递归实现的，所以不需要显式写出结束条件，但是需要将当前节点入队，作为第一个元素；
void BFS(int x, int y){
    queue<node> q;
    q.push({x, y});
    iqu[x][y] = true;
    //当队列为空后，迭代结束
    while(!q.empty()){
        node temp = q.front();
        q.pop();
        for(int  i = 0; i < 4; i ++){
            int x0 = temp.x + dx[i], y0 = temp.y + dy[i];
            if(x0 < 0 || x0 >= m || y0 < 0 || y0 >= n) continue;//对于涉及到下标的问题，先看下标是否合法
            //在下标合法的情况下，如果位置是1，并且没有入过队，才继续进行
            if(matrix[x0][y0] == 1 && iqu[x0][y0] == false){
                q.push({x0, y0});
                iqu[x0][y0] = true;
            }
        }
    }
    return;
}

int main()
{
    int ans = 0;
    //读入矩阵
    scanf("%d%d", &m, &n);
    for(int  i = 0; i < m; i ++){
        for(int  j = 0; j < n; j ++){
            scanf("%d", &matrix[i][j]);
        }
    }
    //遍历矩阵
    for(int  i = 0; i < m; i ++){
        for(int j = 0; j < n; j ++){
            if(matrix[i][j] == 1 && iqu[i][j] == false){
                ans++;
                BFS(i, j);
            }
        }
    }
    cout << ans;
    system("pause");
    return 0;
}
求连通块问题（DFS）
#include <iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn = 30;
int m, n, matrix[maxn][maxn];
bool check[maxn][maxn] = {false};//check代表是否检查过
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};

//DFS进行后剪枝，如果下标不合法，或者不是1，或者已经检查过，则返回
void DFS(int x0, int y0){
    //下标不合法，则返回
    if(x0 < 0 || x0 >= m || y0 < 0 || y0 >= n) return;
    //这个数据不是1，或者已经处理过，则返回
    if(matrix[x0][y0] != 1 || check[x0][y0] == true) return;

    check[x0][y0] = true;//将当前元素设置为已检查
    for(int  i = 0; i < 4; i ++){
        int x = x0 + dx[i], y = y0 + dy[i];
        DFS(x, y);
    }
    return;
}

int main()
{
    int ans = 0;
    //读入矩阵
    scanf("%d%d", &m, &n);
    for(int  i = 0; i < m; i ++){
        for(int  j = 0; j < n; j ++){
            scanf("%d", &matrix[i][j]);
        }
    }
    //遍历矩阵
    for(int  i = 0; i < m; i ++){
        for(int j = 0; j < n; j ++){
            if(matrix[i][j] == 1 && check[i][j] == false){
                ans++;
                DFS(i, j);
            }
        }
    }
    cout << ans;
    system("pause");
    return 0;
}
求最少步数（BFS）
#include <iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn = 30;
int m, n, ans = -1;
char matrix[maxn][maxn];
bool check[maxn][maxn] = {false};//check代表是否入过队
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};

struct node{
    int x, y, step;//step表示第几步到达它
}S, T;

void BFS(){
    queue<node> q;
    q.push(S);
    check[S.x][S.y] = true;//开始点入队后要设为已入队
    while(!q.empty()){
        node top = q.front() ;
        q.pop();
        //判断队首元素是不是终点
        if(top.x == T.x && top.y == T.y){
            ans = top.step;
            break;
        }
        for(int  i =0 ; i < 4; i ++){
            int x = top.x + dx[i], y =top.y + dy[i];
            if(x < 0 || x >= m || y < 0 || y >= n) continue;//如果下标不满足，直接continue
            //如果不是墙且没有入过队则入队
            if(matrix[x][y] != '*' && check[x][y] == false){
                node temp = {x, y, top.step + 1};
                q.push(temp);
                check[x][y] = true;
            }
        }
    }
    return ;
}

int main()
{
    //读入矩阵
    scanf("%d%d", &m, &n);
    for(int  i = 0; i < m; i ++){
        getchar();//过滤回车
        for(int  j = 0; j < n; j ++){
            scanf("%c", &matrix[i][j]);
        }
    }
    scanf("%d%d%d%d", &S.x, &S.y, &T.x, &T.y);
    S.step = 0;
    //进行BFS
    BFS();
    cout << ans;
    system("pause");
    return 0;
}
求最少步数（DFS）
#include <iostream>
#include<vector>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn = 30;
int m, n, matrix[maxn][maxn];
bool check[maxn][maxn] = {false};//check代表是否检查过
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int ans = -1;
struct node{
    int x, y;
}S, T;

//DFS进行后剪枝，如果下标不合法，或者不是1，或者已经检查过，则返回
void DFS(int x0, int y0, int step){
    //下标不合法，则返回
    if(x0 < 0 || x0 >= m || y0 < 0 || y0 >= n) return;
    if(matrix[x0][y0] == '*') return;
    //如果这个点恰好是出口,跟当前全局步数比较大小
    if(x0 == T.x && y0 == T.y){
        ans = max(step, ans);
        return;
    }
    for(int  i = 0; i < 4; i ++){
        int x = x0 + dx[i], y = y0 + dy[i];
        DFS(x, y， step + 1);
    }
    return;
}

int main()
{
    //读入矩阵
    scanf("%d%d", &m, &n);
    for(int  i = 0; i < m; i ++){
        getchar();//过滤回车
        for(int  j = 0; j < n; j ++){
            scanf("%c", &matrix[i][j]);
        }
    }
    scanf("%d%d%d%d", &S.x, &S.y, &T.x, &T.y);
    //进行DFS
    DFS(S.x, S.y, 0);
    cout << ans;
    system("pause");
    return 0;
}
爱幻想-hjyp
关注
专栏目录
【算法笔记】二分图最大权匹配 - KM算法（dfs版O(n4) + bfs版O(n3)）
繁凡さん的博客
10-09 1199
匈牙利算法又称为 KM 算法，可以在 O(n3)O(n^3)O(n3) 时间内求出二分图的 最大权完美匹配 。 考虑到二分图中两个集合中的点并不总是相同，为了能应用 KM 算法解决二分图的最大权匹配，需要先作如下处理：将两个集合中点数比较少的补点，使得两边点数相同，再将不存在的边权重设为 0，这种情况下，问题就转换成求最大权完美匹配问题 ，从而能应用 KM\tt KMKM 算法求解。 其实就是普通的匈牙利算法求二分图最大匹配的拓展版本 顶标：两边点都有的标记（左 aia_iai​右 bjb_jbj​）满
CSP刷题总结/DFS&BFS
qq_40901482的博客
08-04 376
备考北航机试的时候刷过一些csp和机试题，写了一些总结
深度优先搜索算法—DFS
04-23
该代码是DFS算法的实现，讲解部分可以查看我的博客
算法笔记 BFS
wzw的博客
03-11 177
这个是题目：相当于就是输入一个只有01的矩阵，求其中1的块数 思路：这道题其实也就是求连通块的问题，只要一个位置的上下左右中存在一个1那就可以连通到一起，是BFS经典的题目 #include<stdio.h> #include<string.h> //#include <stdbool.h> #include <algorithm> #includ...
深度优先算法 DFS总结(算法详解+模板+例题)
最新发布
Alex_Fufu的博客
08-09 2010
沿着树的深度遍历树的节点，尽可能深的搜索树的分支。共 m+1 行，第 1 行为 2 个数，n 和 m，分别表示一共有 n(n≤105) 篇文章（编号为 1 到 n）以及m(m≤106) 条参考文献引用关系。一个如下的 6×6 的跳棋棋盘，有六个棋子被放置在棋盘上，使得每行、每列有且只有一个，每条对角线（包括两条主对角线的所有平行线）上至多有一个棋子。有一个 n \times mn×m 的棋盘，在某个点 (x, y)(x,y) 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。
算法笔记-BFS
qq_40584427的博客
08-14 177
解决思路： 代码实现： #include<bits/stdc++.h> using namespace std; int m,n,ans=0; int a[20][20]={0}; bool b[20][20]={0}; int nx[4]={0,0,1,-1}; int ny[4]={1,-1,0,0}; bool judge(int x1,int y1) { if(x1<0||x1>m||y1<0||y1>n) return fals..
ACWing n-皇后问题
Stillboring的博客
04-01 2056
n−n−皇后问题是指将nn个皇后放在n×nn×n的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。 现在给定整数nn，请你输出所有的满足条件的棋子摆法。 输入格式 共一行，包含整数nn。 输出格式 每个解决方案占nn行，每行输出一个长度为nn的字符串，用来表示完整的棋盘状态。 其中.表示某一个位置的方格状态为空，Q表示某一个位置的方格上摆着皇后。 每个方案输出完成后，输出一个空行。 注意：行末不能有多余空格。 输出方...
算法笔记 8.2 BFS
树叶子的博客
03-16 307
1.BFS模板 //BFS模板 void BFS(int s){ queue&lt;int&gt; q;//定义队列 q.push(s);//起始结点入队 while(!q.empty()){//非空循环 取出队首元素top; 访问队首元素top; 队首元素出队; 将top的下一层结点中未曾入队的结点全部入...
《算法笔记》pdf版，欢迎下载学习~
10-10
2. **图论**：如深度优先搜索（DFS）、广度优先搜索（BFS）、最小生成树（Prim或Kruskal）、最短路径（Dijkstra或Floyd-Warshall）等，这些都是处理网络和复杂关系的有效工具。 3. **动态规划**：解决最优化问题的...
算法笔记3_算法笔记_浙大_
09-30
搜索算法如二分查找、深度优先搜索（DFS）和广度优先搜索（BFS）。 2. **数据结构**：数据结构是算法的基础，笔记中会详细讲解线性结构（数组、链表）、树结构（二叉树、平衡树如AVL和红黑树）、图结构（邻接矩阵、...
【算法笔记】bfs广度优先搜索
Ronaldo7_ZYB的博客
02-06 373
1.对广度优先搜索的理解：广度优先搜索相对于深度优先搜索，深度优先搜索就是从一个状态出发往深处走然后回退的过程，不断去枚举每一个方案，所以是“深度优先”；而对于广度优先搜索而言，没扩展万一个点都会以这个点进行再一次的扩展，所以是“宽度优先”。2.一道模板题：bfs求最短路（不是图论）求点S到点T的最短路q[++tail]=S;//第一个点入队访问 vis[S]=1;//标记已被 dis[S]=0;...
算法学习笔记 - BFS
杨骆白的博客
05-16 153
目录广度优先搜索代码框架题目练习[111. 二叉树的最小深度 - 简单](https://leetcode.cn/problems/minimum-depth-of-binary-tree/)[剑指 Offer II 109. 开密码锁 - 中等](https://leetcode.cn/problems/zlDJc7/) 广度优先搜索代码框架 广度优先搜索 主要用来解决在一幅图中, 找到从起点到终点的最近距离. 主要使用队列数据结构来存储每一步所要处理的数据 使用set来记录处理的数据是否访问过 代码框架
【算法笔记】BFS（走迷宫，八数码）
Radein的博客
11-28 540
BFS（权值相等下的最短路问题）
算法笔记之DFS与 BFS
Steven_ZYF
06-06 518
基本思想： 深度优先搜索(DFS,Depth-First Search):  它从某个状态开始，不断的转移状态直到无法转移状态，然后回退到前一步的状态，继续转移到其它状态，如此不继重复，直至找到最终的解。 宽度优先搜索(BFS,Breadth-First Search)： 总是先搜索距离初始状态近的状态，也就是说，它是按照开始状态--->只需1次转移就可以到达的所有状态---->只需2次转
算法笔记-图--bfs
weixin_30889885的博客
05-18 62
题目：PAT A1076 思路： 建立图； dfs便利的的深度不超过给定深度，但是采用BFS 把节点编号和层号建立结构点，控制 #include <iostream> #include <string> #include <queue> #include <vector> #include <algorithm&g...
算法笔记——dfs,bfs
袁钰琦的博客
02-22 289
深度优先和广度优先‘(dfs、bfs)是最常用的两种搜索方法，在各类算法竞赛中也是频频出现，（可参见2017蓝桥杯的前4题均是搜索题），所以掌握两种搜索的适用场合和使用方法是很有必要的。 适用场合： bfs：常用在搜索最短路径的情景，一旦搜索到可以结束，因为其深度一定是最短的。dfs也可以但是就必须全部搜索完才能判定最短的路径。 dfs：所需要维护的空间少，这个跟其每次只需要维护一个方向的记录有关...
算法笔记--BFS例题
jiangjiangjiang6的博客
03-05 469
例1： 基本思想：枚举每一个位置的元素，如果为0，则跳过；如果为1，则使用BFS查询与该位置相邻的4个位置，判断它们是否为1（如果某个相邻的位置为1，则同样去查询与该位置相邻的4个位置，指导整个“1”块访问完毕）。为了防止走回头路，一般可以设置一个bool型数组inq（即in queue的简写）来记录每个位置是否在BFS中已入过队。 #include<cstdio> #inc...
算法笔记学习 BFS（Java）
BodyCsoulN的博客
03-22 401
题目及解析（利用BFS解决背包问题） ​​​​​​​ import java.util.Scanner; public class dfsbeibao { static final int maxn = 30; static int n, V, maxValue = 0;//物品件数是n，背包容量是v，最大价值maxValue static int[] w = new int[max...
算法笔记：从入门到专业，涵盖数据结构与高级技巧
接下来，进入工作级阶段，涉及到更复杂的高级数据结构，如树和二叉树，以及常见算法的应用，如迭代、递归、回溯、分治策略（如归并排序和二分查找）、广度优先搜索（BFS）和深度优先搜索（DFS）。同时，还介绍了贪心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值