DAY52-图论BFS

已于 2024-08-25 23:03:22 修改
阅读量248 收藏
点赞数 1
分类专栏： LeetCode刷题手册 文章标签： 图论 宽度优先 算法
于 2024-08-25 22:57:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61702109/article/details/141536769
版权

kama101.孤岛的总面积 

	/**
	 * 在外循环遇到没有标记过的岛屿+1
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		int m=scan.nextInt();
		
		int[][] isoland = new int[n][m];
		boolean[][] path = new boolean[n][m];
		
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				isoland[i][j]=scan.nextInt();
			}
		}
		
		//初始化_把连着四周的陆地变为海洋
		for(int i=0;i<m;i++) {
			if(isoland[0][i]==1&&path[0][i]==false) {
				bfs0(isoland,path,0,i,n,m);
			}
			if(isoland[n-1][i]==1&&path[n-1][i]==false) {
				bfs0(isoland,path,n-1,i,n,m);
			}
		}
		for(int i=1;i<n-1;i++) {
			if(isoland[i][0]==1&&path[i][0]==false) {
				bfs0(isoland,path,i,0,n,m);
			}
			if(isoland[i][m-1]==1&&path[i][m-1]==false) {
				bfs0(isoland,path,i,m-1,n,m);
			}
		}
		
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				System.out.print(isoland[i][j]);
			}
			System.out.println();
		}
		
		//DFS搜索
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				if(isoland[i][j]==1&&path[i][j]==false) {
					bfs(isoland,path,i,j,n,m);
				}
			}
		}
		
		System.out.println(sum);
		scan.close();
	}
	
	public static int sum=0;
	public static int[][] step = {{1,0},{0,1},{-1,0},{0,-1}};
	
	/**
	 * 初始化为0
	 * @param isoland
	 * @param path
	 * @param x
	 * @param y
	 */
	public static void bfs0(int[][] isoland,boolean[][] path,int x,int y,int n,int m) {
		LinkedList<int[]> queue = new LinkedList<>();
		queue.add(new int[]{x,y});
		path[x][y]=true;
		isoland[x][y]=0;
		
		while(!queue.isEmpty()) {
			int[] temp = queue.remove();
			
			for(int i=0;i<4;i++) {
				int tempx=temp[0]+step[i][0];
				int tempy=temp[1]+step[i][1];
				
				//越界
				if(tempx<0||tempx>n-1||tempy<0||tempy>m-1) continue;
				if(isoland[tempx][tempy]==1&&path[tempx][tempy]==false) {
					path[tempx][tempy]=true;
					isoland[tempx][tempy]=0;
					queue.add(new int[] {tempx,tempy});
				}

			}
		}
		
	}
	
	/**
	 * 从哪个点开始广度搜索
	 * @param isoland
	 * @param path
	 * @param x
	 * @param y
	 */
	public static void bfs(int[][] isoland,boolean[][] path,int x,int y,int n,int m) {
		LinkedList<int[]> queue = new LinkedList<>();
		queue.add(new int[]{x,y});
		path[x][y]=true;
		sum++;
		while(!queue.isEmpty()) {
			int[] temp = queue.remove();
			
			for(int i=0;i<4;i++) {
				int tempx=temp[0]+step[i][0];
				int tempy=temp[1]+step[i][1];
				
				//越界
				if(tempx<0||tempx>n-1||tempy<0||tempy>m-1) continue;
				if(isoland[tempx][tempy]==1&&path[tempx][tempy]==false) {
					path[tempx][tempy]=true;
					sum++;
					queue.add(new int[] {tempx,tempy});
				}

			}
		}
		
	}

