迷宫（蓝桥杯）——DFS和BFS

迷宫

题目描述

下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可以通行的地方。

010000
000100
001001
110000

迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。

对于上面的迷宫，从入口开始，可以按 DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中
D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），
请找出一种通过迷宫的方式，其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。

请注意在字典序中 D<L<R<U。

01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000

暴力DFS

这段代码是一个迷宫求解程序，使用深度优先搜索（DFS）算法来找到从迷宫的左上角（起点）到右下角（终点）的最短路径。下面是对代码的详细注释：

#include<bits/stdc++.h>
using namespace std;// 定义列数和行数
const int col=30, row=50;// 迷宫的二维数组，0表示可通行，1表示障碍
int mp[col+1][row+1] = {// 迷宫的具体布局，这里省略了具体的数字，只给出了格式// ...
};// 用于记录路径的字符数组
char a[col*row];// 用于保存最终路径的字符串
string s;// 记录从起点到终点的最短步数
int best = INT_MAX;// 判断函数，用来判断当前坐标是否在迷宫内部且为可通行区域
int judge(int x, int y) {if (x > 0 && x <= col && y > 0 && y <= row && v[x][y] == 0 && mp[x][y] == 0)return 1;return 0;
}// 深度优先搜索函数，用于寻找路径
void dfs(int x, int y, int step) {// 如果当前步数已经超过已知的最短步数，则直接返回if (step > best)return;// 如果已经到达终点（迷宫的右下角），则记录路径if (x == col && y == row) {string temp;// 将路径中的每一步转换为字符串形式并拼接for (int i = 0; i < step; i++)temp += a[i];// 如果当前路径比已知的最短路径更短，则更新最短路径if (step < best) {best = step;s = temp;}// 如果当前路径与已知的最短路径同样短，但字典序更小，则更新最短路径else if (step == best && temp < s)s = temp;return;}// 定义四个可能的移动方向：上、下、左、右int dir_x[4] = {-1, 1, 0, 0};int dir_y[4] = {0, 0, -1, 1};char dir[4] = {'U', 'D', 'L', 'R'};// 遍历所有可能的移动方向for (int i = 0; i < 4; i++) {int x_1 = x + dir_x[i];int y_1 = y + dir_y[i];// 如果新的位置在迷宫内部且为可通行区域if (judge(x_1, y_1)) {// 记录当前方向到路径数组中a[step] = dir[i];// 标记当前位置为已访问v[x_1][y_1] = 1;// 递归调用dfs函数，继续搜索下一个位置dfs(x_1, y_1, step + 1);// 回溯，将当前位置标记为未访问v[x_1][y_1] = 0;}}
}int main() {// 将起点标记为已访问v[1][1] = 1;// 调用dfs函数开始搜索dfs(1, 1, 0);// 输出最终找到的最短路径cout << s << endl;// 输出最短路径的步数cout << best << endl;return 0;
}

这段代码的主要逻辑是通过深度优先搜索来遍历迷宫的所有可能路径，同时记录并更新最短路径。在搜索过程中，使用了一个二维数组 v 来标记已经访问过的位置，以避免重复访问。当到达终点时，会检查当前路径的步数是否比已知的最短路径更短，或者在步数相同的情况下是否字典序更小。如果满足条件，就会更新最短路径。最后，程序输出找到的最短路径及其步数。

因为dfs是遍历到每一条路径，所以代码编译时间一定很长，但这是填空题，所以暴力也是一种办法
在这里插入图片描述
所以，我们需要优化

这个方法好像不行，我运行4个小时也没出答案，应该是递归太多栈溢出了

DFS+剪枝优化

根据上面代码以及截图来看，如果我们定义一个mins数组来存储从起点到该点的位置，如果 pos+1 大于 mins[tox][toy]，那么当前路径不会是到达 (tox, toy) 的最短路径，因此没有必要继续在这个方向上搜索，可以剪枝，节省搜索时间。

因此，我们只需要在if判断中加入pos+1<=mins[tox][toy]条件即可

if(judge(tox,toy)&&pos+1<=mins[tox][toy])//判断下一步是否合法且如果pos+1大于起点到（tox，toy）的步骤，依然无意义

