2024/1/30 dfs与bfs

想要了解dfs与bfs，就得了解队列和栈。

一、栈与队列

1.栈

栈说白了就是先入后出。把栈类比为一个容器。只有一个口，所以如果我们想要取出最底层也就是最先放入的元素，只能最后取出它。

栈基础操作有如下几种：

  1. push 放入
  2. pop 拿出
  3. empty 是否为空
  4. size 栈的大小
  5. top 获取栈顶元素

下面将用两种方式实现：

  1. 用数组或者链表模拟栈 
    #include <iostream>
using namespace std;const int N = 100;int stk[N], top = 0;int main()
{//使用数组模拟栈int x;cin >> x;//push放入栈中stk[++top] = x;//输出栈顶元素cout << stk[top] << endl;//pop拿出(不管top元素删不删，top--就行)top--;// 常用的就是，获取栈顶元素的同时，弹出栈顶元素int u = stk[top--];return 0;
}

    以上是普通静态数组。但是考虑到现实生活由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组或者链表，这样就无须自行处理数组扩容问题。这里贴出hello算法里对这个的网址。https://www.hello-algo.com/chapter_stack_and_queue/stack/#1icon-default.png?t=N7T8https://www.hello-algo.com/chapter_stack_and_queue/stack/#1

  2. stl库写栈

首先就是 #include <stack>

定义：stack<数据类型> stk;

使用：

  • stk.push(x);
  • stk.pop();
  • stk.top();
  • stk.empty();//true表示空
  • stk.size();//返回正整数
#include <iostream>
#include <stack>
using namespace std;int main()
{stack<int>stk;int x;cin >> x;//放入栈中stk.push(x);//输出栈顶cout << stk.top() << endl;//弹出栈顶stk.pop();return 0;
}

2.队列

队列则是：“先入先出”。「队列 queue」是一种遵循先入先出规则的线性数据结构。顾名思义，队列模拟了排队现象，即新来的人不断加入队列尾部，而位于队列头部的人逐个离开。

队列基础操作有如下几种：

  1. push 放入（从队尾）
  2. pop 拿出（从队首）
  3. empty 是否为空
  4. size 栈的大小
  5. front
#include <iostream>
using namespace std;const int N = 100;int q[N], front = 0, tail = 0;int main()
{//使用数组模拟队列int x;cin >> x;//push 放入队列中q[++tail] = x;//pop 把元素移除（只能从队首）front++;//size 队列长度int size = tail - front + 1;//empty 看size是否为0//front return q[front];return 0;
}
/* 初始化队列 */
queue<int> queue;/* 元素入队 */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);/* 访问队首元素 */
int front = queue.front();/* 元素出队 */
queue.pop();/* 获取队列的长度 */
int size = queue.size();/* 判断队列是否为空 */
bool empty = queue.empty();

额外：优先队列，双向队列

http://t.csdnimg.cn/KpFjNicon-default.png?t=N7T8http://t.csdnimg.cn/KpFjN5.2   队列 - Hello 算法 (hello-algo.com)icon-default.png?t=N7T8https://www.hello-algo.com/chapter_stack_and_queue/queue/#5215.3   双向队列 - Hello 算法 (hello-algo.com)icon-default.png?t=N7T8https://www.hello-algo.com/chapter_stack_and_queue/deque/

/* 初始化双向队列 */
deque<int> deque;/* 元素入队 */
deque.push_back(2);   // 添加至队尾
deque.push_back(5);
deque.push_back(4);
deque.push_front(3);  // 添加至队首
deque.push_front(1);/* 访问元素 */
int front = deque.front(); // 队首元素
int back = deque.back();   // 队尾元素/* 元素出队 */
deque.pop_front();  // 队首元素出队
deque.pop_back();   // 队尾元素出队/* 获取双向队列的长度 */
int size = deque.size();/* 判断双向队列是否为空 */
bool empty = deque.empty();

双向队列兼具栈与队列的逻辑，因此它可以实现这两者的所有应用场景，同时提供更高的自由度。

我们知道，软件的“撤销”功能通常使用栈来实现：系统将每次更改操作 push 到栈中，然后通过 pop 实现撤销。然而，考虑到系统资源的限制，软件通常会限制撤销的步数（例如仅允许保存 50 步）。当栈的长度超过 50 时，软件需要在栈底（队首）执行删除操作。但栈无法实现该功能，此时就需要使用双向队列来替代栈。请注意，“撤销”的核心逻辑仍然遵循栈的先入后出原则，只是双向队列能够更加灵活地实现一些额外逻辑。

二、DFS深度优先搜索-----栈

 1.指数型搜索

模板：

void dfs(int step){
    判断边界
    尝试每一种可能 for(i=1;i<=n;i++){
        继续下一步 dfs(step+1)
        }
    返回
}

