【C】dfs/bfs--9度OJ四题

最新推荐文章于 2023-02-02 23:10:52 发布
最新推荐文章于 2023-02-02 23:10:52 发布
阅读量425 收藏
点赞数
分类专栏： 考试 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Li_Jiaqian/article/details/79566132
版权

这里写图片描述

#include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
#include<queue>
using namespace std;
int g[51][51][51];
int mark[51][51][51]={0};
int l[][3]={1,0,0,
            -1,0,0,
            0,1,0,
            0,-1,0,
            0,0,1,
            0,0,-1};
struct INFO{
    int x,y,z;
    int t;
};
bool value(int A,int B,int C,int x,int y,int z){
    if(x>=0&&x<A&&y>=0&&y<B&&z>=0&&z<C) return true;
    else return false;
}
int bfs(int A,int B,int C,int T){
    INFO s;
    s.x=0;s.y=0;s.z=0;s.t=0;//将起始改为1，1，1
    mark[s.x][s.y][s.z]=1;
    queue<INFO> q;
    q.push(s);
    while(!q.empty()){
        INFO t=q.front();
        q.pop();
        for(int i=0;i<6;i++){
            int nx=t.x+l[i][0];
            int ny=t.y+l[i][1];
            int nz=t.z+l[i][2];
            if(!value(A,B,C,nx,ny,nz)) continue;
            if(g[nx][ny][nz]==1) continue;
            if(mark[nx][ny][nz]==1) continue;
            INFO tmp;
            tmp.x=nx;tmp.y=ny;tmp.z=nz;
            tmp.t=t.t+1;
            q.push(tmp);
            mark[nx][ny][nz]=1;
            if(nx==A-1&&ny==B-1&&nz==C-1) return tmp.t;
        }   
    }
    return -1;
}


        /*int x=s.x,y=s.y,z=t.z;
        if(x==A-1&&y==B-1&&z==C-1){
            return t.t;
        }
        INFO p;
        p.x=x-1;p.y=y;p.z=z;
        if(value(A,B,C,p.x,p.y,p.z)&&g[p.x][p.y][p.z]==0&&mark[p.x][p.y][p.z]==0){
            p.t=t.t+1;
            if(p.x==A-1&&p.y==B-1&&p.z==C-1){
                return p.t;
            }
            //if(p.t<=T){
                mark[p.x][p.y][p.z]=1;
                q.push(p);
            //}
        }
        p.x=x+1;p.y=y;p.z=z;
        if(value(A,B,C,p.x,p.y,p.z)&&g[p.x][p.y][p.z]==0&&mark[p.x][p.y][p.z]==0){
            p.t=t.t+1;
            if(p.x==A-1&&p.y==B-1&&p.z==C-1){
                return p.t;
            }
            //if(p.t<=T){
                mark[p.x][p.y][p.z]=1;
                q.push(p);
            //}
        }
        p.x=x;p.y=y-1;p.z=z;
        if(value(A,B,C,p.x,p.y,p.z)&&g[p.x][p.y][p.z]==0&&mark[p.x][p.y][p.z]==0){
            p.t=t.t+1;
            if(p.x==A-1&&p.y==B-1&&p.z==C-1){
                return p.t;
            }
            //if(p.t<=T){
                mark[p.x][p.y][p.z]=1;
                q.push(p);
            //}
        }
        p.x=x;p.y=y+1;p.z=z;
        if(value(A,B,C,p.x,p.y,p.z)&&g[p.x][p.y][p.z]==0&&mark[p.x][p.y][p.z]==0){
            p.t=t.t+1;
            if(p.x==A-1&&p.y==B-1&&p.z==C-1){
                return p.t;
            }
            //if(p.t<=T){
                mark[p.x][p.y][p.z]=1;
                q.push(p);
            //}
        }
        p.x=x;p.y=y;p.z=z-1;
        if(value(A,B,C,p.x,p.y,p.z)&&g[p.x][p.y][p.z]==0&&mark[p.x][p.y][p.z]==0){
            p.t=t.t+1;
            if(p.x==A-1&&p.y==B-1&&p.z==C-1){
                return p.t;
            }
            //if(p.t<=T){
                mark[p.x][p.y][p.z]=1;
                q.push(p);
            //}
        }
        p.x=x;p.y=y;p.z=z+1;
        if(value(A,B,C,p.x,p.y,p.z)&&g[p.x][p.y][p.z]==0&&mark[p.x][p.y][p.z]==0){
            p.t=t.t+1;
            if(p.x==A-1&&p.y==B-1&&p.z==C-1){
                return p.t;
            }
            //if(p.t<=T){
                mark[p.x][p.y][p.z]=1;
                q.push(p);
            //}
        }
    }
    return -1;
}*/