代码详细注释如下：

// 引入必要的头文件
#include<iostream>
#include<cstring> // 用于 memset 函数
#include<string> // 用于 string 类型
using namespace std;// 定义四个可能的移动方向：右（R）、左（L）、下（D）、上（U）
const int dirx[4] = {0, 0, 1, -1}; // x 坐标的变动
const int diry[4] = {1, -1, 0, 0}; // y 坐标的变动
const char dir[4] = {'R', 'L', 'D', 'U'}; // 方向的缩写// 定义迷宫的行数和列数
const int row = 30, col = 50;// 定义一个字符数组，用于记录最终的路径序列
char a[row * col + 5];// 定义一个字符串，用于存储最终的路径序列
string ans;// 定义迷宫数组，0 表示可通行，1 表示障碍
int maze[row + 1][col + 1] = {// 迷宫的具体布局，这里省略了具体的数字，只给出了格式// ...
};// 判断函数，用于检查坐标 (x, y) 是否在迷宫内部且为可通行区域
int judge(int x, int y) {if (x > 0 && x <= row && y > 0 && y <= col && maze[x][y] == 0)return 1;return 0;
}// 深度优先搜索函数，用于寻找通往出口的最短路径
void dfs(int x, int y, int pos) {// 如果当前步数已经超过已知的最短步数 best，则直接返回if (pos > best)return;// 如果已经到达终点（迷宫的右下角），则记录路径if (x == row && y == col) {// 根据路径记录构建字符串string temp;for (i = 0; i < pos; i++) {temp += a[i];}// 如果当前路径比已知的最短路径更短，则更新 best 和 ansif (pos < best) {ans = temp;best = pos;} else if (pos == best && temp < ans) {ans = temp;}return;}// 遍历四个可能的移动方向for (int i = 0; i < 4; i++) {int tox = x + dirx[i];int toy = y + diry[i];// 如果新的位置在迷宫内部且为可通行区域if (judge(tox, toy)) {// 标记当前位置为已访问maze[tox][toy] = 1;// 更新到新位置的最短步数mins[tox][toy] = pos + 1;// 记录移动方向到路径数组中a[pos] = dir[i];// 递归调用 dfs 函数，继续搜索下一个位置dfs(tox, toy, pos + 1);// 回溯，将当前位置标记为未访问maze[tox][toy] = 0;}}
}// 主函数
int main() {// 初始化 mins 数组，将所有值设置为一个非常大的数，表示无穷大memset(mins, 1, sizeof(mins));// 初始化 best 为一个非常大的数，用于记录从起点到终点的最小步数best = 1 << 28;// 将迷宫入口（1, 1）标记为已访问maze[1][1] = 1;// 调用 dfs 函数开始搜索dfs(1, 1, 0);// 输出最终找到的最短路径cout << ans << endl;// 输出最短路径的步数cout << best << endl;return 0;
}

这段代码的主要逻辑是通过深度优先搜索来遍历迷宫的所有可能路径，同时记录并更新最短路径。在搜索过程中，使用了一个二维数组 mins 来记录从起点到每个点的最短步数，以及一个字符数组 a 来记录路径中的每一步移动方向。当到达终点时，会检查当前路径的步数是否比已知的最短路径更短，或者在步数相同的情况下是否字典序更小。如果满足条件，就会更新最短路径。最后，程序输出找到的最短路径及其步数。

难点解释：pos+1<=mins[tox][toy]

在这段代码中，pos+1<=mins[tox][toy] 这一行的作用是检查当前扩展的路径是否可能成为到达新位置 (tox, toy) 的更短或等长但字典序更优的路径。

具体来说，这里的 pos 表示当前路径的步数，mins[tox][toy] 存储的是到达位置 (tox, toy) 的最短步数。如果 pos+1（即当前路径步数加一，因为我们要移动到新位置）小于或等于 mins[tox][toy]，这意味着我们找到了一个到达该位置的路径，其步数不比已知的最短步数多，或者步数相同时路径的字典序更优（因为在这段代码中，路径是通过字符数组 a 记录的，所以可以直接比较字符串的字典序）。