kama102.沉没孤岛 

	/**
	 * 在外循环遇到没有标记过的岛屿+1
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		int m=scan.nextInt();
		
		int[][] isoland = new int[n][m];
		boolean[][] path = new boolean[n][m];
		
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				isoland[i][j]=scan.nextInt();
			}
		}
		
		//初始化_把连着四周的陆地变为海洋
		for(int i=0;i<m;i++) {
			if(isoland[0][i]==1&&path[0][i]==false) {
				bfs(isoland,path,0,i,n,m);
			}
			if(isoland[n-1][i]==1&&path[n-1][i]==false) {
				bfs(isoland,path,n-1,i,n,m);
			}
		}
		for(int i=1;i<n-1;i++) {
			if(isoland[i][0]==1&&path[i][0]==false) {
				bfs(isoland,path,i,0,n,m);
			}
			if(isoland[i][m-1]==1&&path[i][m-1]==false) {
				bfs(isoland,path,i,m-1,n,m);
			}
		}
		

		
		//DFS搜索
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				if(isoland[i][j]==1&&path[i][j]==false) {
					bfs0(isoland,path,i,j,n,m);
				}
			}
		}
		
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				System.out.print(isoland[i][j]);
				if(j!=m-1) {
					System.out.print(" ");
				}
			}
			if(i!=n-1) {
				System.out.println();			
			}
		}

		scan.close();
	}
	
	public static int[][] step = {{1,0},{0,1},{-1,0},{0,-1}};
	
	/**
	 * 初始化为0
	 * @param isoland
	 * @param path
	 * @param x
	 * @param y
	 */
	public static void bfs0(int[][] isoland,boolean[][] path,int x,int y,int n,int m) {
		LinkedList<int[]> queue = new LinkedList<>();
		queue.add(new int[]{x,y});
		path[x][y]=true;
		isoland[x][y]=0;
		
		while(!queue.isEmpty()) {
			int[] temp = queue.remove();
			
			for(int i=0;i<4;i++) {
				int tempx=temp[0]+step[i][0];
				int tempy=temp[1]+step[i][1];
				
				//越界
				if(tempx<0||tempx>n-1||tempy<0||tempy>m-1) continue;
				if(isoland[tempx][tempy]==1&&path[tempx][tempy]==false) {
					path[tempx][tempy]=true;
					isoland[tempx][tempy]=0;
					queue.add(new int[] {tempx,tempy});
				}

			}
		}
		
	}
	
	/**
	 * 从哪个点开始广度搜索
	 * @param isoland
	 * @param path
	 * @param x
	 * @param y
	 */
	public static void bfs(int[][] isoland,boolean[][] path,int x,int y,int n,int m) {
		LinkedList<int[]> queue = new LinkedList<>();
		queue.add(new int[]{x,y});
		path[x][y]=true;
		while(!queue.isEmpty()) {
			int[] temp = queue.remove();
			
			for(int i=0;i<4;i++) {
				int tempx=temp[0]+step[i][0];
				int tempy=temp[1]+step[i][1];
				
				//越界
				if(tempx<0||tempx>n-1||tempy<0||tempy>m-1) continue;
				if(isoland[tempx][tempy]==1&&path[tempx][tempy]==false) {
					path[tempx][tempy]=true;
					queue.add(new int[] {tempx,tempy});
				}

			}
		}
		
	}

kama103.水流问题 

	/**
	 *从四周遍历获取两边都可以到达的地方
	 * @param args
	 */
	public static void main(String[] args) {
		
		//获取岛屿数组
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		int m=scan.nextInt();
		
		int[][] isoland = new int[n][m];
		boolean[][] pathL = new boolean[n][m];
		boolean[][] pathR = new boolean[n][m];
		
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				isoland[i][j]=scan.nextInt();
			}
		}
		
		//遍历上边界和下边界
		for(int i=0;i<m;i++) {
			if(pathL[0][i]==false) {
				bfs(isoland,pathL,0,i,n,m);
			}
			if(pathR[n-1][i]==false) {
				bfs(isoland,pathR,n-1,i,n,m);
			}
		}
		//遍历左边界和右边界
		for(int i=0;i<n;i++) {
			if(pathL[i][0]==false) {
				bfs(isoland,pathL,i,0,n,m);
			}
			if(pathR[i][m-1]==false) {
				bfs(isoland,pathR,i,m-1,n,m);
			}
		}
		
		
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				if(pathL[i][j]==true&&pathR[i][j]==true) {
					System.out.println(i+" "+j);
				}
			}
		}

		scan.close();
	}
	
	public static int[][] step = {{1,0},{0,1},{-1,0},{0,-1}};
	
	
	/**
	 * 从哪个点开始广度搜索
	 * @param isoland
	 * @param path
	 * @param x
	 * @param y
	 */
	public static void bfs(int[][] isoland,boolean[][] path,int x,int y,int n,int m) {
		LinkedList<int[]> queue = new LinkedList<>();
		queue.add(new int[]{x,y});
		path[x][y]=true;
		
		while(!queue.isEmpty()) {
			int[] temp = queue.remove();
			
			for(int i=0;i<4;i++) {
				int tempx=temp[0]+step[i][0];
				int tempy=temp[1]+step[i][1];
				
				//越界
				if(tempx<0||tempx>n-1||tempy<0||tempy>m-1) continue;
				if(isoland[tempx][tempy]>=isoland[temp[0]][temp[1]]&&path[tempx][tempy]==false) {
					path[tempx][tempy]=true;
					queue.add(new int[] {tempx,tempy});
				}

			}
		}
		
	}

