BFS经典例题合集

最新推荐文章于 2023-02-20 23:10:00 发布
最新推荐文章于 2023-02-20 23:10:00 发布
阅读量3k 收藏 28
点赞数 5
分类专栏： BFS 文章标签： bfs

转载请注明出处，谢谢 http://blog.csdn.net/ACM_cxlove?viewmode=contents by—cxlove

刚好yobobobo最近做BFS，我也被渲染了，当是复习一下，也总结一下吧，大部分是HDOJ上的BFS题目，由于本人时间有限，会持续更新

HDU 1548 http://acm.hdu.edu.cn/showproblem.php?pid=1548

基础的BFS，每次有两个方向，分别把步数乘以1和-1就行了。其余的都是基础BFS，注意下起点终点重合的情况

HDU 1372http://acm.hdu.edu.cn/showproblem.php?pid=1372

经典的马步移动，基本的BFS改成8个方向，同样处理即可

HDU 2717 http://acm.hdu.edu.cn/showproblem.php?pid=2717

3种情况移动，+1，-1，*2，没啥好说的，同样处理就行了，同时注意下边界，比目标大的话就只能全部-1，如果比目标大了就没必要*2

HDU 3766 http://acm.hdu.edu.cn/showproblem.php?pid=3766

比较坑，开始以为和1372一样，其实不是，这题没有给出范围，但是范围很大，之前需要逼近下，然后再搜索，或者直接枚举判断下就行了

HDU 1026 http://acm.hdu.edu.cn/showproblem.php?pid=1026

其实做法一样，需要打怪耗时，需要用优先队列或者最小堆来处理下，不过这题比较纠结的是需要输出路径，首先注意细节问题，之前用的是next，保存后继结点，果断被坑，一个点在搜索的时候的后继结点会有好多，果断改成pre,前趋表示。

HDU 1072 http://acm.hdu.edu.cn/showproblem.php?pid=1072

题目总体思路很明确，遇到数字4的话，时间重置下，在判重的时候需要用三维数组，加一个当前时间，如果两次到某点剩余时间相同，那就没必要再走了。

HDU 1175 http://acm.hdu.edu.cn/showproblem.php?pid=1175

弱爆了，果断也被坑了，开始觉得只要保存某个结点的方向和已拐的弯，然后搜索就行了，其实只要沿某条直线先一直搜到底就行了，不过还是要保存方向和已拐的弯的个数。

HDU 1180 http://acm.hdu.edu.cn/showproblem.php?pid=1180

注意下楼梯部分的细节问题就行了，可以停在原地等待楼梯转向，这里比较坑啊，而且楼梯处不需要标记，可能两个方向都要走

HDU 1242 http://acm.hdu.edu.cn/showproblem.php?pid=1242

果断BFS+优先队列

HDU 1728 http://acm.hdu.edu.cn/showproblem.php?pid=1728

类似于连连看，限制了拐弯次数，只需要每个方向走到底就行了，题目输入有些坑，行列有点混乱应注意。而且如果之前搜过的点，之后不能停止而是跳过。

HDU 2579 http://acm.hdu.edu.cn/showproblem.php?pid=2579

由于 在K的倍数的时候石头会消失，所以不能像其它迷宫问题一样判重，可能当前时间石头还在，而走一圈再回来石头消失，也许就有其它的路径可以走，因此判断的时候要加上三维数组flag[x][y][time%k]，如果到某点的时间取余都相同，那么此时的状态就是完全相同，没有意义的

HDU 2012 http://acm.hdu.edu.cn/showproblem.php?pid=2102
三维的BFS，注意一些细节就行了，譬如进入传送门就必须传送，而且另一边必须只有是空地才行，坑死了，读题不仔细

HDU 1253 http://acm.hdu.edu.cn/showproblem.php?pid=1253

三维BFS，木有问题，注意优化下

HDU 1240 http://acm.hdu.edu.cn/showproblem.php?pid=1240