如果 pos+1 大于 mins[tox][toy]，那么当前路径不会是到达 (tox, toy) 的最短路径，因此没有必要继续在这个方向上搜索，可以剪枝，节省搜索时间。

这个条件检查是典型的在图搜索算法中用于优化和剪枝的技巧，它帮助算法避免在不可能改善当前最短路径的方向上浪费时间。通过这种方式，算法可以保证在找到出口时，记录的路径是最短的，并且在步数相同时字典序最小的路径。

踩过的坑：memset(mins, 1, sizeof(mins));

这里我没理解memset函数的作用，其实memset这个函数只能将整型数组初始化为0和-1，对于其他数字的初始化则不行，例如这里memset(mins, 1, sizeof(mins));则是将mins数组初始化为16843009，这是一个非常大的数

BFS

#include<bits/stdc++.h> // 包含所有标准库
using namespace std;
typedef pair<int,int> PII; // 定义一个类型别名，方便表示坐标对const int col=30,row=50; // 定义迷宫的列数和行数// 迷宫的布局，0表示可通行的路径，1表示障碍
int mp[col][row] = {
0,1,0,1,0,1,0,1,0,0,1,0,1,1,0,0,1,0,0,1,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,
0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1,0,1,0,0,1,0,1,
0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,
0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,0,0,1,0,1,1,
0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,
1,1,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,1,0,1,0,1,1,0,0,0,1,1,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,0,1,1,1,
0,0,0,1,1,0,1,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,1,0,0,0,0,0,0,0,
1,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0,
0,0,1,1,1,0,0,0,0,0,1,0,1,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,0,0,0,0,1,0,0,1,
1,1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0,0,1,0,0,0,1,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,
0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,0,1,0,1,
1,1,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,
0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,1,1,0,0,1,1,1,1,0,1,0,0,0,1,1,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,1,1,
1,0,1,0,1,0,1,0,0,1,1,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,1,1,0,0,1,1,1,1,0,1,1,0,1,0,0,0,0,1,0,0,0,
1,0,1,0,1,0,1,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,1,1,0,1,1,1,0,1,0,0,1,
1,0,0,0,0,0,0,0,1,0,1,1,0,0,0,1,0,0,0,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,
1,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,1,1,1,1,0,1,0,1,0,0,1,
0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,0,1,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,1,0,1,1,0,1,1,1,0,0,0,0,1,1,0,1,0,1,
1,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,1,0,
0,0,0,0,1,0,0,0,1,1,0,0,0,0,1,1,0,1,0,1,1,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,
1,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,0,0,0,0,1,
0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,
1,0,1,0,0,0,0,1,0,0,0,1,1,0,0,1,0,0,0,1,0,0,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,0,1,0,
0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,
1,1,0,1,0,0,0,0,0,0,1,0,0,1,1,1,0,1,1,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,0,0,1,0,1,1,0,1,1,1,0,1,0,0,0,
0,0,0,0,0,1,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0,0,0,0,0,0,1,1,0,0,1,1,
1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,1,0,0,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,
1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,1,0,1,1,1,0,1,0,0,0,
0,0,1,1,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,
1,0,0,0,0,0,0,1,1,0,0,1,1,1,0,1,0,1,1,1,0,1,0,0,0,1,0,0,0,1,1,0,1,1,1,0,1,0,1,0,1,1,0,1,1,1,1,0,0,0
};int d[col+1][row+1]; // 定义一个二维数组，用于记录从起点到每个点的最短距离queue<PII> p; // 创建一个队列，用于存放待探索的坐标// 定义一个结构体，用于记录路径信息
struct node {int x; // 父节点的x坐标int y; // 父节点的y坐标char s; // 父节点的方向
};node fa[col][row]; // 创建一个二维数组，用于记录每个点的父节点信息// dx和dy数组用于表示四个方向的相对坐标变化
int dx[5] = {1, 0, 0, -1};
int dy[5] = {0, -1, 1, 0};// dir数组用于表示四个方向的字符，按照字典序排序
char dir[5] = {'D', 'L', 'R', 'U'};// 判断函数，用于检查坐标是否在迷宫内，且为可通行的路径，且未被探索过
int judge(int x, int y) {if (x >= 0 && x < col && y >= 0 && y < row && mp[x][y] == 0 && d[x][y] == -1)return 1;return 0;
}// 深度优先搜索函数，用于探索迷宫
void dfs(int x, int y) {if (x == col - 1 && y == row - 1) // 如果到达终点，则停止搜索return;elsedfs(fa[x][y].x, fa[x][y].y); // 递归探索父节点//因为father(29,49)存储了它上一个位置在哪，那么就可以顺藤摸瓜的找出再上一个位置//如此搜索下去，直到搜到（0，0）位置而终止，返回上一层打印出所记录的direction方位，//逐层返回，就把从（0，0）走到（29，49）所途径的所有点时的direction都打印出来了cout << fa[x][y].s; // 输出路径
}int main() {memset(d, -1, sizeof(d)); // 初始化距离数组，将所有值设为-1，表示未探索p.push({0, 0}); // 将起点加入队列d[0][0] = 0; // 起点到起点的距离设为0while (p.size() != 0) { // 当队列不为空时，循环探索PII t = p.front(); // 取出队列中的第一个元素p.pop();for (int i = 0; i < 4; i++) { // 遍历四个方向int tx = t.first + dx[i]; // 计算目标坐标int ty = t.second + dy[i];if (judge(tx, ty)) { // 如果目标坐标可通行d[tx][ty] = d[t.first][t.second] + 1; // 更新距离p.push({tx, ty}); // 将目标坐标加入队列fa[tx][ty].x = t.first; // 记录父节点坐标fa[tx][ty].y = t.second;fa[tx][ty].s = dir[i]; // 记录方向//father(tox,toy)的x、y、s表明了//走到（tox，toy）这个点，是从其（x，y）点往s方向而来的 //换句话说，就是存储了它的上一个点的位置，以及从何方位而来 }}}dfs(col - 1, row - 1); // 从终点开始回溯，输出路径return 0;
}