#include <iostream>using namespace std;const int N = 100;int n;//输入的节点数  
int st[N] = {}; //决策数组 0 表示没有搜索过， 1表示选择 ， 2表示没有选择// 对于每一个点，都需要有一次决策，无论是1还是2 
// 搜索是把所有的情况都考虑 // u表示对u进行抉择，已经抉择了u个数
void dfs(int u) {// 递归出口，当所有节点都决策完毕时输出结果  if (u > n){for (int i = 0; i < n; i++) {// 只有当第i个节点被选择时才输出 if (st[u] = 1){cout << i << " ";}}}// 选择第u个节点（标记为1）并继续搜索下一个节点st[u] = 1;dfs(u + 1);// 恢复第u个节点的状态（标记为0）并选择不选择第u个节点（标记为2）并继续搜索下一个节点st[u] = 0;st[u] = 2;dfs(u + 1);// 继续恢复第u个节点的状态（标记为0）以备下次决策使用  st[u] = 0;
}
int main()
{cin >> n;dfs(1);return 0;
}


Python Tutor code visualizer: Visualize code in Python, JavaScript, C, C++, and Javaicon-default.png?t=N7T8https://pythontutor.com/render.html#code=%23include%20%3Ciostream%3E%0A%0Ausing%20namespace%20std%3B%0A%0Aconst%20int%20N%20%3D%20100%3B%0A%0Aint%20n%20,%20st%5BN%5D%20%3D%20%7B%7D%3B%20//%200%20%E8%A1%A8%E7%A4%BA%E6%B2%A1%E6%9C%89%E6%90%9C%E7%B4%A2%E8%BF%87%EF%BC%8C%201%E8%A1%A8%E7%A4%BA%E9%80%89%E6%8B%A9%20%EF%BC%8C%202%E8%A1%A8%E7%A4%BA%E6%B2%A1%E6%9C%89%E9%80%89%E6%8B%A9%0A%0A//%20%E5%AF%B9%E4%BA%8E%E6%AF%8F%E4%B8%80%E4%B8%AA%E7%82%B9%EF%BC%8C%E9%83%BD%E9%9C%80%E8%A6%81%E6%9C%89%E4%B8%80%E6%AC%A1%E5%86%B3%E7%AD%96%EF%BC%8C%E6%97%A0%E8%AE%BA%E6%98%AF1%E8%BF%98%E6%98%AF2%20%0A//%20%E6%90%9C%E7%B4%A2%E6%98%AF%E6%8A%8A%E6%89%80%E6%9C%89%E7%9A%84%E6%83%85%E5%86%B5%E9%83%BD%E8%80%83%E8%99%91%20%0A%0A//%20u%E8%A1%A8%E7%A4%BA%E5%AF%B9u%E8%BF%9B%E8%A1%8C%E6%8A%89%E6%8B%A9%EF%BC%8C%E5%B7%B2%E7%BB%8F%E6%8A%89%E6%8B%A9%E4%BA%86u%E4%B8%AA%E6%95%B0%20%0Avoid%20dfs%28%20int%20u%20%29%20%7B%0A%20%20%20%20%0A%20%20%20%20//%20%E9%80%92%E5%BD%92%E5%87%BA%E5%8F%A3%20%EF%BC%8C%20%E6%AF%8F%E4%B8%80%E4%B8%AA%E7%82%B9%E9%83%BD%E6%8A%89%E6%8B%A9%E8%BF%87%E4%BA%86%20%0A%20%20%20%20if%28u%20%3E%20n%20%29%7B%0A%20%20%20%20%20%20%20%20for%28int%20i%20%3D%201%3B%20i%20%3C%3D%20n%20%3B%20i%2B%2B%20%29%20%7B%0A%20%20%20%20%20%20%20%20%20%20%20%20//%20%E6%88%91%E4%BB%AC%E5%8F%AA%E6%9C%89%E5%9C%A8%E9%80%89%E6%8B%A9%E7%AC%ACi%E4%B8%AA%E7%82%B9%E7%9A%84%E6%97%B6%E5%80%99%E8%BE%93%E5%87%BA%20%0A%20%20%20%20%20%20%20%20%20%20%20%20if%28st%5Bu%5D%20%3D%3D%201%20%29%20%7B%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20cout%20%3C%3C%20i%20%3C%3C%20%22%20%22%20%3B%0A%20%20%20%20%20%20%20%20%20%20%20%20%7D%0A%20%20%20%20%20%20%20%20%7D%0A%20%20%20%20%20%20%20%20return%20%3B%0A%20%20%20%20%7D%0A%20%20%20%20%0A%20%20%20%20%0A%20%20%20%20//%20%E9%80%89%E6%8B%A9%0A%20%20%20%20//%20st%5Bu%5D%20%3D%200%3B%20%E8%BF%99%E5%8F%A5%E8%AF%9D%E9%80%9A%E5%B8%B8%E7%9C%81%E7%95%A5%20%0A%20%20%20%20st%5Bu%5D%20%3D%201%3B%0A%20%20%20%20dfs%28u%20%2B%201%29%3B%0A%20%20%20%20%0A%20%20%20%20//%20%E6%81%A2%E5%A4%8D%E7%8E%B0%E5%9C%BA%EF%BC%8C%E6%8E%A7%E5%88%B6%E5%8F%98%E9%87%8F%20%EF%BC%9A%20%E5%8D%95%E4%B8%80%E5%8F%98%E9%87%8F%E5%8E%9F%E5%88%99%20%0A%20%20%20%20st%5Bu%5D%20%3D%200%3B%20%0A%20%20%20%20//%20%E4%B8%8D%E9%80%89%E6%8B%A9%20%0A%20%20%20%20st%5Bu%5D%20%3D%202%3B%0A%20%20%20%20dfs%28u%20%2B%201%29%3B%0A%20%20%20%20%0A%20%20%20%20//%20%E7%BB%A7%E7%BB%AD%E6%81%A2%E5%A4%8D%E7%8E%B0%E5%9C%BA%0A%20%20%20%20st%5Bu%5D%20%3D%200%3B%20%0A%7D%0A%0Aint%20main%28%29%7B%0A%20%20n%3D3%3B%0A%20%20%20%20dfs%281%29%3B%0A%20%20%20%20%0A%20%20%20%20return%200%3B%0A%7D&cppShowMemAddrs=true&cumulative=false&curInstr=38&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=cpp_g%2B%2B9.3.0&rawInputLstJSON=%5B%5D&textReferences=false

