BFS中的Flood Fill和最短路模型

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量358 收藏 9
点赞数 5
分类专栏： 日志 文章标签： 宽度优先 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73165551/article/details/136274860
版权

BFS：1、“求最小” 用bfs第一次搜到的值就是最小值

           2、基迭代，不会爆栈 

 845. 八数码 - AcWing题库

import java.util.*;

public class Main{
    public static void swap(char[] arr, int a, int b){
        char temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    
    public static int bfs(String start, String end){
        Map<String, Integer> map = new HashMap<>();//用来存储到达每种状态要走的距离
        Queue<String> q = new LinkedList<>();
        
        q.offer(start);
        map.put(start, 0);
        
        int[] dx = {-1,0,1,0}, dy = {0,1,0,-1};//上下左右四个方向
        
        while(!q.isEmpty()){
            String t = q.poll();//取出队头元素
            
            int k = t.indexOf('x');//找到元素x在这个字符串里的位置
            int x = k / 3;//找到等同在二维数组里面的坐标
            int y = k % 3;
            
            if(t.equals(end)) return map.get(t);//如果这时候已经相同了，就提前结束
            
            for(int i = 0; i < 4; i ++){//进行上下左右四种方案
                int a = x + dx[i], b = y + dy[i];//之前那种位移量的方法
                if(a < 3 && a >= 0 && b < 3 && b >= 0){//如果没有超出边界
                    char[] arr = t.toCharArray();
                    swap(arr, k, a * 3 + b);//交换位置，二维转化成一维
                    //将交换位置后的字符数组变成新的字符串
                    String str = new String(arr);
                    
                    if(map.get(str) == null){//说明这种状态还没有走到过
                        map.put(str, map.get(t) + 1);//交换数加1
                        q.offer(str);//加入队列
                    }
                }
            }
        }
        return -1;
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String start = "";
        for(int i = 1; i <= 9; i ++){
            String s = sc.next();
            start += s;
        }
        String end = "12345678x";
        System.out.print(bfs(start, end));
    }
}

Flood Fill算法：

        可以在线性的时间复杂度内，找到某个点所在的连通块。

1097. 池塘计数 - AcWing题库 

import java.util.*;
import java.io.*;

class PII{
    int x, y;
    public PII(int x, int y){//一个点的横纵坐标
        this.x = x;
        this.y = y;
    }
}

public class Main{
    static int N = 1010, M = N * N;
    static int n, m;
    static PII[] q = new PII[M];
    static char[][] g = new char[N][N];
    static boolean[][] st = new boolean[N][N];
    
    public static void bfs(int x, int y){
        int hh = 0, tt = -1;
        q[++ tt] = new PII(x, y);//把这个点加入队列
        while(hh <= tt){
            PII t = q[hh ++];//取出队头
            int a = t.x;//横坐标
            int b = t.y;//纵坐标
            for(int i = a - 1; i <= a + 1; i ++){
                for(int j = b - 1; j <= b + 1; j ++){
                    if(i == a && j == b) continue;
                    if(i < 0 || j < 0 || i >= n || j >= m) continue;//如果就是这个点
                    if(g[i][j] == '.' || st[i][j]) continue;//如果不是水或者是已经遍历过了
                    q[++ tt] = new PII(i, j);//把这个点加入队列
                    st[i][j] = true;//标记位遍历过
                }
            }
        }
    }
    
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] s = br.readLine().split(" ");
        n = Integer.parseInt(s[0]);
        m = Integer.parseInt(s[1]);
        
        for(int i = 0; i < n; i ++){
            String str = br.readLine();
            char[] arr = str.toCharArray();
            for(int j = 0; j < m; j ++){
                g[i][j] = arr[j];
            }
        }
        
        int cnt = 0;//记录遍历了多少个连通块
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < m; j ++){
                if(g[i][j] == 'W' && !st[i][j]){//如果是水，而且没有遍历过
                    bfs(i, j);
                    cnt ++;
                }
            }
        }
        System.out.print(cnt);
    }
}

 

1098. 城堡问题 - AcWing题库

import java.util.*;

class PII{
    int x, y;
    public PII(int x, int y){
        this.x = x;
        this.y = y;
    }
}

public class Main{
    static int N = 60, M = N * N;
    static int n, m;
    static int[][] g = new int[N][N];
    static PII[] q = new PII[M];
    static boolean[][] st = new boolean[N][N];
    