kama104.建造最大岛屿

	/**
	 * 遍历每个岛并编号、再遍历所有的0将0周围的所有值加起来
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		int m=scan.nextInt();
		
		int[][] isoland = new int[n][m];
		boolean[][] path = new boolean[n][m];
		
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				isoland[i][j]=scan.nextInt();
			}
		}


		//BFS遍历
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				if(isoland[i][j]==1&&path[i][j]==false) {
					bfs0(isoland,path,i,j,n,m);
					hash.put(count, area);
					count++;
					area=0;
				}
			}
		}
		
		
		//会出现重复计算一个岛屿的问题
		int max=0;
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				
				//如果该位置是海洋
				if(isoland[i][j]==0) {
					int sub=0;
					set.clear();
					for(int k=0;k<4;k++) {
						int tempx=i+step[k][0];
						int tempy=j+step[k][1];
						
						//越界
						if(tempx<0||tempx>n-1||tempy<0||tempy>m-1) continue;
						if(isoland[tempx][tempy]==0) continue;
						if(set.contains(isoland[tempx][tempy]))continue;
						sub=sub+hash.get(isoland[tempx][tempy]);
						set.add(isoland[tempx][tempy]);
					}
					sub++;
					if(sub>max)max=sub;
				}
			}
		}
		
		scan.close();
		//说明没有海洋部分,返回整个陆地部分
		if(max==0) {
			System.out.println(hash.get(2));
			return ;
		}
		System.out.println(max);
	}
	
	public static int[][] step = {{1,0},{0,1},{-1,0},{0,-1}};
	
	//编号与map
	public static Map<Integer,Integer> hash = new HashMap<>();
	public static Set<Integer> set = new HashSet<>();
	public static int count=2;
	public static int area=0;
	/**
	 * 初始化为0
	 * @param isoland
	 * @param path
	 * @param x
	 * @param y
	 */
	public static void bfs0(int[][] isoland,boolean[][] path,int x,int y,int n,int m) {
		LinkedList<int[]> queue = new LinkedList<>();
		queue.add(new int[]{x,y});
		path[x][y]=true;
		isoland[x][y]=count;
		area++;
		
		while(!queue.isEmpty()) {
			int[] temp = queue.remove();
			
			for(int i=0;i<4;i++) {
				int tempx=temp[0]+step[i][0];
				int tempy=temp[1]+step[i][1];
				
				//越界
				if(tempx<0||tempx>n-1||tempy<0||tempy>m-1) continue;
				if(isoland[tempx][tempy]==1&&path[tempx][tempy]==false) {
					path[tempx][tempy]=true;
					isoland[tempx][tempy]=count;
					area++;
					queue.add(new int[] {tempx,tempy});
				}

			}
		}
		
	}
	
	/**
	 * 从哪个点开始广度搜索
	 * @param isoland
	 * @param path
	 * @param x
	 * @param y
	 */
	public static void bfs(int[][] isoland,boolean[][] path,int x,int y,int n,int m) {
		LinkedList<int[]> queue = new LinkedList<>();
		queue.add(new int[]{x,y});
		path[x][y]=true;
		while(!queue.isEmpty()) {
			int[] temp = queue.remove();
			
			for(int i=0;i<4;i++) {
				int tempx=temp[0]+step[i][0];
				int tempy=temp[1]+step[i][1];
				
				//越界
				if(tempx<0||tempx>n-1||tempy<0||tempy>m-1) continue;
				if(isoland[tempx][tempy]==1&&path[tempx][tempy]==false) {
					path[tempx][tempy]=true;
					queue.add(new int[] {tempx,tempy});
				}

			}
		}
		
	}