int main(){
    int n;
    scanf("%d",&n);
    while(n--){
        //fill(g[0][0],g[0][0]+51*51*51,1);//默认都是墙
        fill(mark[0][0],mark[0][0]+51*51*51,0);
        int A,B,C,T;
        scanf("%d%d%d%d",&A,&B,&C,&T);
        for(int i=0;i<A;i++){
            for(int j=0;j<B;j++){
                for(int k=0;k<C;k++){
                    scanf("%d",&g[i][j][k]);
                }
            }
        }
        int minT=bfs(A,B,C,T);
        if(minT<=T) printf("%d\n",minT);
        else printf("-1\n");

    }
}
/*1
3 3 4 20
0 1 1 1
0 0 1 1
0 1 1 1
1 1 1 1
1 0 0 1
0 1 1 1
0 0 0 0
0 1 1 0
0 1 1 0
》》
11*/

Ignatius再次被魔王抓走了(搞不懂他咋这么讨魔王喜欢)……

这次魔王汲取了上次的教训，把Ignatius关在一个n*m的地牢里，并在地牢的某些地方安装了带锁的门，钥匙藏在地牢另外的某些地方。刚开始Ignatius被关在(sx,sy)的位置，离开地牢的门在(ex,ey)的位置。Ignatius每分钟只能从一个坐标走到相邻四个坐标中的其中一个。魔王每t分钟回地牢视察一次，若发现Ignatius不在原位置便把他拎回去。经过若干次的尝试，Ignatius已画出整个地牢的地图。现在请你帮他计算能否再次成功逃亡。只要在魔王下次视察之前走到出口就算离开地牢，如果魔王回来的时候刚好走到出口或还未到出口都算逃亡失败。

输入描述:
每组测试数据的第一行有三个整数n,m,t(2<=n,m<=20,t>0)。接下来的n行m列为地牢的地图，其中包括:
. 代表路
* 代表墙
@ 代表Ignatius的起始位置
^ 代表地牢的出口
A-J 代表带锁的门,对应的钥匙分别为a-j a-j 代表钥匙，对应的门分别为A-J 每组测试数据之间有一个空行。

输出描述:
针对每组测试数据，如果可以成功逃亡，请输出需要多少分钟才能离开，如果不能则输出-1。

示例1

输入

4 5 17
@A.B.
a*.*.
..^
c..b*

4 5 16
@A.B.
a*.*.
..^
c..b*

输出

16
-1

#include<stdio.h>
#include<queue>
using namespace std;
int n,m,tx,ty,T;
char g[22][22];
int vis[22][22][1200]={0};
int l[][2]={1,0,
            -1,0,
            0,1,
            0,-1};
struct Node{
    int x,y;
    int deep;
    int key;
    Node(int x,int y,int deep,int key):x(x),y(y),deep(deep),key(key) {}
};
int bfs(int x,int y){
    queue<Node> q;
    q.push(Node(x,y,0,0));
    vis[x][y][0]=1;
    while(!q.empty()){
        Node t=q.front();
        q.pop();
        if(t.deep>=T) return -1;
        if(t.x==tx&&t.y==ty) return t.deep;
        for(int i=0;i<4;i++){
            int nx=t.x+l[i][0];
            int ny=t.y+l[i][1];
            if(nx<0||ny<0||nx>=n||ny>=m) continue;
            if(g[nx][ny]=='*') continue;
            int key=t.key;
            if(g[nx][ny]>='a'&&g[nx][ny]<='j') key=key|(1<<(g[nx][ny]-'a'));
            if(g[nx][ny]>='A'&&g[nx][ny]<='J'&&(key&(1<<(g[nx][ny]-'A')))==0) continue;
            if(vis[nx][ny][key]==0){
                vis[nx][ny][key]=1;
                q.push(Node(nx,ny,t.deep+1,key));
            }
        }
    }
    return -1;
}
int main(){
    int x,y;
    while(scanf("%d%d%d",&n,&m,&T)!=EOF){
        for(int i=0;i<n;i++){
            getchar();
            for(int j=0;j<m;j++){
                scanf("%c",&g[i][j]);
                if(g[i][j]=='@'){
                    x=i;y=j;
                }
                else if(g[i][j]=='^'){
                    tx=i;ty=j;
                }
            }
        }
        printf("%d\n",bfs(x,y));
    }
}