例题1 P2036 Perket

 

#include <iostream>  
#include <algorithm>  
#include <cstdio>  
#include <cmath>  
using namespace std;  // 全局变量声明  
int n; // n代表数字的个数  
int mindif = 999999999; // mindif用于存储最小差值，初始化为一个非常大的数  
int s[10], b[10]; // s数组和b数组分别用于存储输入的数字和它们对应的值  // perket函数是一个递归函数，用于计算所有可能的组合  
// u代表当前处理的数字的索引  
// sp代表当前选择的s数组中数字的乘积  
// bs代表当前选择的b数组中数字的和  
void perket(int u, int sp, int bs) {  // 递归终止条件：当u大于n时，表示所有数字都已经处理完毕  if (u > n) {  // 如果bs为0，表示没有选择任何b数组中的数字，直接返回  if (!bs) {  return;  }  // 更新最小差值  mindif = min(mindif, abs(sp - bs));  return;  }  // 递归调用1：不选择当前数字  perket(u + 1, sp, bs);  // 递归调用2：选择当前数字  perket(u + 1, sp * s[u], bs + b[u]);  
}  int main() {  // 输入数字的个数  cin >> n;  // 输入每个数字及其对应的值  for (int i = 1; i <= n; i++) {  cin >> s[i] >> b[i];  }  // 调用perket函数开始计算  perket(1, 1, 0);  // 输出最小差值  cout << mindif << endl;  return 0;  
}