这段代码的主要功能是找到从迷宫的左上角（起点）到右下角（终点）的最短路径，并按照字典序输出路径。代码使用了深度优先搜索算法，通过一个队列来实现层级遍历，同时记录每个点的父节点信息，以便最后回溯输出路径。

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

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

相关文章

[云] vmware: host: net: Net.CoaleseDefaultOn

[云] vmware: host: net: Net.CoaleseDefaultOn

https://communities.vmware.com/t5/Storage-Performance/Advanced-Networking-Performance-Options/ta-p/2792649 在vsphere client下的路径是&#xff1a; 选择使用的host -> 右键setting->configure-> system->advanced system setting->edit->Net.Coales…
阅读更多...
微信小程序开发之创建一个自己的项目和项目目录下各个文件的了解

微信小程序开发之创建一个自己的项目和项目目录下各个文件的了解

1、小程序开发工具基础 &#xff08;1&#xff09;菜单栏&#xff1a;可以对开发工具进行一些简单的设置&#xff0c;还可以在帮助一行获取学习相关api文档 &#xff08;2&#xff09;模拟器显示栏&#xff1a;每当我们在进行便写好代码之后&#xff0c;通过编译可以在模拟显示…
阅读更多...
华为ensp中ospf基础 原理及配置命令（详解）

华为ensp中ospf基础 原理及配置命令（详解）

CSDN 成就一亿技术人&#xff01; 作者主页&#xff1a;点击&#xff01; ENSP专栏&#xff1a;点击&#xff01; CSDN 成就一亿技术人&#xff01; ————前言———— OSPF 的全称是 Open Shortest Path First&#xff0c;意为“开放式最短路径优先”。是一种内部网关协…
阅读更多...
【算法刷题day3】Leetcode: 203.移除链表元素、707.设计链表、 206.反转链表

【算法刷题day3】Leetcode: 203.移除链表元素、707.设计链表、 206.反转链表

链表基础知识 分类&#xff1a; 单链表、双链表、循环连链表 存储方式&#xff1a; 链表中的节点在内存中不是连续分布的 &#xff0c;而是散乱分布在内存中的某地址上&#xff0c;分配机制取决于操作系统的内存管理。 链表的定义&#xff1a; struct ListNode{int val; //节…
阅读更多...
【如何安装odl: 1.0.0.dev0】

