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

news2024/9/20 5:53:56

迷宫

题目描述

下图给出了一个迷宫的平面图，其中标记为 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 和 ans
        if (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;
    else
        dfs(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; // 起点到起点的距离设为0

    while (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.coloradmin.cn/o/1536154.html

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

相关文章

表格列内容过长显示省略号，并悬浮展示信息

表格列内容过长显示省略号，并悬浮展示信息

自定义全局指令&#xff1a; 指定超出行数的内容&#xff0c;以省略号替代。 // main.ts import App from ./App.vue;const app createApp(App);// 自定义指令app.directive(textOverflow, {mounted(el, binding, vnode) {const maxRows binding.value || 3;// 添加样式vnod…
阅读更多...
哪些因素决定SSL证书的定价？DV、OV和EV证书多少钱？

哪些因素决定SSL证书的定价？DV、OV和EV证书多少钱？

在当前网络环境安全问题日益凸显的时代背景下&#xff0c;SSL证书已成为保障网站及用户数据传输安全的核心手段。然而&#xff0c;由于不同供应商、证书类型和功能差异&#xff0c;SSL证书的价格存在较大浮动空间。本文将概述SSL证书的基本定价范围及其决定因素&#xff0c;为选…
阅读更多...
什么快递可以寄摩托车？看你要啥样的了

什么快递可以寄摩托车？看你要啥样的了

一辆49cc的二冲程摩托车仅需561元。 购买125的组装车不会超过1元&#xff0c;购买250品牌发动机的组装车不会超过4000元。 购买一辆名牌摩托车大约需要4000到10000元。 花一万到两百万多就能买到一辆像样、动力强劲、能玩的炫酷摩托车。 哈哈&#xff0c;就看你想要什么了&…
阅读更多...
基于ssm的乡镇自来水收费系论文

基于ssm的乡镇自来水收费系论文

摘 要 互联网发展至今&#xff0c;无论是其理论还是技术都已经成熟&#xff0c;而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播&#xff0c;搭配信息管理工具可以很好地为人们提供服务。针对乡镇自来水收费信息管理混乱&#xff0c;出错率高&#xff0c;信息安…
阅读更多...
算法第三十一天-直方图的水量

算法第三十一天-直方图的水量

直方图的水量 题目要求 解题思路 使用面向列的计算比面向行的计算更加容易。我们只需要考虑当前的位置的左右最高模板的高度。 方法一、暴力解法 每个位置能接到多少雨水&#xff0c;很容易想到[木桶效应]&#xff0c;即是由两边最短的木板限制的。那么直观思路就是&#x…
阅读更多...
PTA-练习5

PTA-练习5

目录 实验7-2-1 求矩阵各行元素之和 实验7-2-2 矩阵运算 实验7-2-3 求矩阵的局部极大值 实验7-2-5 判断上三角矩阵 实验7-2-6 打印杨辉三角 实验7-2-7 方阵循环右移 实验7-2-8 找鞍点 实验7-2-1 求矩阵各行元素之和 #include<stdio.h> #include<stdlib.h> …
阅读更多...
uniapp微信小程序_购物车_下单页面

uniapp微信小程序_购物车_下单页面

先说下整体逻辑以方便总体理解 1、首先画出下单页面 2、此次画出结算价格页面 3、怎么点击下完单变成结算页面&#xff1f;其实就是把下单页面的信息传递给结算页面就行 问题难点&#xff1f; 点击加号的时候把物品加入一个数组传到下单页面&#xff0c;但是点击的时候不能…
阅读更多...
再谈 Flink 的 “动态表” 和 “流表二象性”

再谈 Flink 的 “动态表” 和 “流表二象性”

博主历时三年精心创作的《大数据平台架构与原型实现&#xff1a;数据中台建设实战》一书现已由知名IT图书品牌电子工业出版社博文视点出版发行&#xff0c;点击《重磅推荐&#xff1a;建大数据平台太难了&#xff01;给我发个工程原型吧&#xff01;》了解图书详情&#xff0c;…
阅读更多...
Modbus串口通信

Modbus串口通信

Modbus ASCII与RTU? 发送报文的方式不一样 ASCII:将数据转换成1 6进制ASCII码再发送 RTU:直接发送原始报文当然也是进制 Modbus-与RS485有何区别? Modbus是通信协议 RS485电气接口规范 Modbus软件 RS485硬件 比如高速公路与汽车的关系&#xff0c;TCP/IP与网线…
阅读更多...
瑞_Redis_商户查询缓存_什么是缓存

瑞_Redis_商户查询缓存_什么是缓存

文章目录 项目介绍1 短信登录2 商户查询缓存2.1 什么是缓存2.1.1 缓存的应用场景2.1.2 为什么要使用缓存2.1.3 Web应用中缓存的作用2.1.4 Web应用中缓存的成本 附&#xff1a;缓存封装工具类 &#x1f64a; 前言&#xff1a;本文章为瑞_系列专栏之《Redis》的实战篇的商户查询缓…
阅读更多...
Mq之pulsar的入门使用（一）

Mq之pulsar的入门使用（一）

目录 一、linux集群安装pulsar 注意事项 编辑 /etc/hostname与/etc/hosts 执行初始化命令 二、创建应用程序对消息的生产和消费进行测试 物理主机启动应用发送消息时报错处理程序的搭建及说明使用到的pom依赖springboot中pulsar配置接收消息模拟发送消息发送与接收消息打印…
阅读更多...
Java-SSM医院在线预约系统

Java-SSM医院在线预约系统

Java-SSM医院在线预约系统 1.服务承诺&#xff1a; 包安装运行&#xff0c;如有需要欢迎联系&#xff08;VX:yuanchengruanjian&#xff09;。 2.项目所用框架: 前端:JSP、layui等。 后端:SSM,即Spring、SpringMvc、Mybatis等。 3.项目功能点: 1.管理员功能: a.修改个人信息…
阅读更多...
【图解物联网】第6章 物联网与数据分析

【图解物联网】第6章 物联网与数据分析

6.1 传感器数据与分析 从前几章中我们已经了解到&#xff0c;只要把配备传感器的设备连接到网络&#xff0c;就能把所有的信息采集到物联网服务之中&#xff08;图6.1&#xff09;。 从工业角度而言&#xff0c;给工厂中的生产流水线和流通的产品打上电子标签&#x…
阅读更多...
Linux 系统是如何收发⽹络包的

Linux 系统是如何收发⽹络包的

Linux 系统是如何收发⽹络包的&#xff1f; ⽹络模型 为了使得多种设备能通过⽹络相互通信&#xff0c;和为了解决各种不同设备在⽹络互联中的兼容性问题&#xff0c;国际标准化组织制定了开放式系统互联通信参考模型&#xff08;Open System Interconnection Reference Mode…
阅读更多...
了解Kafka位移自动提交的秘密：避免常见陷阱的方法

了解Kafka位移自动提交的秘密：避免常见陷阱的方法

欢迎来到我的博客&#xff0c;代码的世界里&#xff0c;每一行都是一个故事 了解Kafka位移自动提交的秘密&#xff1a;避免常见陷阱的方法 前言位移自动提交简介自动提交的优缺点自动提交位移的优点&#xff1a;自动提交位移的缺点&#xff1a;自动提交与手动提交的对比分析&am…
阅读更多...
安捷伦Agilent E4440A频谱分析仪

安捷伦Agilent E4440A频谱分析仪

181/2461/8938产品概述&#xff1a; 这是一篇关于安捷伦Agilent E4440A频谱分析仪的详细指南。在这篇文章中&#xff0c;您将了解该设备的基本概述、技术规格、使用方法、应用场景以及与其他类似设备的比较。让我们一起深入了解Agilent E4440A频谱分析仪的各个方面。 让我们简…
阅读更多...
软件杯 深度学习 机器视觉 人脸识别系统 - opencv python

软件杯 深度学习 机器视觉 人脸识别系统 - opencv python

文章目录 0 前言1 机器学习-人脸识别过程人脸检测人脸对其人脸特征向量化人脸识别 2 深度学习-人脸识别过程人脸检测人脸识别Metric Larning 3 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 深度学习 机器视觉 人脸识别系统 该项目…
阅读更多...
DashVector - 阿里云向量检索服务

DashVector - 阿里云向量检索服务

DashVector 文章目录 DashVector一、关于 DashVector二、使用 DashVector 前提准备1、创建Cluster&#xff1a;2、获得API-KEY3、安装最新版SDK 三、快速使用 DashVector1. 创建Client2. 创建Collection3、插入Doc4、相似性检索5、删除Doc6. 查看Collection统计信息7. 删除Coll…
阅读更多...
js中多重引号会导致函数的参数失效报错-Invalid or unexpected token

js中多重引号会导致函数的参数失效报错-Invalid or unexpected token

在js使用中我们经常会使动态添加html信息到元素对象中&#xff0c;且还加入了函数及其&#xff0c;函数对应参数&#xff0c;这个时候就会使用多重引号去拼接&#xff0c;如果拼接中没有做引号的转义&#xff0c;就会出现Invalid or unexpected token。 例如以下代码&#xff0…
阅读更多...
【嵌入式——QT】Charts常见的图表的绘制

【嵌入式——QT】Charts常见的图表的绘制

【嵌入式——QT】Charts常见的图表的绘制 柱状图QBarSetQBarSeriesQBarCategoryAxis图示 饼图堆叠柱状图百分比柱状图散点图和光滑曲线图代码示例 柱状图 QBarSet 用于创建柱状图的数据集。 主要函数 setLabel()&#xff1a;设置数据集标签 &#xff1b;setLabelBrush()&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023