Python Tutor code visualizer: Visualize code in Python, JavaScript, C, C++, and Javaicon-default.png?t=N7T8https://pythontutor.com/render.html#code=%23include%20%3Ciostream%3E%20%20%0A%23include%20%3Calgorithm%3E%20%20%0A%23include%20%3Ccstdio%3E%20%20%0A%23include%20%3Ccmath%3E%20%20%0Ausing%20namespace%20std%3B%20%20%0A%20%20%0A//%20%E5%85%A8%E5%B1%80%E5%8F%98%E9%87%8F%E5%A3%B0%E6%98%8E%20%20%0Aint%20n%3B%20//%20n%E4%BB%A3%E8%A1%A8%E6%95%B0%E5%AD%97%E7%9A%84%E4%B8%AA%E6%95%B0%20%20%0Aint%20mindif%20%3D%20999999999%3B%20//%20mindif%E7%94%A8%E4%BA%8E%E5%AD%98%E5%82%A8%E6%9C%80%E5%B0%8F%E5%B7%AE%E5%80%BC%EF%BC%8C%E5%88%9D%E5%A7%8B%E5%8C%96%E4%B8%BA%E4%B8%80%E4%B8%AA%E9%9D%9E%E5%B8%B8%E5%A4%A7%E7%9A%84%E6%95%B0%20%20%0Aint%20s%5B10%5D,%20b%5B10%5D%3B%20//%20s%E6%95%B0%E7%BB%84%E5%92%8Cb%E6%95%B0%E7%BB%84%E5%88%86%E5%88%AB%E7%94%A8%E4%BA%8E%E5%AD%98%E5%82%A8%E8%BE%93%E5%85%A5%E7%9A%84%E6%95%B0%E5%AD%97%E5%92%8C%E5%AE%83%E4%BB%AC%E5%AF%B9%E5%BA%94%E7%9A%84%E5%80%BC%20%20%0A%20%20%0A//%20perket%E5%87%BD%E6%95%B0%E6%98%AF%E4%B8%80%E4%B8%AA%E9%80%92%E5%BD%92%E5%87%BD%E6%95%B0%EF%BC%8C%E7%94%A8%E4%BA%8E%E8%AE%A1%E7%AE%97%E6%89%80%E6%9C%89%E5%8F%AF%E8%83%BD%E7%9A%84%E7%BB%84%E5%90%88%20%20%0A//%20u%E4%BB%A3%E8%A1%A8%E5%BD%93%E5%89%8D%E5%A4%84%E7%90%86%E7%9A%84%E6%95%B0%E5%AD%97%E7%9A%84%E7%B4%A2%E5%BC%95%20%20%0A//%20sp%E4%BB%A3%E8%A1%A8%E5%BD%93%E5%89%8D%E9%80%89%E6%8B%A9%E7%9A%84s%E6%95%B0%E7%BB%84%E4%B8%AD%E6%95%B0%E5%AD%97%E7%9A%84%E4%B9%98%E7%A7%AF%20%20%0A//%20bs%E4%BB%A3%E8%A1%A8%E5%BD%93%E5%89%8D%E9%80%89%E6%8B%A9%E7%9A%84b%E6%95%B0%E7%BB%84%E4%B8%AD%E6%95%B0%E5%AD%97%E7%9A%84%E5%92%8C%20%20%0Avoid%20perket%28int%20u,%20int%20sp,%20int%20bs%29%20%7B%20%20%0A%20%20%20%20//%20%E9%80%92%E5%BD%92%E7%BB%88%E6%AD%A2%E6%9D%A1%E4%BB%B6%EF%BC%9A%E5%BD%93u%E5%A4%A7%E4%BA%8En%E6%97%B6%EF%BC%8C%E8%A1%A8%E7%A4%BA%E6%89%80%E6%9C%89%E6%95%B0%E5%AD%97%E9%83%BD%E5%B7%B2%E7%BB%8F%E5%A4%84%E7%90%86%E5%AE%8C%E6%AF%95%20%20%0A%20%20%20%20if%20%28u%20%3E%20n%29%20%7B%20%20%0A%20%20%20%20%20%20%20%20//%20%E5%A6%82%E6%9E%9Cbs%E4%B8%BA0%EF%BC%8C%E8%A1%A8%E7%A4%BA%E6%B2%A1%E6%9C%89%E9%80%89%E6%8B%A9%E4%BB%BB%E4%BD%95b%E6%95%B0%E7%BB%84%E4%B8%AD%E7%9A%84%E6%95%B0%E5%AD%97%EF%BC%8C%E7%9B%B4%E6%8E%A5%E8%BF%94%E5%9B%9E%20%20%0A%20%20%20%20%20%20%20%20if%20%28!bs%29%20%7B%20%20%0A%20%20%20%20%20%20%20%20%20%20%20%20return%3B%20%20%0A%20%20%20%20%20%20%20%20%7D%20%20%0A%20%20%20%20%20%20%20%20//%20%E6%9B%B4%E6%96%B0%E6%9C%80%E5%B0%8F%E5%B7%AE%E5%80%BC%20%20%0A%20%20%20%20%20%20%20%20mindif%20%3D%20min%28mindif,%20abs%28sp%20-%20bs%29%29%3B%20%20%0A%20%20%20%20%20%20%20%20return%3B%20%20%0A%20%20%20%20%7D%20%20%0A%20%20%20%20%20%20%0A%20%20%20%20//%20%E9%80%92%E5%BD%92%E8%B0%83%E7%94%A81%EF%BC%9A%E4%B8%8D%E9%80%89%E6%8B%A9%E5%BD%93%E5%89%8D%E6%95%B0%E5%AD%97%20%20%0A%20%20%20%20perket%28u%20%2B%201,%20sp,%20bs%29%3B%20%20%0A%20%20%20%20%20%20%0A%20%20%20%20//%20%E9%80%92%E5%BD%92%E8%B0%83%E7%94%A82%EF%BC%9A%E9%80%89%E6%8B%A9%E5%BD%93%E5%89%8D%E6%95%B0%E5%AD%97%20%20%0A%20%20%20%20perket%28u%20%2B%201,%20sp%20*%20s%5Bu%5D,%20bs%20%2B%20b%5Bu%5D%29%3B%20%20%0A%7D%20%20%0A%20%20%0Aint%20main%28%29%20%7B%20%20%0A%20%20%20%20//%20%E8%BE%93%E5%85%A5%E6%95%B0%E5%AD%97%E7%9A%84%E4%B8%AA%E6%95%B0%20%20%0A%20%20%20%20n%3D4%3B%0A%20%20%20%20%20%20%0A%20%20%20%20//%20%E8%BE%93%E5%85%A5%E6%AF%8F%E4%B8%AA%E6%95%B0%E5%AD%97%E5%8F%8A%E5%85%B6%E5%AF%B9%E5%BA%94%E7%9A%84%E5%80%BC%20%20%0A%20%20%20%20s%5B0%5D%3D1,s%5B1%5D%3D2,s%5B2%5D%3D3,s%5B3%5D%3D4%3B%0A%20%20%20%20b%5B0%5D%3D7,b%5B1%5D%3D6,b%5B2%5D%3D8,b%5B3%5D%3D9%3B%0A%20%20%20%20%20%20%0A%20%20%20%20//%20%E8%B0%83%E7%94%A8perket%E5%87%BD%E6%95%B0%E5%BC%80%E5%A7%8B%E8%AE%A1%E7%AE%97%20%20%0A%20%20%20%20perket%281,%201,%200%29%3B%20%20%0A%20%20%20%20%20%20%0A%20%20%20%20//%20%E8%BE%93%E5%87%BA%E6%9C%80%E5%B0%8F%E5%B7%AE%E5%80%BC%20%20%0A%20%20%20%20cout%20%3C%3C%20mindif%20%3C%3C%20endl%3B%20%20%0A%20%20%20%20%20%20%0A%20%20%20%20return%200%3B%20%20%0A%7D&cppShowMemAddrs=true&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=cpp_g%2B%2B9.3.0&rawInputLstJSON=%5B%5D&textReferences=false