    public static int bfs(int x, int y){
        int hh = 0, tt = -1;//队头和队尾
        int[] dx = {0, -1, 0, 1}, dy = {-1, 0, 1, 0};//西北东南四个方向
        q[++ tt] = new PII(x, y);//加入队列
        st[x][y] = true;//标记为已经遍历过
        int res = 0;//面积
        while(hh <= tt){
            PII t = q[hh ++];//取出元素
            res ++;//取出一个就加上一个
            for(int i = 0; i < 4; i ++){
                int a = t.x + dx[i];//四个方向
                int b = t.y + dy[i];
                if(a < 0 || b < 0 || a >= n || b >= m) continue;//越界
                if(st[a][b]) continue;//如果已经遍历过
                if((g[t.x][t.y] >> i & 1) == 1) continue;//用二进制来表示墙
                q[++ tt] = new PII(a, b);//加入队列
                st[a][b] = true;//标记为已经遍历过
            }
        }
        return res;
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j ++){
                g[i][j] = sc.nextInt();
            }
        }
        
        int cnt = 0;//连通块的数量
        int area = 0;//面积
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < m; j ++){
                if(!st[i][j]){
                    area = Math.max(area, bfs(i, j));
                    cnt ++;
                }
            }
        }
        
        System.out.println(cnt);
        System.out.println(area);
    }
}

 

1106. 山峰和山谷 - AcWing题库

import java.util.*;

class PII{
    int x, y;
    public PII(int x, int y){
        this.x = x;
        this.y = y;
    }
}

public class Main{
    static int N = 1010, M = N * N;
    static int n;
    static int[][] g = new int[N][N];
    static boolean[][] st = new boolean[N][N];
    static PII[] q = new PII[M];
    static boolean has_higher, has_lower;
    
    public static void bfs(int x, int y){
        int hh = 0, tt = -1;
        q[++ tt] = new PII(x, y);
        st[x][y] = true;//标记为走过
        
        while(hh <= tt){
            PII t = q[hh ++];
            for(int i = t.x - 1; i <= t.x + 1; i ++){
                for(int j = t.y - 1; j <= t.y + 1; j ++){
                    if(t.x == i && t.y == j) continue;
                    if(i < 0 || j < 0 || i >= n || j >= n) continue;
                    
                    if(g[i][j] != g[t.x][t.y]){//如果高度不相等
                        if(g[i][j] > g[t.x][t.y]) has_higher = true;
                        else has_lower = true;
                    }else if(!st[i][j]){//如果高度相等
                        st[i][j] = true;//标记为走过
                        q[++ tt] = new PII(i, j);//存入队列
                    }
                }
            }
        }
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < n; j ++){
                g[i][j] = sc.nextInt();
            }
        }
        
        int peak = 0;
        int vally = 0;
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < n; j ++){
                if(!st[i][j]){//如果没走过
                    has_higher = false;
                    has_lower = false;
                    bfs(i, j);
                    if(!has_lower) vally ++;//只要没有比他矮的，那么他就是山谷
                    if(!has_higher) peak ++;//只要没有比他高的，那么就是山峰
                }
            }
        }
        System.out.print(peak + " " + vally);
    }
}

最短路问题

844. 走迷宫 - AcWing题库 是迷宫问题的简单版（迷宫问题要存路径）

1076. 迷宫问题 - AcWing题库

import java.util.*;
import java.io.*;

class PII{
    int x, y;
    public PII(int x, int y){
        this.x = x;
        this.y = y;
    }
}



public class Main{
    static int N = 1010, M = N * N, n;
    static int[][] g = new int[N][N];
    static PII[] q = new PII[M];
    static PII[][] pre = new PII[N][N];
    
    public static void bfs(int x, int y){
        int hh = 0, tt = -1;
        int[] dx = {-1, 0, 1, 0}, dy = {0, 1, 0, -1};//四个方向
    
        q[++ tt] = new PII(x, y);
        pre[x][y] = new PII(0, 0);//终点是由哪个点遍历来的
    
        while(hh <= tt){
            PII t = q[hh ++];
            for(int i = 0; i < 4; i ++){
                int a = t.x + dx[i];
                int b = t.y + dy[i];
                if(a >= n || b >= n || a < 0 || b < 0) continue;//边界
                if(g[a][b] == 1) continue;//墙
                if(pre[a][b].x != -1) continue;//如果前一个点的横坐标不为-1，那么说明遍历过
            
                q[++ tt] = new PII(a, b);//加入队列
                pre[a][b] = t;//这个点是由上一点过来的标记一下
            }
        }
    }
    
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(br.readLine());
        for(int i = 0; i < n; i ++){
            String[] str = br.readLine().split(" ");
            for(int j = 0; j < n; j ++){
                g[i][j] = Integer.parseInt(str[j]);
                pre[i][j] = new PII(-1, -1);//标记为没遍历过
            }
        }
        