【如何安装odl: 1.0.0.dev0】

【如何安装odl: 1.0.0.dev0】 ODL官网 pip install odl可能容易报错&#xff0c;建议使用下述命令安装 pip install https://github.com/odlgroup/odl/archive/master.zip检查是否安装成功 conda list
阅读更多...
聊聊车载以太网PMA测试解决方案

聊聊车载以太网PMA测试解决方案

自2013年起&#xff0c;车载以太网技术日益成熟&#xff0c;在电子电气系统中应用越来越广泛&#xff0c;因此逐渐有很多主机厂和供应商加入到车载以太网技术的开发应用中&#xff0c;同时对传输速率的要求逐步提高&#xff0c;产生了传输速率更高的车载以太网技术&#xff0c;…
阅读更多...
低代码开发平台开源：依靠科技力量实现数字化转型！

低代码开发平台开源：依靠科技力量实现数字化转型！

在竞争激烈的当今社会&#xff0c;数字化转型、流程化办公等字眼早已充斥在我们的职场生活中。虽然如此&#xff0c;但是我们依然要面临着这样一个现实问题&#xff1a;很多中小企业发展面临着资源有限、技术储备不足、人才短缺的现实问题&#xff0c;进入流程化办公困境依然明…
阅读更多...
Linux东方通下载及使用

Linux东方通下载及使用

解压文件 mkdir /usr/local/java 加压包拖进去 vi /etc/profile 复制路径修改路径 export JAVA_HOME/usr/local/java/jdk1.8.0_151 export CLASSPATH.:${JAVA_HOME}/jre/lib/rt.jar:${JAVA_HOME}/lib/dt.jar:${JAVA_HOME}/lib/tools.jar export PATH$PATH:${JAVA_HOME}/bin 进入…
阅读更多...
Day41：WEB攻防-ASP应用HTTP.SYS短文件文件解析Access注入数据库泄漏

Day41：WEB攻防-ASP应用HTTP.SYS短文件文件解析Access注入数据库泄漏

目录 ASP-默认安装-MDB数据库泄漏下载 ASP-中间件-CVE&短文件&解析&写权限 HTTP.SYS&#xff08;CVE-2015-1635&#xff09;主要用作蓝屏破坏&#xff0c;跟权限不挂钩 IIS短文件(iis全版本都可能有这个问题) IIS文件解析 IIS写权限 ASP-SQL注入-SQLMAP使用…
阅读更多...
软件推荐 篇三十七：安卓软件推荐IP Tools「IP工具」：全面解析网络状态与管理的必备神器

软件推荐 篇三十七：安卓软件推荐IP Tools「IP工具」：全面解析网络状态与管理的必备神器

引言&#xff1a; 随着互联网的普及&#xff0c;网络已经成为我们日常生活中不可或缺的一部分。无论是工作、学习还是娱乐&#xff0c;我们都需要通过网络来进行各种操作。然而&#xff0c;网络问题的出现往往会给我们带来诸多困扰。为了更好地管理和优化网络&#xff0c;我们…
阅读更多...
SunFMEA冠翔（台山）工业FMEA培训会圆满结束

SunFMEA冠翔（台山）工业FMEA培训会圆满结束

近日&#xff0c;SunFMEA软件成功在冠翔&#xff08;台山&#xff09;工业有限公司举办了为期三天的FMEA软件系统培训&#xff0c;通过重要知识讲解、现场答疑、演练互动、软件实操等环节&#xff0c;把培训氛围推向高潮。 ​ 此次培训分为DFMEA与PFMEA两部分&#xff0c;按照七…
阅读更多...
LiveGBS流媒体平台GB/T28181常见问题-如何订阅设备状态在线离线状态redis订阅设备或是通道状态subscribe device操作及示例

LiveGBS流媒体平台GB/T28181常见问题-如何订阅设备状态在线离线状态redis订阅设备或是通道状态subscribe device操作及示例