No.Ada
关注
专栏目录
DAY53-图论BFS
Ada的博客
08-31 452
kama105.有向图的完全可达性。kama110.字符串接龙。kama106.岛屿的周长。
DAY51-图论BFS
Ada的博客
08-25 180
kama99.岛屿数量。kama99.岛屿数量。
代码随想录day15--图论
weixin_34185396的博客
09-04 81
主要过程就是一圈一圈容器需要能保存所遍历过的元素：队列 ， 栈 ，数组队列：操作受限制的线性表，先进先出，一般应用的问题：速度不匹配，多用户竞争资源。顺序存储：头指针 front 指向对头元素，尾指针 rear 指向队尾元素的下一个位置。队列顺序存储的顺序存储类型的描述：登录后复制 #define MaxSize 50 ...
代码随想录day16--图论
weixin_42131601的博客
09-04 68
题目描述： 给定一个由 1（陆地）和 0（水）组成的矩阵，你需要计算岛屿的数量。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。 输入描述： 第一行包含两个整数 N, M，表示矩阵的行数和列数。 后续 N 行，每行包含 M 个数字，数字为 1 或者 0。 输出描述： 输出一个整数...
【面试】每日力扣 Day5 ---- 图论
weixin_45584892的博客
09-16 723
leetcode面试经典150题： 200、岛屿数量 130、被围绕的区域 133、克隆图
挑战30天C++基本入门（DAY10--BFS）（代码模板轻松秒杀图论）（二）
sgsgg0_0的博客
04-07 320
BFS承接上文DFS，秒解图论
java 图论算法包_玩转算法系列--图论精讲 面试升职必备（Java版）
weixin_33057949的博客
02-16 553
第1章 和bobo老师一起，玩转图论算法欢迎大家来到我的新课程：《玩转图论算法》。在这个课程中，我们将一起完整学习图论领域的经典算法，培养大家的图论建模能力。通过这个课程的学习，你将能够真正地，玩转图论算法：)第2章 图的基本表示千里之行，驶于足下。解决任何有一个图论算法问题，首先需要用基本的数据结构来表示图。在这一章，我们就将探索图的基本表示问题，学习邻接矩阵和邻接表，进而，也让同学们熟悉这个课...
【代码随想录训练营第42期 续Day52打卡 - 图论Part3 - 卡码网 103. 水流问题 104. 建造最大岛屿
记得要努力变强
09-07 1225
DFS -- 水流问题，岛屿问题进阶
代码随想录day14--图论
weixin_41377226的博客
09-04 70
两者大概的区别： dfs是可一个方向去搜，不到黄河不回头，直到遇到绝境了，搜不下去了，再换方向（换方向的过程就涉及到了回溯）。 bfs是先把本节点所连接的所有节点遍历一遍，走到下一个节点的时候，再把连接节点的所有节点遍历一遍，搜索方向更像是广度，四面八方的搜索过程。就地递归函数的下面，例如如下代码： 登录后复制 void...
leetcode卡-30-Day-LeetCoding-Challenge:“30天LeetCoding挑战”所有问题的解决方案+一些奖励问题
07-06
5. **图论**：图数据结构和相关算法，如深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径算法（Dijkstra、Floyd-Warshall等）在解决网络问题、社交网络分析等场景中有重要作用。 6. **动态规划**：这是一种解决...
sdwc2022-day3(图论1)
chengjize的博客
02-09 725
1.什么是图： 图论（英语：Graph theory），是组合数学的一个分支，和其他数学分支，如群论、矩阵论、拓扑学有着密切关系。图是图论的主要研究对象。图是由若干给定的顶点及连接两顶点的边所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系。顶点用于代表事物，连接两顶点的边则用于表示两个事物间具有这种关系。（以上都没啥用） 2.图的定义： 由顶点集V和边的集合E组成的一种关系结构，可以用有序二元组定义为G=(V,E)。 简单来说就是:V是一些节点，E是这些节点间的连接关系。 ...
搜索与图论（一）——DFS、BFS、树与图的遍历
qq_44005993的博客
02-26 635
算法基础课-3.1,3.2 第三章 搜索与图论（一）+ Week4——习题课 共7题，知识点如下 DFS：排列数字、n-皇后问题。 BFS：走迷宫、八数码。 树与图的深度优先遍历：树的重心 树与图的广度优先遍历：图中点的层次 拓扑排序：有向图的拓扑序列
2021-07-13 JZYZ暑期集训Day8 基础图论、树总结
qq_35684989的博客
07-13 974
Day8图论篇图的定义图的存储方法(1)邻接矩阵存(2)邻接表存Vector动态存法链式前向星图的遍历DFS 图论篇 图的定义 图（Graph）：表示物与物之间关系的方法。 图论（Graph Theory）：以图为研究对象，研究顶点和边组成的图形的数学理论和方法 。 一般是n个点，m条边。 无向图：顾名思义，没有方向的图。用不带箭头的边表示顶点之间的关系。 ↓这就是一个无向图。（1）可以到（2），（2）可以到（1） 有向图：顾名思义，有方向的图。用带箭头的边表示顶点之间的关系。 边权：就是边上的数值。 带
图论(dfs系列) 9/27
2301_78191305的博客
09-27 939
2.将所有的连通块找出来之后，然后枚举所有的海洋块。判断海洋块的周围有没有两个连通块(最多只能有两个连通块)。在以往的dfs搜索中，都是往四个方向去dfs；但是在这一道题中，四个方向是不行的；如果第i次是从左往右过来的，那么i+1次，就不能从右往左再过。给定一个二维数组grid,如果二维数组中存在一个环，处于环上的值都是相同的。如果不存在就返回false；1.首先找到所有的岛屿(连通块)，将他们存储到map表中。如果上一次不是从左边来的，那我们就可以往左走；如果上一次不是从右边来的，那我们就可以往右走；
图论系列(dfs岛屿) 9/26
2301_78191305的博客
09-26 532
在相同的位置处，如果矩阵2中是陆地，矩阵1中是海洋。1.出现在矩阵边缘的O定不会被包围，首先寻找未被包围的‘O’,通过dfs边缘的O，寻找连通子块。如果该节点正好是1并且没有被访问过，返回true，周围是1，满足被包围的条件。因为1是陆地，所以将两个岛屿中的1相加起来，如果为2，这就是他们重叠的陆地。2.然后剩下的O就是被包围的，将他们标记成X；淹没完不是子岛屿的岛屿，剩下的就是子岛屿的岛屿。如果值为2的岛屿中含有值为1的陆地，那么他就不是子岛屿；给定两个岛屿，看岛屿b中的岛屿是不是岛屿a中的子岛屿。
CSP-S 2022 T1假期计划
最新发布
良月澪二的博客
10-01 482
对于路径。
D. Determine Winning Islands in Race （cf div2，dp、图论最短路）
2303_79310336的博客
09-25 338
Codeforces Round 965 (Div. 2) D. Determine Winning Islands in Race 数据结构（data structures）动态规划（dp）图论（graphs）贪心（greedy）最短路（shortest paths）
匈牙利算法模板
qq_42643660的博客
09-30 348
匈牙利算法
数据结构 图论 BFS
06-07
BFS（Breadth-First Search）即广度优先搜索，是图论中的一种基本算法，用于遍历或搜索树或图的数据结构。BFS从一个根节点开始，沿着树的宽度遍历树的节点。如果所有的节点均被访问，则算法中止。 BFS主要有以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值