        bfs(n - 1, n - 1);//倒着来遍历
        PII end = new PII(0, 0);//输出路径
        while(true){
            System.out.println(end.x + " " + end.y);
            if(end.x == n - 1 && end.y == n - 1) break;
            end = pre[end.x][end.y];
        }
    }
}

 

188. 武士风度的牛 - AcWing题库

import java.util.*;
import java.io.*;

class PII{
    int x, y;
    public PII(int x, int y){
        this.x = x;
        this.y = y;
    }
}

public class Main{
    static int N = 200, M = N * N;
    static int n, m;
    static char[][] g = new char[N][N];
    static PII[] q = new PII[M];
    static int[][] dist = new int[N][N];
    
    public static int bfs(int a, int b){
        int hh = 0, tt = -1;
        int[] dx = {-2, -2, -1, 1, 2, 2, 1, -1};//八个方向
        int[] dy = {-1, 1, 2, 2, 1, -1, -2, -2};
        
        q[++ tt] = new PII(a, b);//加入队列
        dist[a][b] = 0;
        
        while(hh <= tt){
            PII t = q[hh ++];
            for(int i = 0; i < 8; i ++){
                int x = t.x + dx[i];
                int y = t.y + dy[i];
                if(x >= n || y >= m || x < 0 || y < 0) continue;//边界
                if(dist[x][y] != -1) continue;//如果走过了
                if(g[x][y] == '*') continue;//障碍
                if(g[x][y] == 'H') return dist[t.x][t.y] + 1;//到达目标
                
                dist[x][y] = dist[t.x][t.y] + 1;//步数加1
                q[++ tt] = new PII(x, y);//加入队列
            }
        }
        return -1;
    }
    
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] s = br.readLine().split(" ");
        m = Integer.parseInt(s[0]);
        n = Integer.parseInt(s[1]);
        
        for(int i = 0; i < n; i ++){
            String str = br.readLine();
            char[] arr = str.toCharArray();
            for(int j = 0; j < m; j ++){
                g[i][j] = arr[j];
                dist[i][j] = -1;//标记为没有走过
            }
        }
        
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < m; j ++){
                if(g[i][j] == 'K'){
                    System.out.print(bfs(i, j));
                }
            }
        }
    }
}

 

1100. 抓住那头牛 - AcWing题库

import java.util.*;

public class Main{
    static int N = 200010, n, k;
    static int[] dist = new int[N];
    static int[] q = new int[N];
    
    public static int bfs(){
        
        int hh = 0, tt = -1;
        q[++ tt] = n;
        dist[n] = 0;
        Arrays.fill(dist, -1);//初始化表示没来过
        
        while(hh <= tt){
            int t = q[hh ++];
            if(t == k) return dist[k] + 1;//到达终点，结果加1
            
            if(t - 1 >= 0 && dist[t - 1] == -1){
                dist[t - 1] = dist[t] + 1;
                q[++ tt] = t - 1;
            }
            
            if(t + 1 < N && dist[t + 1] == -1){
                dist[t + 1] = dist[t] + 1;
                q[++ tt] = t + 1;
            }
            
            if(2 * t < N && dist[2 * t] == -1){
                dist[2 * t] = dist[t] + 1;
                q[++ tt] = 2 * t;
            }
        }
        return -1;
    }
    
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        k = sc.nextInt();
        System.out.print(bfs());
    }
}

 

