蓝桥杯 第五十七天 BFS之Flood Fill

最新推荐文章于 2024-10-04 10:53:43 发布
最新推荐文章于 2024-10-04 10:53:43 发布
阅读量185 收藏
点赞数
文章标签： 蓝桥杯 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aixiaoxiao13/article/details/123880206
版权
本文详细介绍了多种算法问题的解决方案，包括使用广度优先搜索（BFS）解决走迷宫、八数码问题、池塘计数以及城堡问题。每个问题都通过Python实现，涉及二维数组操作、路径查找和连通块计数。此外，还讨论了山峰和山谷的判断以及特定路径寻找问题。这些算法在信息技术领域有着广泛应用。
摘要由CSDN通过智能技术生成

目录

走迷宫

def isvalid(x,y):
    if x<0 or x>=n:
        return False
    if y<0 or y>=m:
        return False
    if adj[x][y]==1:
        return False
    return True
def bfs():
    from collections import deque
    q=deque([])
    start=[0,0]
    q.append(start)
    end=[n-1,m-1]
    vis=[[False for i in range(m)]for j in range(n)]
    vis[0][0]=True
    dx=[-1,0,+1,0]
    dy=[0,+1,0,-1]
    ans=0
    while q:
        size=len(q)
        for i in range(size):
            top=q.popleft()
            if top==end:
                return ans
            for j in range(4):
                nx=top[0]+dx[j]
                ny=top[1]+dy[j]
                if isvalid(nx,ny) and not vis[nx][ny]:
                    q.append([nx,ny])
        ans+=1
    return -1

n,m=map(int,input().split())
adj=[]
for i in range(n):
    adj.append(list(map(int,input().split())))
print(bfs())

八数码

既然三维不好表示，就直接压缩成一维
这一题和上交2020年的题，倒水问题有异曲同工之妙

def isvalid(x,y):
    if x<0 or x>=3:
        return False
    if y<0 or y>=3:
        return False
    return True
def bfs():
    global a
    end="12345678x"
    a="".join(a)
    from collections import deque
    q=deque([])
    q.append(a)
    d=dict()
    d[a]=0
    ans=0
    dx=[1,-1,0,0]
    dy=[0,0,1,-1]
    while q:
        size=len(q)
        for i in range(size):
            top=q.popleft()
            if top==end:
                return ans
            index=top.index('x')
            curlen=d[top]
            x=index//3
            y=index%3
            for j in range(4):
                nx=x+dx[j]
                ny=y+dy[j]
                if isvalid(nx,ny):
                    newindex=nx*3+ny
                    top=list(top)
                    top[newindex],top[index]=top[index],top[newindex]
                    top="".join(top)
                    if top not in d:
                        d[top]=curlen+1
                        q.append(top)
                    top=list(top)
                    top[newindex], top[index] = top[index], top[newindex]
                    top="".join(top)
        ans+=1
a=input().split()
print(bfs())

池塘计数

相当于统计连通块的数目，每次bfs都会把连接在一起的池塘’W’访问

from collections import deque
def isvalid(x,y):
    if x<0 or x>=n:
        return False
    if y<0 or y>=m:
        return False
    if adj[x][y]!='W':
        return False
    return True
dx=[-1,-1,-1,0,1,1,1,0]
dy=[-1,0,1,1,1,0,-1,-1]
def bfs(x,y):
    q=deque([])
    q.append((x,y))
    vis[x][y]=True
    while q:
        size=len(q)
        for i in range(size):
            top=q.popleft()
            for j in range(8):
                nx=top[0]+dx[j]
                ny=top[1]+dy[j]
                if isvalid(nx,ny) and not vis[nx][ny]:
                    q.append((nx,ny))
                    vis[nx][ny]=True
    return
n,m=map(int,input().split())
adj=[]
for i in range(n):
    adj.append(list(input()))
ans=0
vis=[[False for i in range(m)]for j in range(n)]
for i in range(n):
    for j in range(m):
        if adj[i][j]=='W' and not vis[i][j]:
            bfs(i,j)
            ans+=1
print(ans)

城堡问题

就是一个flood fill算法，但是出题人说的很复杂，很吓人，吓到我了

from collections import deque
def isvalid(x,y):
    if x<0 or x>=n:
        return False
    if y<0 or y>=m:
        return False
    return True