三维BFS水之

HDU 1429 http://acm.hdu.edu.cn/showproblem.php?pid=1429

BFS+二进制压缩存储，很明显要保存你拿过的钥匙的状态，总共10把钥匙，使用二进制压缩才1024个状态，开始还打算把门的状态也保存下来，结果莫名其秒的TLE，后来发现只需要钥匙的状态，因为钥匙可以用很多次，但是又莫名其妙的MLE,好吧，不解释，彻底晕了flag[x][y][key],表示在（x,y）手上钥匙状态为key

HDU 1254 http://acm.hdu.edu.cn/showproblem.php?pid=1254

经典的推箱子游戏，注意判重需要一个三维数组，可用两次B FS解决，或者BFS+DFS

详情请移步 http://blog.csdn.net/acm_cxlove/article/details/7639306

HDU 2612 http://acm.hdu.edu.cn/showproblem.php?pid=2612

两个人到同一点的和最短，分别以两个人为起点，遍历整个图，计算出到每个KFC的最短距离，然后枚举所有的KFC,算最小的代价

HDU 1983 http://acm.hdu.edu.cn/showproblem.php?pid=1983

最差的情况直接把出口或者入口四个方向封住，所以最多只要堵4次。BFS找出最短的路径，并保存路径，DFS处理路径上的点，BFS判断是否连通。

HDU 1195 http://acm.hdu.edu.cn/showproblem.php?pid=1195

题目不难，1W个可能，判重很简单，就是转化有点纠结，至少我写得很矬

HDU 2128 http://acm.hdu.edu.cn/showproblem.php?pid=2128

坑爹的题目，不过题目很好，BFS和DFS都可以做

具体请见http://blog.csdn.net/acm_cxlove/article/details/7635497

贴代码：

HDU 1240 三维BFS

[cpp] view plain copy

/* 
ID:cxlove 
*/  
#include<iostream>  
#include<cstdio>  
#include<cstring>  
#include<queue>  
#define LL unsigned long long  
using namespace std;  
int n,m,q;  
int way[6][3]={{0,0,1},{0,0,-1},{0,1,0},{0,-1,0},{1,0,0},{-1,0,0}};  
char str[15][15][15];  
bool flag[15][15][15];  
struct Node{  
    int x,y,z,step;  
    bool check(){  
        if(x>=0&&y>=0&&z>=0&&x<n&&y<n&&z<n)  
            return true;  
        return false;  
    }  
}s,e,u,v;  
int bfs(){  
    if(s.x==e.x&&s.y==e.y&&s.z==e.z)  
        return 0;  
    queue<Node>que;  
    memset(flag,false,sizeof(flag));  
    s.step=0;  
    que.push(s);  
    flag[s.x][s.y][s.z]=true;  
    while(!que.empty()){  
        u=que.front();  
        que.pop();  
        for(int i=0;i<6;i++){  
            v=u;  
            v.x+=way[i][0];  
            v.y+=way[i][1];  
            v.z+=way[i][2];  
            v.step++;  
            if(v.check()&&flag[v.x][v.y][v.z]==false){               
                flag[v.x][v.y][v.z]=true;  
                if(v.x==e.x&&v.y==e.y&&v.z==e.z)  
                    return v.step;  
                if(str[v.x][v.y][v.z]=='X')  
                    continue;  
                que.push(v);  
            }  
        }  
    }  
    return -1;  
}  
char ch[100];  
int main(){  
    while(scanf("%s%d",ch,&n)!=EOF){  
        for(int i=0;i<n;i++)  
            for(int j=0;j<n;j++)  
                    scanf("%s",str[i][j]);  
        while(scanf("%s",ch)){  
            if(strcmp(ch,"END")==0)  
                break;  
            sscanf(ch,"%d",&s.x);  
            scanf("%d%d%d%d%d",&s.y,&s.z,&e.x,&e.y,&e.z);  
            int ans=bfs();  
            if(ans==-1)  
                printf("NO ROUTE\n");  
            else  
                printf("%d %d\n",n,ans);  
        }  

    }  
    return 0;  
}