在给定的代码中，每次递归的两种选择（选择当前数字和不选择当前数字）可能会产生重复的结果。这意味着，递归函数perket可能会计算出重复的组合。

为了解决这个问题，可以在递归过程中添加一些逻辑来跳过已经计算过的组合，或者使用其他方法来避免重复计算。例如，可以维护一个集合或哈希集合来跟踪已经计算过的组合，并在递归函数中进行检查。

如果不采取措施避免重复计算，则可能会导致递归函数的时间复杂度增加，因为重复计算相同的组合会导致更多的递归调用。在处理大量数据时，这可能会导致性能问题。

2.组合型搜索

例题2 全排列

【题意】
先给一个正整数 ( 1 < = n < = 10 )，输出所有全排列。
什么是全排列，例如n＝3，输出所有组合,并且按字典序输出：
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
每个全排列一行，相邻两个数用空格隔开（最后一个数后面没有空格）
【输入格式】
一行一个整数n。
【输出格式】
输出1~n的所有全排列。
【样例输入】
3
【样例输出】
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

#include <iostream>  // 引入输入输出流库  
#include <algorithm>  // 引入算法库  
#include <cstdio>      // 引入标准输入输出库  
#include <cmath>        // 引入数学库  
using namespace std;     // 使用标准命名空间  int n, ans[10], used[10];   // 定义全局变量，n表示要选取的数字个数，ans数组用于存放结果，used数组用于标记数字是否被使用过  void dfs(int cnt){          // 定义深度优先搜索函数，cnt表示当前已经选取的数字个数  if (cnt > n) {           // 如果已经选取的数字个数大于n，说明已经选取了所有数字，输出结果并返回  for (int i = 1; i <= n; i++) { // 遍历所有数字并输出  cout << ans[i] << " ";  }  cout << endl;  return;  }  for (int i = 1; i <= n; i++){ // 枚举所有数字  if (used[i] == 0) {      // 如果数字i还没有被使用过  ans[cnt] = i;        // 将数字i放入当前位置  used[i] = 1;          // 标记数字i为已使用  dfs(cnt + 1);        // 递归搜索下一个位置  ans[cnt] = 0;         // 撤销当前位置的选择，即清空当前位置  used[i] = 0;           // 撤销对数字i的选择，即将其标记为未使用  }  }  
}  int main() {                  // 主函数  cin >> n;                  // 输入要选取的数字个数n  dfs(1);                     // 从第一个位置开始搜索  return 0;                   // 程序正常结束  
}

这段代码中的回溯是通过以下步骤实现的：

1. 在dfs函数中，首先检查是否已经选取了所有数字（即`cnt`是否大于`n`）。如果是，则输出当前结果并返回。
2. 然后，函数使用一个循环来枚举所有数字。如果某个数字还没有被使用过（即`used[i]`等于0），则进行以下操作：

  •     将该数字放入当前位置（即`ans[cnt] = i`）。
  •     标记该数字为已使用（即`used[i] = 1`）。
  •     递归调用`dfs(cnt + 1)`来搜索下一个位置。

3. 在递归调用返回后，执行回溯操作：

  •     撤销当前位置的选择，即将`ans[cnt]`重置为0，表示该位置还没有被选择。
  •     撤销对数字`i`的选择，即将`used[i]`重置为0，表示数字`i`现在可以再次被选择。