m0_73165551
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
10 bfs（flood fill与最短路模型）
m0_63729880的博客
06-17 216
图论bfs
2.1.1BFS中的Flood Fill和最短路模型
一名混沌的大学生
10-21 141
你的任务是，对于给定的地图，求出山峰和山谷的数量，如果所有格子都有相同的高度，那么整个地图即是山峰，又是山谷。在遍历单元格过程中，如果当前单元格是水，并且没有被访问过，水域数量+1，并且对该单元格进行bfs。表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。个字符，字符为”W”或”.”，用以表示矩形土地的积水状况，字符之间没有空格。每个单元格内，如果包含雨水，则用”W”表示，如果不含雨水，则用”.”表示。按顺序，每行输出一个路径中经过的单元格的坐标，左上角坐标为。
acwing算法提高之搜索--BFS中的Flood Fill和最短路模型
YMWM_的博客
02-24 223
acwing算法提高之搜索--BFS中的Flood Fill和最短路模型
BFS Flood Fill and 最短路模型
小菜鸡的博客
08-24 154
acwing笔记
Flood Fill和最短路模型
释然的成长之路
08-21 123
Flood Fill 池塘问题 DFS写法 #include <iostream> #include <cstring> #include <algorithm> using namespace std; const int N = 1010; char g[N][N]; int n, m; void dfs(int x, int y) { g[x][y] = '.'; int dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0}
[Acwing提高]搜索（BFS的Flood Fill和最短路模型)
鱼竿钓鱼干
02-28 278
[Acwing提高]搜索 BFS的Flood Fill和最短路模型 知识点 题目 扩展方式 类型 池塘计数 明确的二维地图 Flood Fill 城堡问题 地图转换，统计连通块数量 Flood Fill 山峰和山谷 搜索试探过程中记录一些东西,统计连通块内外分界处的关系 Flood Fill 迷宫问题 记录BFS最短路 BFS最短路 题目 池塘计数 思路 裸的Flood Fill 代码 #include<bits/stdc++.h>
AcWing.算法提高课_BFS中的Flood Fill和最短路模型
wazsja的博客
08-02 338
Flood Fill 模型与最短路模型
算法提高之搜索：BFS中的Flood Fill和最短路模型
qq_37448336的博客
02-10 572
目录0、基础课中的bfs1、Flood Fill1.1、池塘计数(统计连通块的数量)1.2、城堡问题（统计连通块的数量和最大值）1.3、山峰和山谷（判断连通块的类型）2、最短路模型2.1、迷宫问题（记录路径）2.2、武士风度的牛（日字形走法）2.3、抓住那头牛 0、基础课中的bfs 1、Flood Fill 1M/开一层所消耗的内存 就可以得到总共开多少层。 1.1、池塘计数(统计连通块的数量) #include <cstring> #include <iostrea
BFS——Flood Fill模型及最短路模型
qq_57150526的博客
12-18 723
BFS的Flood Fill与单源最短路模型的讲解
带你学习Flood Fill算法与最短路模型
「 虚幻私塾」
01-21 1164
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 一、Flood Fill（连通块问题） 0.简介 Flood Fill（洪水覆盖） 可以在线性的时间复杂内，找到某个点所在的连通块！ 注：基于宽搜的思想，深搜也可以做但可能会爆栈 flood fill算法DFS与BFS： ​ DFS：无法求解最短路问题；可能会爆栈（递
[AcWing算法提高课]之搜索（Flood_Fill+最短路模型+多源BFS+最小步数模型）（C++题解）
lihua777的博客
04-14 1233
[AcWing算法提高课]之搜索（Flood_Fill+最短路模型+多源BFS+最小步数模型）（C++题解）
Flood Fill（漫水法）+ 最短路模型
ker的博客
07-06 1130
文章目录 对于一张地图，使用Flood Fill就可以找到最大连通子图，可以使用BFS、DFS来实现，这里使用BFS演示。 可以在线性时间复杂度（O（nm)）内，找到某个点所在的连通块（所有边权重相等） 例题： 城堡问题 图1是一个城堡的地形图。 请你编写一个程序，计算城堡一共有多少房间，最大的房间有多大。 城堡被分割成 m∗n个方格区域，每个方格区域可以有0~4面墙。 注意：墙体厚度忽略不计。 输入格式 第一行包含两个整数 m 和 n，分别表示城堡南北方向的长度和东西方向的长度。 接下来 m 行，
Acwing--1097.池塘计数(Flood Fill)
with_wine的博客
02-04 2944
Flood Fill（泛洪填充）_在？为什么不学习的博客-CSDN博客 Flood Fill（泛洪填充）：从一个起始节点开始，把附近与其连通的节点提取出或填充成不同颜色，直到封闭区域内的所有节点都被处理过为止。 是从一个区域中提取若干个连通的点与其他相邻区域区分开(或分别染成不同颜色)的经典算法。 可以抽象成一个二维矩阵（图片其实就是像素点矩阵），然后从某个点开始向四周扩展，直到无法再扩展为止。 即求连通块问题的算法。 具体实现采用BFS或DFS。 BFS求解：可以求出最短路或者判断两者是否...
对比DFS、BFS求连通块问题
ker的博客
07-16 766
许多连通块问题既可以用BFS求解也可以用DFS求解，两者各有优缺点。 BFS求解：可以求出最短路或者判断两者是否连通，不存在爆栈的风险，但空间相对用的多一些而且代码相对来说繁琐一些。 DFS求解：DFS代码简洁，相对好写一些，但存在爆栈的风险，而且不能求出最短路。
spring事务详细讲解-深入浅出
小电玩
09-08 435
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1432
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1362
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 461
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
flood fill
10-20
Flood Fill算法是一种对连通区域进行着色...本文提到的Flood Fill算法实现有两个版本，一个是使用BFS（广度优先搜索）实现，另一个是使用DFS（深度优先搜索）实现。在实际应用中，可以根据具体情况选择合适的算法实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值