HDU 1728 限制拐弯次数

[cpp] view plain copy

#include<iostream>  
#include<cstdio>  
#include<cstring>  
#include<queue>  
#define LL unsigned long long  
using namespace std;  
int n,m,k;  
int way[4][2]={{1,0},{-1,0},{0,1},{0,-1}};  
char str[105][105];  
bool flag[105][105];  
struct Node{  
    int x,y,dir,cnt;  
    bool check(){  
        if(x>=0&&x<n&&y>=0&&y<m)  
            return true;  
        return false;  
    }  
}s,e,u,v;  
int bfs(){  
    queue<Node>que;  
    que.push(s);  
    memset(flag,false,sizeof(flag));  
    flag[s.x][s.y]=true;  
    while(!que.empty()){  
        u=que.front();  
        que.pop();  
        for(int i=0;i<4;i++){  
            v.cnt=u.cnt;  
            if(u.dir!=-1&&u.dir!=i)  
                v.cnt++;  
            if(v.cnt>k)  
                continue;      
            v.dir=i;  
            for(int j=1;;j++){  
                v.x=u.x+way[i][0]*j;  
                v.y=u.y+way[i][1]*j;  
                if(v.check()&&str[v.x][v.y]!='*'){  
                    if(flag[v.x][v.y])  
                        continue;  
                    flag[v.x][v.y]=true;  
                    if(v.x==e.x&&v.y==e.y)  
                        return true;  
                    que.push(v);  
                }  
                else  
                    break;  
            }  
        }  
    }  
    return false;  
}  
int main(){  
    int t;  
    scanf("%d",&t);  
    while(t--){  
        scanf("%d%d",&n,&m);  
        for(int i=0;i<n;i++)  
            scanf("%s",str[i]);  
        scanf("%d%d%d%d%d",&k,&s.y,&s.x,&e.y,&e.x);  
        s.x--;s.y--;e.x--;e.y--;  
        s.cnt=0;s.dir=-1;  
        if((s.x==e.x&&s.y==e.y)||bfs())  
            printf("yes\n");  
        else  
            printf("no\n");  
    }  
    return 0;  
}

HDU 1242 BFS+优先队列

[cpp] view plain copy

#include<cstdio>  
#include<cstring>  
#include<iostream>  
#include<algorithm>  
#include<queue>  
#define LL long long  
using namespace std;  
struct Node{  
    int x,y,step;  
    bool operator<(const Node &n1)const{  
        return step>n1.step;  
    }  
}s,e,u,v;  
int n,m;  
char str[205][205];  
int way[4][2]={{0,1},{0,-1},{1,0},{-1,0}};  
int bfs(){  
    priority_queue<Node>que;  
    bool flag[205][205];  
    memset(flag,0,sizeof(flag));  
    s.step=0;  
    que.push(s);  
    flag[s.x][s.y]=1;  
    while(!que.empty()){  
        u=que.top();  
        que.pop();  
        for(int i=0;i<4;i++){  
            v.x=u.x+way[i][0];  
            v.y=u.y+way[i][1];  
            if(v.x>=0&&v.y>=0&&v.x<n&&v.y<m&&flag[v.x][v.y]==0&&str[v.x][v.y]!='#'){  
                flag[v.x][v.y]=1;  
                if(str[v.x][v.y]=='x')  
                    v.step=u.step+2;  
                else  
                    v.step=u.step+1;  
                if(v.x==e.x&&v.y==e.y)  
                    return v.step;  
                que.push(v);  
            }  
        }  
    }  
    return -1;  
}  
int main(){  
    while(scanf("%d%d",&n,&m)!=EOF){  
        for(int i=0;i<n;i++){  
            scanf("%s",str[i]);  
            for(int j=0;j<m;j++)  
                if(str[i][j]=='a'){  
                    s.x=i;  
                    s.y=j;  
                }  
                else if(str[i][j]=='r'){  
                    e.x=i;  
                    e.y=j;  
                }  
        }  
        int ans=bfs();  
        if(ans==-1)  
            printf("Poor ANGEL has to stay in the prison all his life.\n");  
        else  
            printf("%d\n",ans);  
    }  
    return 0;  
}