LiveGBS如何订阅设备状态在线离线状态redis订阅设备或是通道状态subscribe device操作及示例 1、如何监听设备状态2、device订阅2.1、设备上线消息2.2、设备离线消息2.2、通道上线消息2.2、通道离线消息 3、订阅示例3.1、连接REDIS3.2、订阅device示例3.3、设备上线示例3.3.1、…
阅读更多...
用DevOpsGPT 5分钟开发一个网页小游戏

用DevOpsGPT 5分钟开发一个网页小游戏

前言&#xff1a; 今天教大家如何制作一个简易的网页小游戏&#xff0c;步骤很简单&#xff0c;我们只需要用到一个智能开发软件&#xff0c;即可自动帮助我们完成开发。话不多说&#xff0c;接下来&#xff0c;我们直接上教程&#xff01; ​ 官网&#xff1a;KUAFUAI - AI 驱…
阅读更多...
基于Matlab的视频人体动作识别，Matlab实现

基于Matlab的视频人体动作识别，Matlab实现

博主简介&#xff1a; 专注、专一于Matlab图像处理学习、交流&#xff0c;matlab图像代码代做/项目合作可以联系&#xff08;QQ:3249726188&#xff09; 个人主页&#xff1a;Matlab_ImagePro-CSDN博客 原则&#xff1a;代码均由本人编写完成&#xff0c;非中介&#xff0c;提供…
阅读更多...
智过网：一级建造师必须两年考过吗？有效期多久？

智过网：一级建造师必须两年考过吗？有效期多久？

在建筑行业&#xff0c;一级建造师的职业资格证书是众多从业者追求的目标。然而&#xff0c;获得这一证书并非易事&#xff0c;它要求考生不仅具备扎实的专业知识&#xff0c;还需要在限定的时间内完成所有科目的考试。那么&#xff0c;一级建造师是否必须在两年内考完所有科目…
阅读更多...
鸿蒙Harmony应用开发—ArkTS-全局UI方法（文本滑动选择器弹窗）

鸿蒙Harmony应用开发—ArkTS-全局UI方法（文本滑动选择器弹窗）

根据指定的选择范围创建文本选择器&#xff0c;展示在弹窗上。 说明&#xff1a; 该组件从API Version 8开始支持。后续版本如有新增内容&#xff0c;则采用上角标单独标记该内容的起始版本。 本模块功能依赖UI的执行上下文&#xff0c;不可在UI上下文不明确的地方使用&#xf…
阅读更多...
ArkTS编写的HarmonyOS原生聊天UI框架

ArkTS编写的HarmonyOS原生聊天UI框架

简介 ChatUI&#xff0c;是一个ArkTS编写的HarmonyOS原生聊天UI框架&#xff0c;提供了开箱即用的聊天对话组件。 下载安装 ohpm install changwei/chatuiOpenHarmony ohpm 环境配置等更多内容&#xff0c;请参考如何安装 OpenHarmony ohpm 包 接口和属性列表 接口列表 接…
阅读更多...
day15-maven高级

day15-maven高级

1. 分模块设计与开发 步骤 创建 maven 模块 tlias-pojo&#xff0c;存放实体类。创建 maven 模块 tlias-utils&#xff0c;存放相关工具类。 <dependency><groupId>com.itheima</groupId><artifactId>tlias-pojo</artifactId><version>1.0…
阅读更多...
线性表：关于链表（主要以单链表为例）的相关理解和应用

线性表：关于链表（主要以单链表为例）的相关理解和应用

多清澈这天空 晴雨相拥 同心逐梦&#xff01; 坚守我信心 一路出众&#xff01;&#xff01; 首先&#xff0c;按照惯例&#xff0c;欢迎大家边听歌边观看本博客 ▶ 紫荆花盛开 (163.com)&#xff08;建议复制链接&#xff0c;浏览器打开&#xff0c;csdn打开太慢了&#x…
阅读更多...
Error Lens插件

Error Lens插件

最近在看视频学习的时候&#xff0c;发现了一个我认为很好用的插件。 就是Error Lens&#xff0c;这个插件它能够以高亮、内联显示代码中的错误、警告和其他诊断信息&#xff0c;让开发者无需查看控制台或问题面板&#xff0c;就能在编辑代码的过程中直观地看到并快速定位到代码…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023