这里写图片描述

#include<stdio.h>
#include<queue>
using namespace std;
int mark[101][101][101];
struct INFO{
    int a,b,c;
    int t;
};
void AtoB(int &a,int sa,int &b,int sb){
    if(sb-b>=a){
        b+=a;
        a=0;
    }
    else{
        a=a-(sb-b);
        b=sb;
    }
}
int bfs(int s,int n,int m){
    INFO p;
    p.a=s;p.b=0;p.c=0;p.t=0;
    queue<INFO> q;
    q.push(p);
    while(!q.empty()){
        INFO t=q.front();
        q.pop();
        int na=t.a,nb=t.b,nc=t.c;
        AtoB(na,s,nb,n);
        if(mark[na][nb][nc]==0){
            mark[na][nb][nc]=1;
            if(na==s/2&&nb==s/2) return t.t+1;
            if(na==s/2&&nc==s/2) return t.t+1;
            if(nc==s/2&&nb==s/2) return t.t+1;
            INFO tmp;
            tmp.a=na;tmp.b=nb;tmp.c=nc;tmp.t=t.t+1;
            q.push(tmp);
        }
        na=t.a,nb=t.b,nc=t.c;
        AtoB(nb,n,na,s);
        if(mark[na][nb][nc]==0){
            mark[na][nb][nc]=1;
            if(na==s/2&&nb==s/2) return t.t+1;
            if(na==s/2&&nc==s/2) return t.t+1;
            if(nc==s/2&&nb==s/2) return t.t+1;
            INFO tmp;
            tmp.a=na;tmp.b=nb;tmp.c=nc;tmp.t=t.t+1;
            q.push(tmp);
        }
        na=t.a,nb=t.b,nc=t.c;
        AtoB(nb,n,nc,m);
        if(mark[na][nb][nc]==0){
            mark[na][nb][nc]=1;
            if(na==s/2&&nb==s/2) return t.t+1;
            if(na==s/2&&nc==s/2) return t.t+1;
            if(nc==s/2&&nb==s/2) return t.t+1;
            INFO tmp;
            tmp.a=na;tmp.b=nb;tmp.c=nc;tmp.t=t.t+1;
            q.push(tmp);
        }
        na=t.a,nb=t.b,nc=t.c;
        AtoB(nc,m,nb,n);
        if(mark[na][nb][nc]==0){
            mark[na][nb][nc]=1;
            if(na==s/2&&nb==s/2) return t.t+1;
            if(na==s/2&&nc==s/2) return t.t+1;
            if(nc==s/2&&nb==s/2) return t.t+1;
            INFO tmp;
            tmp.a=na;tmp.b=nb;tmp.c=nc;tmp.t=t.t+1;
            q.push(tmp);
        }
        na=t.a,nb=t.b,nc=t.c;
        AtoB(nc,m,na,s);
        if(mark[na][nb][nc]==0){
            mark[na][nb][nc]=1;
            if(na==s/2&&nb==s/2) return t.t+1;
            if(na==s/2&&nc==s/2) return t.t+1;
            if(nc==s/2&&nb==s/2) return t.t+1;
            INFO tmp;
            tmp.a=na;tmp.b=nb;tmp.c=nc;tmp.t=t.t+1;
            q.push(tmp);
        }
        na=t.a,nb=t.b,nc=t.c;
        AtoB(na,s,nc,m);
        if(mark[na][nb][nc]==0){
            mark[na][nb][nc]=1;
            if(na==s/2&&nb==s/2) return t.t+1;
            if(na==s/2&&nc==s/2) return t.t+1;
            if(nc==s/2&&nb==s/2) return t.t+1;
            INFO tmp;
            tmp.a=na;tmp.b=nb;tmp.c=nc;tmp.t=t.t+1;
            q.push(tmp);
        }
    }
    return -1;
}
int main(){
    int s,n,m;
    scanf("%d%d%d",&s,&n,&m);
    while(s!=0||n!=0||m!=0){
        fill(mark[0][0],mark[0][0]+101*101*101,0);
        if(s%2==1) printf("No\n");
        else if(s==0) printf("0\n");
        else{
            int t=bfs(s,n,m);
            printf("%d\n",t);
        }
        scanf("%d%d%d",&s,&n,&m);
    }
}
/*
7 4 3
4 1 3
0 0 0
》》
NO
3
*/