HDU 1429 BFS+二进制压缩

[cpp] view plain copy

#include<iostream>  
#include<cstdio>  
#include<cstring>  
#include<queue>  
#include<vector>  
#define LL unsigned long long  
using namespace std;  
int n,m,T;  
int way[4][2]={{0,1},{0,-1},{1,0},{-1,0}};  
char str[21][21];  
bool flag[21][21][1024];  
struct Node{  
    short x,y,step;  
    short key;  
    bool check(){  
        if(x>=0&&x<n&&y>=0&&y<m)  
            return true;  
        return false;  
    }  
}s,e,u,v;  
queue<Node>que;  
int bfs(){  
    if(!que.empty())  
        que.pop();  
    que.push(s);  
    memset(flag,false,sizeof(flag));  
    while(!que.empty()){  
        u=que.front();  
        que.pop();  

        for(int i=0;i<4;i++){  
            v=u;  
            v.step++;  
            v.x+=way[i][0];  
            v.y+=way[i][1];   

            if(v.step>=T)  
                break;  
            if(v.check()&&str[v.x][v.y]!='*'){  
                if(str[v.x][v.y]=='^')  
                    return v.step;  
                if(str[v.x][v.y]>='A'&&str[v.x][v.y]<='J'){  
                    if(((1<<(str[v.x][v.y]-'A'))&v.key)&&flag[v.x][v.y][v.key]==false){  
                        que.push(v);  
                        flag[v.x][v.y][v.key]=true;  
                    }  
                }  
                else if(str[v.x][v.y]>='a'&&str[v.x][v.y]<='j'){  
                    v.key|=(1<<(str[v.x][v.y]-'a'));  
                    if(flag[v.x][v.y][v.key]==false){             
                        que.push(v);  
                        flag[v.x][v.y][v.key]=true;  
                    }  
                }  
                else{  //相当于空地  
                    if(!flag[v.x][v.y][v.key]){  
                        flag[v.x][v.y][v.key]=true;  
                        que.push(v);  
                    }  
                }  
            }  

        }  
    }  
    return -1;  
}  
int main(){  
    while(scanf("%d%d%d",&n,&m,&T)!=EOF){  
        for(int i=0;i<n;i++){  
            scanf("%s",str[i]);  
            for(int j=0;j<m;j++){  
                if(str[i][j]=='@'){  
                    s.x=i;  
                    s.y=j;  
                    s.step=0;  
                    s.key=0;  
                }  
            }  
        }  
        printf("%d\n",bfs());  
    }  
    return 0;  
}
舒然---小广广
关注
  • 5
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BFS-广度优先搜索例题1
02-12
此题非彼题！正是洛谷P1162 填涂颜色之题！源代码简洁 10000000000000000000%推荐！此题非彼题！正是洛谷P1162 填涂颜色之题！源代码简洁 10000000000000000000%推荐！此题非彼题！正是洛谷P1162 填涂颜色之题！源代码简洁 10000000000000000000%推荐！此题非彼题！正是洛谷P1162 填涂颜色之题！源代码简洁 10000000000000000000%推荐！此题非彼题！正是洛谷P1162 填涂颜色之题！源代码简洁 10000000000000000000%推荐！此题非彼题！正是洛谷P1162 填涂颜色之题！源代码简洁 10000000000000000000%推荐！此题非彼题！正是洛谷P1162 填涂颜色之题！源代码简洁 10000000000000000000%推荐！此题非彼题！正是洛谷P1162 填涂颜色之题！源代码简洁 10000000000000000000%推荐！此题非彼题！正是洛谷P1162 填涂颜色之题！源代码简洁 10000000000000000000%推荐！此题非彼题！正是洛谷P1162 填涂颜色之题！
广度优先搜索遍历（BFS）在二维数组上的应用例题讲解
cug_cxy的博客
09-20 2830
广度优先搜索遍历又名BFS，属于盲目搜寻法，是图的搜索算法之一，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。下面列出几道经典例题，来带领大家一同求解。 （1）给定一个由 0 和 1 组成的矩阵 mat，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。两个相邻元素间的距离为 1 。 本题意思是求解数组中每个数到数字0的距离，0自己本身的距离为0，且距离只考虑上下左右四个方向，不..
bfs常见题型总结
Jefferson__的博客
08-15 1009
文章目录（一）bfs模板题（二）Flood Fill（三）最短路模型（四）多源bfs （一）bfs模板题 题目描述 给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。 最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。 请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。 数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。 输入格式
【刷题日记】BFS 经典题目
白晨的博客
10-04 2190
广度优先搜索（Breadth First Search）简称广搜或者 BFS，概念相对于深度优先搜索。深度优先搜索广度优先搜索可以看到深度优先搜索和广度优先搜索在二叉树的遍历上分别体现为前序遍历和层序遍历。广度优先搜索的思路首先，将开始遍历的结点加入队列，遍历这个结点后，将其孩子结点入队。接着，按照队列的顺序将结点出队，遍历并将其孩子结点入队。重复2过程，直到队列为空。广度优先搜索的优势没有过多的堆栈消耗，耗时少。在求最大或者最小问题时比较好用。
【刷题】BFS题目精选
qq_53893431的博客
07-04 1041
BFS刷题
【BFS】经典例题
SY奇星的OI博客
02-20 585
【BFS】经典例题
【算法模板】BFS秒杀模板—附练习题（开启大海贼时代）
小宝的博客
03-14 2580
男たちは グランド ライン を 目指し（めざし）梦を（ゆめを）追い（おい）続ける（つづける）。世はまさに大海贼 时代（じだい）。 于是男子汉们起程前往伟大的航路，追逐梦想，大海贼时代来临了。
图论之BFS问题详细介绍和例题练习
Carroll的博客
05-14 975
文章目录BFS单源BFS多源BFSBFS例题单源BFS例题多源BFS例题 BFS 单源BFS 单源BFS就是树的广搜思路，把根节点入队，然后一层层的遍历 多源BFS 多源BFS就是图的广搜思路，可以多个源点入队，为防止某个点入队多次，需要标记，多源BFS一般用于解决下面这种多源点问题，会提高代码执行效率。 BFS例题 单源BFS例题 多源BFS例题 1162. 地图分析 class Solution { public int maxDistance(int[][] grid) {
BFS小结（持续更新中）
tulunta
06-05 287
转载请注明出处，谢谢 http://blog.csdn.net/ACM_cxlove?viewmode=contents by---cxlove 刚好yobobobo最近做BFS，我也被渲染了，当是复习一下，也总结一下吧，大部分是HDOJ上的BFS题目，由于本人时间有限，会持续更新 HDU 1548 http://acm.hdu.edu.cn/showproblem.php?pid=154...
BFS练手题目
S5242的博客
05-27 464
文章目录1.员工的重要性2.腐烂的橘子3.N 叉树的层序遍历4. 单词接龙5.最小基因变化6.打开转盘锁 广度优先搜索（BFS）算法，概念就不说啥了，常用来求最短路径，最少步数等，比如求二叉树最小高度。 总体解体框架参考labuladong的算法小抄中的结构，如下图所示： 核心数据结构为一个queue,需要用于个queue记录每一层次的数据节点，还有一个visited的set或者其他结构来记录已经访问过的数据，还有一个step来控制扩散的层数。具体做题感受吧。 这里记录了几个经典例题： 1.员工的重要性
BFS.rar_bfs
09-22
BFS变度量算法，.............用于工程中的数值计算
bfs.zip_bfs
09-24
数据结构里的bfs算法，用vc6.0编写
bfs.rar_bFS maze
09-23
用广度搜索方法实现 找迷宫类游戏 从一点搜索到另一点
Python课程设计 课设 手写数字识别卷积神经网络源码+文档说明.zip
04-24
高分设计源码，详情请查看资源内容中使用说明 高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明
SpringBoot2.0快速开发框架权限.rar
04-24
SpringBoot2.0快速开发框架权限.rarSpringBoot2.0快速开发框架权限.rarSpringBoot2.0快速开发框架权限.rar
大语言模型的微调和推理baichuan7B, chatglm2-6B, Qwen-7B-chat源码.zip
04-24
详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；详情请查看资源内容中使用说明；
基于Qt与STM32平台开发的汽车车机系统上位机
04-24
基于Qt开发的汽车车机系统上位机 & 常见类型汽车传感器信号模拟发生器 任务和要求： 任务： 根据发动机测控系统信号需求，设计一套发动机信号模拟器人机交互系统，能够根据需要向下位机输出控制信号，使其输出发动机测控系统需要的传感器模拟信号，给发动机测控系统的开发提供方便。 要求： 1.设计应包含上位机与下位机的交互程序及人机交互界面的设计，与下位机设计相结合，使其能够实现全部类型发动机传感器信号的模拟输出及显示。 2.设计中需要采用模块化开发程序。 3.所设计的人机交互界面简洁合理。 4.应考虑所设计系统的实用性。 具体工作内容: 1.根据设计目标，查阅相关设计标准和设计方法资料，对发动机信号模拟器设计中的关键工程原理和工程方法进行提炼，并围绕关键问题进行国内外设计现状调研，开展分析、评价与总结，确定主要研究内容，制定设计技术路线，制定设计计划(周进度)，撰写开题报告，并进行开题答辩，开题报告参考文献应不少于15篇(其中外文文献不少于 4 篇，近五年文献不少于三分之一)。 2.根据设计要求和技术指标，进行满足功能原理需求的多方案拟定，考虑安全、 标准等多因素进行技术性与经济性评价
实验-三、数据库安全性(目的、要求和模板).doc
04-24
实验-三、数据库安全性(目的、要求和模板).doc
毕设绝技 - 4天玩乐完成商城系统完整资料day02
最新发布
04-24
文件为第二天视频教程 在毕业设计的挑战中，有时我们需要以极短的时间完成一个相对复杂的项目，比如一个商城系统。虽然时间紧迫，但只要我们合理规划、高效执行，完全有可能在4天内完成一个基础且功能完备的商城系统。 商城系统，也被称为网上商城系统或Online Mall system，是一种功能完善的网上销售系统。该系统主要包括产品发布、在线订购、在线支付、在线客服等功能模块，旨在为企业或个人提供一个在线销售平台，实现商品的展示、交易和客户服务。 商城系统具有多种核心功能，如商品管理、订单管理、用户管理和营销管理。商品管理功能支持商品的添加、编辑、删除、分类和搜索，满足商家对商品信息的全面管理需求。订单管理功能则涵盖订单的生成、支付、发货、退款和评价等环节，确保交易流程的顺畅进行。用户管理功能包括用户的注册、登录、个人信息管理和收货地址管理等，提升用户体验。而营销管理功能则通过促销活动的设置、优惠券的发放和积分兑换等手段，帮助商家提升销售业绩。 商城系统的特点主要体现在功能性、易用性和安全性上。商城系统注重功能性的开发，每个功能都有其发挥作用的地方，满足商家的实际需求。
BFS python
10-11
BFS（广度优先搜索）是一种用于图形遍历的算法，它从起始节点开始，逐层扩展搜索，直到找到目标节点或遍历完整个图形。下面是一个使用Python实现BFS的示例代码： ```python from collections import deque def bfs...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值