def bfs(x,y):
    dx=[0,-1,0,+1]
    dy=[-1,0,+1,0]
    q=deque([])
    q.append((x,y))
    vis[x][y]=True
    area=0
    while q:
        top=q.popleft()
        area+=1
        cur=adj[top[0]][top[1]]
        for k in range(4):
            if cur>>k&1==0:
                nx=top[0]+dx[k]
                ny=top[1]+dy[k]
                if not vis[nx][ny] and isvalid(nx,ny):
                    q.append((nx,ny))
                    vis[nx][ny]=True
    return area
def isroom(x):
    flag=False
    for i in range(4):
        if x>>i&1==0:
            flag=True
            break
    if flag:
        return True
    else:
        return False
n,m=map(int,input().split())
adj=[]
for i in range(n):
    adj.append(list(map(int,input().split())))
vis=[[False for i in range(m)]for j in range(n)]
ans=0
num=0
for i in range(n):
    for j in range(m):
        if not vis[i][j]:
            ans=max(ans,bfs(i,j))
            num+=1
print(num)
print(ans)

山峰和山谷

有点复杂，但是难度不大

from collections import deque
dx=[0,-1,-1,-1,0,1,1,1]
dy=[-1,-1,0,1,1,1,0,-1]
def isvalid(x,y):
    if x<0 or x>=n:
        return False
    if y<0 or y>=n:
        return False
    return True
def bfs(x,y):
    q=deque([])
    q.append((x,y))
    vis[x][y]=True
    flag=True
    while q:
        top=q.popleft()
        x,y=top
        for j in range(8):
            nx=x+dx[j]
            ny=y+dy[j]
            if isvalid(nx,ny):
            # if isvalid(nx,ny) and not vis[nx][ny]:
                if adj[nx][ny]>adj[x][y]:
                    flag=False
                    continue
                elif adj[nx][ny]==adj[x][y]  and not vis[nx][ny]:
                    q.append((nx,ny))
                    vis[nx][ny]=True
    if flag:
        return True
    else:
        return False
def bfs2(x,y):
    q=deque([])
    q.append((x,y))
    vis[x][y]=True
    flag=True
    while q:
        top=q.popleft()
        x,y=top
        for j in range(8):
            nx=x+dx[j]
            ny=y+dy[j]
            if isvalid(nx,ny):
                if adj[nx][ny]<adj[x][y]:
                    flag=False
                    continue
                elif adj[nx][ny]==adj[x][y]  and not vis[nx][ny]:
                    q.append((nx,ny))
                    vis[nx][ny]=True
    if flag:
        return True
    else:
        return False

n=int(input())
adj=[]
for i in range(n):
    adj.append(list(map(int,input().split())))
vis=[[False for i in range(n)]for j in range(n)]
ans1=0
for i in range(n):
    for j in range(n):
        if not vis[i][j]:
            if bfs(i,j):
                ans1+=1
vis=[[False for i in range(n)]for j in range(n)]
ans2=0
for i in range(n):
    for j in range(n):
        if not vis[i][j]:
            if bfs2(i,j):
                ans2+=1
print(ans1,ans2)

迷宫问题

def isvalid(x,y):
    if x<0 or x>=n:
        return False
    if y<0 or y>=n:
        return False
    if adj[x][y]==1:
        return False
    return True
def bfs():
    dx=[0,-1,0,1]
    dy=[-1,0,1,0]
    from collections import  deque
    q=deque([])
    q.append((0,0))
    end=(n-1,n-1)
    vis[0][0]=0
    ans=0
    while q:
        size=len(q)
        for i in range(size):
            top=q.popleft()
            if top==end:
                dfs(end)
                return
            for j in range(4):
                nx=top[0]+dx[j]
                ny=top[1]+dy[j]
                if isvalid(nx,ny) and vis[nx][ny]==-1:
                    q.append((nx,ny))
                    vis[nx][ny]=top
    return
def dfs(cur):
    if cur!=(0,0):
        dfs(vis[cur[0]][cur[1]])
    print(cur)
    return
n=int(input())
adj=[]
for i in range(n):
    adj.append(list(map(int,input().split())))
vis=[[-1 for i in range(n)]for j in range(n)]
bfs()

武士风度的牛

输入时先列再行，以后要注意点

def isvalid(x,y):
    if x<0 or x>=n:
        return False
    if y<0 or y>=m:
        return False
    if adj[x][y]=='*':
        return False
    return True