这里写图片描述
这里写图片描述

#include<stdio.h>
#include<queue>
#include<vector>
#include<math.h>
using namespace std;
int n,m;
char g1[110][110];
int mark[110][110];
int l[][2]={1,0,
           1,1,
           1,-1,
           -1,0,
           -1,1,
           -1,-1,
            0,1,
            0,-1};
void dfs(int x,int y){
    for(int i=0;i<8;i++){
        int nx=x+l[i][0];
        int ny=y+l[i][1];
        if(nx<0||nx>=n||ny<0||ny>=m) continue;
        if(mark[nx][ny]==1) continue;
        if(g1[nx][ny]!='@') continue;
        mark[nx][ny]=1;
        dfs(nx,ny);
    }
    return;
}
int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
        getchar();
        if(n==0&&m==0) return 0;
        fill(g1[0],g1[0]+110*110,'*');
        fill(mark[0],mark[0]+110*110,0);
        for(int i=0;i<n;i++){   
            for(int j=0;j<m;j++){
                scanf("%c",&g1[i][j]);
            }
            getchar();
        }
        /*printf("%d %d\n",n,m);
        for(int i=0;i<n;i++){   
            for(int j=0;j<m;j++){
                printf("%cLLL   ",g1[i][j]);
            }
            printf("\n");
        }*/
        int num=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(mark[i][j]==0&&g1[i][j]=='@'){
                    dfs(i,j);
                    num++;
                }
            }
        }
        printf("%d\n",num);
    }
    return 0;
}
/*
1 1
*
3 5
*@*@*
**@**
*@*@*
1 8
@@****@*
5 5 
****@
*@@*@
*@**@
@@@*@
@@**@
0 0
》》
0
1
2
2
*/

这里写图片描述
这里写图片描述

#include<stdio.h>
#include<queue>
#include<vector>
#include<math.h>
using namespace std;
struct INFO{
    int x,y;
    int t;
};
int l[][2]={1,0,
            -1,0,
            0,1,
            0,-1};