4. 重复上述过程，直到所有可能的排列都被探索完为止。

通过这种方式，代码能够撤销之前的决策，尝试其他可能的路径，从而全面地探索所有可能的解空间。

还有几个题，以后补补（太赶了qaq

三、BFS广度优先搜索-----队列

bfs个人感觉就是，同时往每个方向都试试，最先得到的就是最好的。

它是一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。宽度优先搜索是一种对图进行搜索的算法。假设我们一开始位于某个顶点（即起点），此 时并不知道图的整体结构，而我们的目的是从起点开始顺着边搜索，直到到达指定顶点（即终 点）。在此过程中每走到一个顶点，就会判断一次它是否为终点。广度优先搜索会优先从离起点 近的顶点开始搜索。

b站有个视频非常清晰，这里贴下链接

【广度优先搜索BFS遍历-动画演示过程，希望对大家有所帮助~】

https://www.bilibili.com/video/BV1bP4y1K7Tr?vd_source=7ccfb0770f378b7710213a50fbacfc17icon-default.png?t=N7T8https://www.bilibili.com/video/BV1bP4y1K7Tr?vd_source=7ccfb0770f378b7710213a50fbacfc17

这个大佬写的也很清晰：

http://t.csdnimg.cn/sw4pZicon-default.png?t=N7T8http://t.csdnimg.cn/sw4pZ

int BFS(Node start, Node target) {
    入队(初始状态);
    visited[初始状态] = true;
    while(!空队) {
        for() { // 状态转换
            Node node = 队首元素;
 
            对node的处理，生成新node状态;
 
            if (visited[node] == true)
                continue;
            if (node == target) {
                输出答案;
                return 0;
            }
            v[node] = true;
            入队(node);
        }
    出队();
    }
    
}

 例题3 P1135 奇怪的电梯

#include <iostream>  // 引入输入输出流    
#include <cstring>  // 引入C风格的字符串处理函数库，用于memset  
#include <queue>  // 引入队列容器  
using namespace std;  const int N = 201;  // 定义常量N为201，表示图的最大节点数  int n, a, b;  // n为图的节点数，a为起点，b为终点  
int k[N], vis[N], ans[N];  // k数组存储每个节点的关联值，vis数组标记节点是否被访问过，ans数组存储从起点到每个节点的最短路径长度  // BFS函数，从节点a开始搜索  
void bfs(int a) {  queue<int> Q;  // 定义一个队列Q  Q.push(a);  // 将起点a加入队列  ans[a] = 0;  // 设置起点a到自身的距离为0  // 当队列不为空时继续循环  while (!Q.empty()) {  int u = Q.front();  // 取出队首元素  Q.pop();  // 弹出队首元素  // 如果当前节点是目标节点b，则结束搜索  if (u == b) {  break;  }  // 如果当前节点已经被访问过，则跳过  if (vis[u] == 1) {  continue;  }  vis[u] = 1;  // 标记当前节点为已访问  // 计算通过当前节点的关联值k[u]可以到达的两个节点v1和v2  int v1 = u + k[u];  // 如果v1是一个有效的节点且未被访问过，则将其加入队列，并更新ans[v1]  if (v1 >= 1 && v1 <= n && vis[v1] == 0) {  Q.push(v1);  ans[v1] = min(ans[v1], ans[u] + 1);  }  int v2 = u - k[u];  // 如果v2是一个有效的节点且未被访问过，则将其加入队列，并更新ans[v2]  if (v2 >= 1 && v2 <= n && vis[v2] == 0) {  Q.push(v2);  ans[v2] = min(ans[v2], ans[u] + 1);  }  }  
}  int main() {  cin >> n >> a >> b;  // 输入节点数n，起点a和终点b  // 初始化ans数组为一个很大的数（表示无穷大）  memset(ans, 0x3f, sizeof(ans));  // 输入每个节点的关联值k[i]  for (int i = 1; i <= n; i++) {  cin >> k[i];  }  bfs(a);  // 从起点a开始BFS搜索  // 如果从a到b没有路径，则输出-1，否则输出最短路径长度  if (ans[b] == 1e9) {  cout << -1 << endl;  } else {  cout << ans[b] << endl;  }  return 0;  
}

四、BFS与DFS区别

bfs 遍历节点是先进先出，dfs遍历节点是先进后出；
bfs是按层次访问的，dfs 是按照一个路径一直访问到底，当前节点没有未访问的邻居节点时，然后回溯到上一个节点，不断的尝试，直到访问到目标节点或所有节点都已访问。
bfs 适用于求源点与目标节点距离最近的情况，例如：求最短路径。dfs 更适合于求解一个任意符合方案中的一个或者遍历所有情况，例如：全排列、拓扑排序、求到达某一点的任意一条路径。
————————————————

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/aliyonghang/article/details/128724989

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/665751.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