dx=[-1,-2,-2,-1,1,2,2,+1]
dy=[2,1,-1,-2,-2,-1,1,2]
from collections import deque
def bfs():
    q=deque([])
    q.append(start)
    vis=[[False for i in range(m)]for j in range(n)]
    vis[start[0]][start[1]]=True
    ans=0
    while q:
        size=len(q)
        for i in range(size):
            top=q.popleft()
            if top==end:
                print(ans)
                return
            for j in range(8):
                nx=top[0]+dx[j]
                ny=top[1]+dy[j]
                if isvalid(nx,ny) and not vis[nx][ny]:
                    q.append([nx,ny])
                    vis[nx][ny]=True
        ans+=1
    return
n,m=map(int,input().split())
n,m=m,n
start=[-1,-1]
end=[-1,-1]
adj=[]
for i in range(n):
    adj.append(input())
    if 'K' in adj[i]:
        start=[i,adj[i].index('K')]
    if 'H' in adj[i]:
        end=[i,adj[i].index('H')]
bfs()

抓住那头牛


from collections import deque
def change(x,y):
    if y==0:
        return x-1
    if y==1:
        return x+1
    if y==2:
        return 2*x
def bfs():
    q=deque([])
    dist=[1<<31 for i in range(300)]
    q.append(n)
    dist[n]=0
    while q:
        top=q.popleft()
        if top==k:
            print(dist[top])
            return
        nextlength=dist[top]+1
        for j in range(3):
            ne=change(top,j)
            if ne>=0:
                if nextlength<dist[ne]:
                    dist[ne]=nextlength
                    if ne not in q:
                        q.append(ne)
    return