int n,m,T;
char g[8][8];
int mark[8][8]={0};
bool dfs(int x,int y,int t){
    if(g[x][y]=='D'&&t==T) return true;
    for(int i=0;i<4;i++){
        int nx=x+l[i][0];
        int ny=y+l[i][1];
        if(nx>=n||nx<0||ny>=m||ny<0) continue;
        if(mark[nx][ny]==1) continue;
        if(g[nx][ny]=='X') continue;
        mark[nx][ny]=1;
        if(dfs(nx,ny,t+1)) return true;//可以提前结束
        mark[nx][ny]=0;
    }
    return false;
}
int main(){
    while(scanf("%d%d%d",&n,&m,&T)!=EOF){
        if(n==0&&m==0&&T==0) break;
        fill(g[0],g[0]+64,'X');
        fill(mark[0],mark[0]+64,0);
        getchar();
        int bi,bj;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                scanf("%c",&g[i][j]);
                if(g[i][j]=='S'){
                    bi=i;bj=j;
                }
            }
            getchar();
        }
        if(dfs(bi,bj,0)) printf("YES\n");
        else printf("NO\n");
    }
}
Li_JiaQian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
九度OJ题目1456：胜利大逃亡（BFS算法）
风口的猪2016
03-14 595
题目描述： Ignatius被魔王抓走了,有一天魔王出差去了,这可是Ignatius逃亡的好机会.魔王住在一个城堡里,城堡是一个A*B*C的立方体,可以被表示成A个B*C的矩阵,刚开始Ignatius被关在(0,0,0)的位置,离开城堡的门在(A-1,B-1,C-1)的位置,现在知道魔王将在T分钟后回到城堡,Ignatius每分钟能从一个坐标走到相邻的六个坐标中的其中一个.现在给你城堡的地图
bfs题目集锦
weixin_30908941的博客
04-21 139
ZOJ1438 : http://acm.zju.edu.cn/show_problem.php?pid=1438 一道最基础的BFS题,就是求在三维迷宫中从一个点到另外一个点的最短距离. 就是在输入的时候它不像以前那样先行再列最后层数,要小心 /* * 简单的BFS * 由于输入问题一开始WA了n次 */ #include <iostream> #i...
OJ——C语言8数码难题（BFS）
weixin_43426254的博客
03-22 776
问题描述 ![在这里插入图片描述](https://img-blog.csdnimg.cn/e617f03ada62439cb6cac9af26a1408d.png) 初始状态的步数就算1，哈哈 输入：第一个33的矩阵是原始状态，第二个33的矩阵是目标状态。 输出：移动所用最少的步数 Input 2 8 3 1 6 4 7 0 5 1 2 3 8 0 4 7 6 5 Output 6 代码部分 因为最近在准备复试，所以具体的注释啥的就等以后有时间了再详细记录，主要就是用BFS的思路解决，菜鸡代码，大佬勿喷。
DFS(深搜算法)问题2之迷宫问题—杭电OJ 1010
smallrain6的博客
02-07 778
读者可先学习深搜解决全排列问题 bfs和dfs的区别 bfs更适合解决带有“最少”，“最短”字样的题 dfs更适合解决带有“刚刚”，“刚好”字样的题 在练习迷宫问题之前，先介绍一下奇偶性剪枝： 若地图上某点的行号加列号为奇数，则将其定义为奇点； 若地图上某点的行号加列号为偶数，则将其定义为偶点； 行与列从(0，0)开始 奇点用1表示 偶点用0表示 通过以上定义可以把一个地图表示为下图（01相间）： 不难发现： 在每一步消耗一个单位时间的情况下： 0的下一步只能走向1 1的下一步只能走向0 从0走
小米 oj 马走日 （bfs 或 双向bfs）
weixin_30815427的博客
11-14 215
马走日 序号：#56难度：困难时间限制：1500ms内存限制：10M 描述 在中国象棋中，马只能走日字型。现在给出一个由 N*M 个格子组成的中国象棋棋盘( 有(N+1)*(M+1)个交叉点可以落子 )，以及棋盘上的两个坐标点 S,T。请计算出从 S 到 T 使用日字型走法所需的最少步数，如果不能到达，则输出-1。 下图为一个1x2的棋盘，起始落子点...
mooc-清华数据结构与算法(邓俊辉) OJ习题.zip
01-01
深度优先搜索（DFS）和广度优先搜索（BFS）是图算法的基础，邓教授会详细讲解它们的实现和应用。 5. **排序与查找**：快速排序、归并排序、堆排序等排序算法以及二分查找、哈希查找等查找算法，是提高程序效率的...
ACM-OJ分类
09-05
2. **搜索算法**：深度优先搜索（DFS）、广度优先搜索（BFS）、回溯法、二分查找等。 3. **数据结构**：数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、图（邻接矩阵、邻接表）、哈希表等。 4. **动态...
newcoder-oj：牛客题霸-算法篇-程序员面试高频题（c ++）
03-04
1. **基础算法**：包括排序算法（如冒泡排序、快速排序、归并排序、堆排序）、搜索算法（如线性搜索、二分搜索）、图论基础（如深度优先搜索DFS、广度优先搜索BFS）等。这些是编程面试中的基础题目，也是衡量一个...
LintCode:在线OJ网站LintCode题目C++实现
05-15
图的表示（邻接矩阵、邻接表）、深度优先搜索（DFS）、广度优先搜索（BFS）以及最短路径算法（Dijkstra、Floyd-Warshall）也是LintCode上的热点问题。 ### 8. 字符串处理 C++的`std::string`类提供了丰富的字符串...
oj软件课设（C语言版本代码）
最新发布
01-18
在C语言中，可以使用队列、栈等数据结构来模拟游戏状态，通过深度优先搜索（DFS）或广度优先搜索（BFS）来检测是否存在死锁。 4. **大数相加**：在C语言中，标准库并不直接支持大整数操作。处理大数相加可能需要...
迷宫bfs应用（华为OJ题目）
夏洛克福尔摩斯
07-24 299
'S'是开始位置，'#'表示墙，'.'是通路，'E'是终点，求最短路径长度 #include <iostream> #include<vector> #include<string> #include<utility> #include<queue> using namespace std; int offset[4][2]={...
ZOJ 2081 Mission Impossible(BFS+DFS)
蚂蚁大战大象
04-14 600
首先BFS找最短距离 然后DFS搜索每一条最短路径,统计成功和失败的路径数目 #include #include #include #include #include using namespace std; const int maxn=15; char maze[maxn][maxn]; int di[]={-1,1,0,0},dj[]={0,0,-1,1},n,m,minDis
利用剪枝降低bfs算法的时空复杂度（一道OJ题目）
你的问题在于，读书太少而想得太多。
02-02 5684
终于学会了如何通过剪枝降低bfs算法的时空复杂度（附示例OJ题目及源码）
【BFS】哈理工OJ-2074-逃生
lhc-----
01-21 616
逃生 Description 小A沦落到了一个迷宫之中，这个迷宫由n*m个格子构成，有些格子是不能通过的，现在他要从迷宫入口(1,1)的格子走到迷宫出口(n,m)的格子。 因为小A的方向感很弱，转多了会晕，所以他走到目的地的时候，最多能转z次，否则他就永远晕倒在原地了，到了出口也没法出去了。 请你告诉他最少能经过多少个格子走出迷宫。小Y从(1,1)出发到达的
贪心算法与DFS：九度OJ1030
lxseu的专栏
07-22 977
题目1030：毕业bg 题目描述：     每年毕业的季节都会有大量毕业生发起狂欢，好朋友们相约吃散伙饭，网络上称为“bg”。参加不同团体的bg会有不同的感觉，我们可以用一个非负整数为每个bg定义一个“快乐度”。现给定一个bg列表，上面列出每个bg的快乐度、持续长度、bg发起人的离校时间，请你安排一系列bg的时间使得自己可以获得最大的快乐度。     例如有4场bg：    
BFS+DFS
MeisterMorxrc的学习小屋
08-13 1131
1.什么是搜索： 2.在acm和平时的题目中，并不会出现遍历一棵树这样的题目，因此，如何将其状态转化成树的节点，就尤其地重要。 3DFS 顾名思义：就是优先向搜索树深层进行搜索的算法。 深度优先遍历图的方法是，从图中某顶点v出发： （1）访问顶点v； （2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问； （3）若此时图中尚有顶点未被访...
广度优先搜索（BFS）----------------（TjuOj1140_Dungeon Master）
weixin_30512785的博客
11-24 137
这次整理了一下广度优先搜索的框架，以后可以拿来直接用了。TjuOj1140是一个三维的迷宫题，在BFS时我增加了一个控制数组，用来对队列的出队进行控制，确保每次出队的结点均为同一步长的结点，个人认为比较适合这种迷宫搜索题。 BFS部分的代码如下： int BFS ( node S , node T ) { int s = 1; //充当指针作用 memset(n,0,...
哈理工OJ 1490 咒语（BFS广度优先搜索）
linlinsong—ACM界蒟水！
08-16 474
咒语 Time Limit: 1000 MS Memory Limit: 65535 K Total Submit: 162(37 users) Total Accepted: 53(35 users) Rating: Special Judge: No Description 小w同学为了学好自己喜欢的ACM，一直fighting着……一天小w同学在做题的过程中睡着
ACM--dfs与bfs
一棵小红树
06-16 305
1.dfs求最大连通块（UVa 871 - Counting Cells in a Blob） Consider a two-dimensional grid of cells, each of which may be empty or filled. Filled cells form blobs. The filled cells that are connected form the sa...
经典算法深度解析：A*、Dijkstra与DFS/BFS性能对比与实践
该系列共包含22篇文章，涉及13个核心算法，包括但不限于A*搜索算法、Dijkstra算法、BFS(广度优先搜索)算法、动态规划、以及深度优先搜索(DFS)算法。作者不仅对这些算法的理论原理进行了详尽研究，还提供了丰富的编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值