python 爬虫安装http请求库

python 爬虫安装http请求库

我的是window环境&#xff0c;安装的python3&#xff0c;如果再linux环境&#xff1a;pip install requests 开始&#xff1a; 上面我们成功发送请求并获取到响应&#xff0c;现在需要解析html或xml获取数据&#xff0c;因此我使用现成的工具库Beautiful Soup
阅读更多...
leetcode刷题(剑指offer) 297.二叉树的序列化和反序列化

leetcode刷题(剑指offer) 297.二叉树的序列化和反序列化

297.二叉树的序列化与反序列化 序列化是将一个数据结构或者对象转换为连续的比特位的操作&#xff0c;进而可以将转换后的数据存储在一个文件或者内存中&#xff0c;同时也可以通过网络传输到另一个计算机环境&#xff0c;采取相反方式重构得到原数据。 请设计一个算法来实现…
阅读更多...
图论练习3

图论练习3

内容&#xff1a;过程中视条件改变边权&#xff0c;利用树状数组区间加处理 卯酉东海道 题目链接 题目大意 个点&#xff0c;条有向边&#xff0c;每条边有颜色和费用总共有种颜色若当前颜色与要走的边颜色相同&#xff0c;则花费为若当前颜色与要走的边颜色不同&#xff0c;…
阅读更多...
shell脚本中的变量，运算符

shell脚本中的变量，运算符

1.脚本格式 我们一般将shell脚本写在xxx.sh文件中&#xff0c;执行的时候bash/sh xxx.sh 注意文件路径 xxx.sh文件中的第一行为 #!/usr/bin/bash 注代表我们使用的是bin文件夹下的bash解释器(此条为注释语句&#xff0c;不写也可以) 2.echo用法 相当与print 示例1&…
阅读更多...
ASP.NET Core 自定义解压缩提供程序

ASP.NET Core 自定义解压缩提供程序

写在前面 在了解ASP.NET Core 自定义请求解压缩中间件的应用时&#xff0c;依据官方文档操作下来碰到了几个问题&#xff0c;这边做个记录。 关键点就是配置 Content-Encoding&#xff0c;参数需要和代码中添加的提供程序的Key保持一致&#xff1b; builder.Services.AddRequ…
阅读更多...
9、C语言复习

9、C语言复习

目录 1、位操作 2、define宏定义关键词 3、ifdef条件编译 4、extern变量申明 5、typedef类别别名 6、结构体 7、static关键字 1、位操作 &&#xff1a;按位与 |&#xff1a;按位或 ^&#xff1a;按位异或 ~&#xff1a;取反 <<&#xff1a;左移 >>…
阅读更多...
【实战知识】使用Github Action + Nginx实现自动化部署

【实战知识】使用Github Action + Nginx实现自动化部署

大家好啊，我是独立开发豆小匠。 先说一下背景~ 我的小程序：豆流便签，目前使用云托管部署后端服务，使用轻量级服务器部署数据库和一些中间件。 因此服务器成本：云托管 + 云服务器 云托管每周花费5元，一个月就是50，一年就是500啊，所以这期准备把云托管优化掉！ 1. 需…
阅读更多...
x-shell安装、使用以及配置cuda、cudnn和conda

x-shell安装、使用以及配置cuda、cudnn和conda

x-shell安装、使用以及安装最新版本conda x-shell安装远程连接服务器conda安装和环境配置 x-shell安装 x-shell是一款终端模拟软件&#xff0c;用于在Windows界面下远程访问和使用不同系统下的服务器。免费版本下载地址&#xff1a; https://www.xshell.com/zh/free-for-home-…
阅读更多...
【Django】如何设置支持多语种网站，中文/英文网站

【Django】如何设置支持多语种网站，中文/英文网站

首先&#xff0c;需要明确一点&#xff1a;我们要实现的中英对照翻译&#xff0c;这个翻译不是浏览器翻译的&#xff0c;也不是Django帮你翻译。这个需要你自己事先手动翻译好&#xff0c;存放在专门翻译文件中&#xff0c;Django只是事后调用而已。 第一步 新建项目后&#x…
阅读更多...
[职场] 英语面试自我介绍 #微信#笔记#媒体

[职场] 英语面试自我介绍 #微信#笔记#媒体

英语面试自我介绍 英语面试自我介绍1 I am very happy to introduce myself here.I was born in Liaoning Province.I graduated from Nankai University and majored in International Trade.I like music and reaing books,especially economical books.It is my honor to ap…
阅读更多...
测试人员的自我修养

测试人员的自我修养

QAS:是负责检查和评估软件产品质量的专业人员&#xff0c;他们通过执行一系列测试来确保软件产品的功能、性能和安全性符合设计要求。 当产品上线后&#xff0c;有 bug&#xff1a; “测试为什么没有测试发现这个问题&#xff1f;肯定是测试的责任&#xff01;” 当产品上线…
阅读更多...
LabVIEW CVT离合器性能测试