n,k=map(int,input().split())
bfs()
是小肖啊！
关注
【经典算法】BFS之Flood Fill
Miiiiiiiiiii的博客
11-09 1180
简述 Flood Fill：字面理解，洪水填充，(大概意思是传播的很快，扩散的广，像水一样四处流动一样)。其实我感觉不就是个BFS嘛，感觉BFS起了个别的名字 大致思想：中间一个点，向四周扩展，每次扩散一圈，下次再一圈…如此下去 我们再想想我们数据结构学的BFS(广度优先遍历)，这不是一回事嘛… 再扩展到题，给人的感觉就是需要加判断，不是说每个点四周的所有点都可以Flood Fill 池塘计数POJ2386 来源： poj2386 题意： 大致的意思是n*m的单元格，"."表示土地，"W"表示水，对于
【蓝桥杯训练】DFS与BFS讲解
一个真ikun
03-14 1521
DFS属于图算法的一种，是针对图和树的遍历算法。深度优先搜索是图论中的经典算法，利用深度优先搜索算法可以产生目标图的相应拓扑排序表，利用拓扑排序表可以方便的解决很多相关的图论问题，如最大路径问题等等。一般用堆或栈来辅助实现DFS算法。其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，如果遇到死路就往回退，回退过程中如果遇到没探索过的支路，就进入该支路继续深入，每个节点只能访问一次。
BFS 之Flood Fill 算法
m0_64226820的博客
08-07 826
图文并茂讲解 的BFS算法 ，无需任何前置知识，即学即会，小白都学会了，你确定不来看看？c++,,java ,python应有尽有
flood fill里的bfs、dfs
boosirit的博客
01-13 280
如果应用广度优先算法或深度优先算法解决算法题里洪水灌溉类的题目。
蓝桥杯国赛每日一题：全球变暖（BFS，Flood Fill）
weixin_73612682的博客
05-14 461
其中”上下左右”四个方向上连在一起的一片陆地组成一座岛屿，例如上图就有 2 座岛屿。由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
Flood Fill算法总结
一个重视算法和系统设计的实战派
12-30 519
【代码总结】Flood Fill算法总结
蓝桥杯——迷宫(BFS)
qq_33880925的博客
03-16 766
【代码】蓝桥杯——迷宫(BFS)
Flood Fill
佛系更新
05-21 830
文章目录前言一、Flood Fill二、例题，代码AcWing 1097. 池塘计数本题分析AC代码AcWing 1098. 城堡问题本题分析AC代码AcWing 1106. 山峰和山谷本题分析AC代码三、时间复杂度 前言 复习acwing算法提高课的内容，本篇为讲解算法：Flood Fill，关于时间复杂度：目前博主不太会计算，先鸽了，日后一定补上。 一、Flood Fill Flood Fill算法是搜索的算法中的一种，用来解决类似田地覆盖这么一系列问题，算法核心是BFS 二、例题，代码 AcW.
acwing——bfs中的Flood Fill
Stephen_Zhao0的博客
06-25 219
Flood Fill 算法思路：顾名思义，洪水覆盖算法，任选一个合法的格子，从这个格子开始向其他合法的格子覆盖。 可以在线性时间复杂度内，可以找到，所有连通块。 AcWing 1097. 池塘计数 #include <iostream> #include <algorithm> #include <cstring> #include <queue> using namespace std; typedef pair<int , int> PI
DFS/BFS(Flood Fill)-第九届蓝桥杯省赛C++A/B组-全球变暖
njuptACMcxk的博客
02-28 288
DFS/BFS(Flood Fill)-第九届蓝桥杯省赛C++A/B组-全球变暖 题目： 你有一张某海域 N×N 像素的照片，”.”表示海洋、”#”表示陆地，如下所示： 其中”上下左右”四个方向上连在一起的一片陆地组成一座岛屿，例如上图就有 2 座岛屿。 由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。 具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像...
Java实现 蓝桥杯 算法提高 八数码（BFS）
12-21
BFS是一种用于遍历或搜索树或图的算法，它会按层序依次访问节点，即先访问根节点，然后访问所有第一层节点，接着访问所有第二层节点，以此类推。在八数码问题中，每个状态（即3x3矩阵）被视为一个节点，相邻的状态...
Flood Fill—DFS和BFS算法的实例讲解（C）（岛屿数量I）
Monkey&Penguin的博客
03-04 650
一、前言： 初学编程的小白学习完基础算法总之不知道有什么用。所以本篇从一个有趣的leetcode题目讲解Flood fill算法，即所熟知的DFS广度优先和BFS深度优先算法。 二、题目： 三、简介： 维基百科：Flood fill 算法是从一个区域中提取若干个连通的点与其他相邻区域区分开（或分别染成不同颜色）的经典 算法。因为其思路类似洪水从一个区域扩散到所有能到达的区域而得名。在 ...
some 蓝桥杯题
2301_80160438的博客
10-02 1259
【代码】some 蓝桥杯题。
蓝桥杯:求平均年龄
aqua3535742358的博客
09-29 248
printf("平均年龄：%.2f", sum/num);printf("请输入总人数: ");
蓝桥杯—STM32G431RBT6(IIC通信--EEPROM(AT24C02)存储器进行通信)
JK03820的博客
10-02 889
IIC （IIC 是半双工通信总线。半双工意味着数据在某一时刻只能沿一个方向传输，即发送数据的时候不能接收数据，接收数据的时候不能发送数据）即集成电路总线（Inter-Integrated Circuit），是一种多主机的串行通信总线.它由飞利浦公司在 20 世纪 80 年代开发，主要用于连接微控制器及其外围设备。IIC 总线具有简单、高效、支持多设备连接等特点，在电子电路设计中被广泛应用。“一主多从” 是一种通信架构模式。在这种模式中，有一个主要的设备（称为主设备），它具有控制和发起通信的能力；
24.2.29蓝桥杯|单位换算--8道题
weixin_47011416的博客
09-29 575
本篇或者本系列文章使用蓝桥云课平台，借助CSDN梳理思路，给自己做一个电子笔记。
蓝桥杯-财务管理
aqua3535742358的博客
09-29 237
printf("平均月结余：$%.2f", nian/12);printf("请输入每月结余:\n ");
《蓝桥杯算法入门》（C/C++、Java、Python三个版本）24年10月出版
罗勇军的博客
10-01 3589
蓝桥杯大赛软件类入门书，有三种语言的版本：C/C++、Java、Python。
第18场小白入门赛(蓝桥杯)
最新发布
2301_78527293的博客
10-04 766
入门赛
flood fill
10-20
Flood Fill算法是一种对连通区域进行着色的算法，它从一个起点开始，将相邻的区域都标记上同样的颜色。它通常被用来填充或者着色图像中的封闭区域，比如说在绘图软件中使用它来填充闭合的多边形区域。Flood Fill算法包括四个基本步骤：选择一个起点，标记起点颜色，将与起点相邻且颜色相同的区域标记上同样的颜色，重复第三步直到没有相邻的区域可以被标记。 本文提到的Flood Fill算法实现有两个版本，一个是使用BFS（广度优先搜索）实现，另一个是使用DFS（深度优先搜索）实现。在实际应用中，可以根据具体情况选择合适的算法实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值