LabVIEW CVT离合器性能测试

介绍了CVT&#xff08;连续变速器&#xff09;离合器的性能测试的一个应用。完成了一个基于LabVIEW软件平台开发的CVT离合器检测与控制系统&#xff0c;通过高效、准确的测试方法&#xff0c;确保离合器性能达到最优。 系统采用先进的硬件配合LabVIEW软件&#xff0c;实现了对…
阅读更多...
C语言在Visual Studio 2010环境下使用＜regex.h＞正则表达式函数库

C语言在Visual Studio 2010环境下使用＜regex.h＞正则表达式函数库

在Visual Studio 2010环境下&#xff0c;如果C语言想要使用<regex.h>头文件进行正则表达式匹配&#xff0c;则需要pcre3.dll这个动态链接库&#xff0c;可以去网上下载。 下载的网址是&#xff1a;Pcre for Windowspcre {whatisit}https://gnuwin32.sourceforge.net/pac…
阅读更多...
[Python] scikit-learn中数据集模块介绍和使用案例

[Python] scikit-learn中数据集模块介绍和使用案例

sklearn.datasets模块介绍 在scikit-learn中&#xff0c;可以使用sklearn.datasets模块中的函数来构建数据集。这个模块提供了用于加载和生成数据集的函数。 API Reference — scikit-learn 1.4.0 documentation 以下是一些常用的sklearn.datasets模块中的函数 load_iris() …
阅读更多...
回归预测 | Matlab基于OOA-LSSVM鱼鹰算法优化最小二乘支持向量机的数据多输入单输出回归预测

回归预测 | Matlab基于OOA-LSSVM鱼鹰算法优化最小二乘支持向量机的数据多输入单输出回归预测

回归预测 | Matlab基于OOA-LSSVM鱼鹰算法优化最小二乘支持向量机的数据多输入单输出回归预测 目录 回归预测 | Matlab基于OOA-LSSVM鱼鹰算法优化最小二乘支持向量机的数据多输入单输出回归预测预测效果基本介绍程序设计参考资料 预测效果 基本介绍 Matlab基于OOA-LSSVM鱼鹰算法…
阅读更多...
Python||五城P.M.2.5数据分析与可视化_使用华夫图分析各个城市的情况（下）

Python||五城P.M.2.5数据分析与可视化_使用华夫图分析各个城市的情况（下）

目录 沈阳市的空气质量 华夫图 柱状图 总结 五城P.M.2.5数据分析与可视化——北京市、上海市、广州市、沈阳市、成都市&#xff0c;使用华夫图和柱状图分析各个城市的情况 沈阳市的空气质量 华夫图 import numpy as np import pandas as pd import matplotlib.pyplot as plt …
阅读更多...
TorchVision的使用方法、更改默认路径

TorchVision的使用方法、更改默认路径

TorchVision的使用 1. 转换和增强图像 torchvision.transforms.v2 参数作用Resize将输入调整为给定大小RandomShortestSize随机调整输入的大小RandomResize随机调整输入的大小RandomCrop在随机位置裁剪输入RandomResizedCrop裁剪输入的随机部分并将其调整为给定大小RandomIoU…
阅读更多...
《最新出炉》系列初窥篇-Python+Playwright自动化测试-11-playwright操作iframe-上篇

《最新出炉》系列初窥篇-Python+Playwright自动化测试-11-playwright操作iframe-上篇

1.简介 原估计宏哥这里就不对iframe这个知识点做介绍和讲解了&#xff0c;因为前边的窗口切换就为这种网页处理提供了思路&#xff0c;另一个原因就是虽然iframe很强大&#xff0c;但是现在很少有网站用它了。但是还是有小伙伴或者童鞋们私下问这个问题&#xff0c;那么宏哥就…
阅读更多...
【后端开发】正向代理与反向代理

【后端开发】正向代理与反向代理

正向代理 正向代理&#xff08;forward proxy&#xff09;&#xff1a;是一个位于客户端和目标服务器之间的服务器(代理服务器)&#xff0c;为了从目标服务器取得内容&#xff0c;客户端向代理服务器发送一个请求并指定目标&#xff0c;然后代理服务器向目标服务器转交请求并将…
阅读更多...
BUUCTF-Real-[ThinkPHP]2-Rce1

BUUCTF-Real-[ThinkPHP]2-Rce1

任意代码执行漏洞 ThinkPHP 2.x版本中&#xff0c;使用preg_replace的/e模式匹配路由&#xff1a; $res preg_replace((\w).$depr.([^.$depr.\/])e, $var[\\\1\]"\\2";, implode($depr,$paths)); 导致用户的输入参数被插入双引号中执行&#xff0c;造成任意代码执行…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023