第六讲 双指针、BFS与图论——AcWing 1113. 红与黑

最新推荐文章于 2024-03-30 22:16:54 发布
最新推荐文章于 2024-03-30 22:16:54 发布
阅读量138 收藏
点赞数
分类专栏： # 备战蓝桥杯 文章标签： bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44855907/article/details/114279563
版权

【题目描述】

AcWing 1113. 红与黑

DFS

res统计 该点能到达的所有点

import java.util.Scanner;
class Main{
    static int N = 25;
    static char [][] g = new char[N][N];
    static int dir[][] ={{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    
    public static int dfs(int x, int y, int m, int n){
        
        int res = 1;
        //标记为访问过
        g[x][y] = '#';
        for(int i = 0; i < 4; i++){
            int a = x + dir[i][0], b = y + dir[i][1];
            //越界  使用continue
            if(a < 0 || a >= m || b < 0 || b >= n) continue;
            //访问过
            if(g[a][b] == '#') continue;
            res += dfs(a, b, m, n);
        }
        return res;
    }
    public static void main(String args[]){
        Scanner reader = new Scanner(System.in);
        while(true){
            int n = reader.nextInt(), m = reader.nextInt();
            if( n == 0 && m == 0) break;
            for(int i = 0; i < m; i ++)
                g[i] = reader.next().toCharArray();
                
            int sx = 0, sy = 0;
            for(int i = 0; i < m; i ++)
                for(int j = 0; j < n; j ++)
                    if(g[i][j] == '@'){
                        sx = i;
                        sy = j;
                    }
                    
            System.out.println(dfs(sx, sy, m, n));
            
        }
        
    }
}

或标记可写成如下：

import java.util.Scanner;
class Main{
    static int N = 25;
    static char [][] g = new char[N][N];
    static int dir[][] ={{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    
    public static int dfs(int x, int y, int m, int n){
        
        int res = 1;
        //标记为访问过
        for(int i = 0; i < 4; i++){
            int a = x + dir[i][0], b = y + dir[i][1];
            //越界  使用continue
            if(a < 0 || a >= m || b < 0 || b >= n) continue;
            //访问过
            if(g[a][b] == '#') continue;
            
            //加入时 即标记为访问过
            g[a][b] = '#';
            
            res += dfs(a, b, m, n);
        }
        return res;
    }
    public static void main(String args[]){
        Scanner reader = new Scanner(System.in);
        while(true){
            int n = reader.nextInt(), m = reader.nextInt();
            if( n == 0 && m == 0) break;
            for(int i = 0; i < m; i ++)
                g[i] = reader.next().toCharArray();
                
            int sx = 0, sy = 0;
            for(int i = 0; i < m; i ++)
                for(int j = 0; j < n; j ++)
                    if(g[i][j] == '@'){
                        sx = i;
                        sy = j;
                    }
            g[sx][sy] = '#';
            System.out.println(dfs(sx, sy, m, n));
            
        }
        
    }
}

BFS

import java.util.Queue;
import java.util.LinkedList;
import java.util.Scanner;
class Node{
    int x, y;
    public Node(int xx, int yy){
        x = xx;
        y = yy;
    }
}
class Main{
    static int N = 25;
    static char [][] g = new char[N][N];
    static int dir[][] ={{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    public static void main(String args[]){
        Scanner reader = new Scanner(System.in);
        while(true){
            int n = reader.nextInt(), m = reader.nextInt();
            if( n == 0 && m == 0) break;
            for(int i = 0; i < m; i ++)
                g[i] = reader.next().toCharArray();
                
            int sx = 0, sy = 0;
            for(int i = 0; i < m; i ++)
                for(int j = 0; j < n; j ++)
                    if(g[i][j] == '@'){
                        sx = i;
                        sy = j;
                    }
                    
            Queue<Node> q = new LinkedList<Node>();
            q.offer(new Node(sx, sy));
            
            int cnt = 0;
            while(!q.isEmpty()){
                Node h = q.poll();
                int x = h.x, y = h.y;
                g[x][y] = '#';
                cnt ++;
                for(int i = 0; i < 4; i ++){//保证每个未被访问过的且可以到达的点只入队一次
                    int a = x +dir[i][0], b = y + dir[i][1];
                    if(a < 0 || a >= m || b < 0 || b >= n || g[a][b] == '#') continue;
                    //此处不标记，会重复入队列，有陷入死循环的可能
                    g[a][b] = '#';
                    q.offer(new Node(a, b));
                }
            }
            System.out.println(cnt);
            
        }
        
    }
}

或将标记写成如下：

import java.util.Queue;
import java.util.LinkedList;
import java.util.Scanner;
class Node{
    int x, y;
    public Node(int xx, int yy){
        x = xx;
        y = yy;
    }
}
class Main{
    static int N = 25;
    static char [][] g = new char[N][N];
    static int dir[][] ={{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    public static void main(String args[]){
        Scanner reader = new Scanner(System.in);
        while(true){
            int n = reader.nextInt(), m = reader.nextInt();
            if( n == 0 && m == 0) break;
            for(int i = 0; i < m; i ++)
                g[i] = reader.next().toCharArray();

            int sx = 0, sy = 0;
            for(int i = 0; i < m; i ++)
                for(int j = 0; j < n; j ++)
                    if(g[i][j] == '@'){
                        sx = i;
                        sy = j;
                    }

            Queue<Node> q = new LinkedList<Node>();
            q.offer(new Node(sx, sy));
            g[sx][sy] = '#';

            int cnt = 0;
            while(!q.isEmpty()){
                Node h = q.poll();
                int x = h.x, y = h.y;
                
                cnt ++;
                for(int i = 0; i < 4; i ++){//保证每个未被访问过的且可以到达的点只入队一次
                    int a = x +dir[i][0], b = y + dir[i][1];
                    if(a < 0 || a >= m || b < 0 || b >= n || g[a][b] == '#') continue;
                    //此处不标记，会重复入队列，有陷入死循环的可能
                    g[a][b] = '#';
                    q.offer(new Node(a, b));
                }
            }
            System.out.println(cnt);

        }

    }
}

如果写成如下，同一个节点会重复多次加入队列中。

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
/*

6 9 
....#. 
.....# 
...... 
...... 
...... 
...... 
...... 
#@...# 
.#..#. 
 
 */

/**
* @author JohnnyLin
* @version Creation Time：2021年1月14日 下午10:01:17
* 
*/
class Node{
	int x, y;
	public Node(int xx, int yy) {
		x = xx;
		y = yy;
	}
}
public class Main {
	//顺时针方向
	static int dir[][] = {{-1,0},{0,1},{1,0},{0,-1}};

	public static void main(String[] args) {
		Scanner reader = new Scanner(System.in);
		int n = reader.nextInt();		//列
		int m = reader.nextInt();		//行	
	    while(m != 0&& n != 0) {
			char map[][] = new char [m][n];
			boolean vis[][] = new boolean[m][n];
			int sx = 0, sy = 0;
			for(int i = 0; i < m; i++) {
				String s = reader.next();
				for(int j = 0; j < n; j++) {
					map [i][j] = s.charAt(j);
					if(map [i][j] == '@') {
						sx = i;
						sy = j;
					}
				}
				
			
			}	
			
			int cnt = 0; 
			Queue<Node> q = new LinkedList<Node>();
			//标记为已经访问过
			q.offer(new Node(sx, sy));
			
			
			while(q.size() != 0) {
				Node node = q.poll();;
				cnt++;
				int x = node.x, y = node.y;
				map[x][y] = '#';
				//往四个邻接方格扩展
				for(int i = 0; i < 4; i++) {
					int a = x + dir[i][0], b = y +dir[i][1];
					//越界或者访问过或者为红砖
					if(a < 0 || a >= m || b < 0 || b >=n || map[a][b] == '#')continue;
					//应该在此处标记访问过
					q.offer(new Node(a, b));
					
					
				}
				
			}
			System.out.println(cnt);
			
			m = reader.nextInt();
			n = reader.nextInt();
			
		}
    }

}
JohnnyLin00
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图论 —— 强连通分量
努力中的老周的专栏
02-18 908
如上图所示的一个有向图。我们可以将所有的边分为444种类型。树边（tree edge）：示意图中以黑色边表示，每次搜索找到一个还没有访问过的结点的时候就形成了一条树边。反祖边（back edge）：示意图中以红色边表示（即7→17 \to 17→1），也被叫做回边，即指向祖先结点的边。横叉边（cross edge）：示意图中以蓝色边表示（即9→79 \to 79→7），它主要是在搜索的时候遇到了一个已经访问过的结点，但是这个结点并不是当前结点的祖先。
红与黑-搜索-简单题解
m0_74157667的博客
03-15 146
由于zzy学长只喜欢黑色和红色,所以每块瓷砖的颜色是红色或者黑色。zzy学长站在一块黑色瓷砖上， 他可以从这块瓷砖移动到相邻（即，上下左右）的四块瓷砖中的一块。但是他只能移动到黑色瓷砖上，而不能移动到红色瓷砖上。编写一个程序，通过重复上述动作来计算zzy学长可以达到的黑色瓷砖的数量。对于每组数据，你的程序应输出一行，其中包含hjq学长可以到达的黑色瓷砖数目。（初始学长所站在的黑色瓷砖也要包含在内）H表示瓷砖的行数，W表示瓷砖的列数。'@' 表示zzy学长初始站在的瓷砖。瓷砖的颜色用字符表示，如下所示。
AcWing 1113. 红与黑 题解 （搜索——BFS）
qiaodxs的博客
06-11 105
AcWing 1113. 红与黑 BFS 计算数量，不是难题
红与黑
张宜强的博客
03-09 2477
https://www.nowcoder.com/practice/5017fd2fc5c84f78bbaed4777996213a?tpId=3&&tqId=10879&rp=1&ru=/activity/oj&qru=/ta/hackathon/question-ranking 点击打开链接 题目描述 有一间长方形的房子，地上铺了红色、黑色两...
[AcWing] 红与黑
weixin_44922845的博客
03-17 161
红与黑 题目 有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。 你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。 请写一个程序，计算你总共能够到达多少块黑色的瓷砖。 输入格式 输入包括多个数据集合。 每个数据集合的第一行是两个整数 W 和 H，分别表示 x 方向和 y 方向瓷砖的数量。 在接下来的 H 行中，每行包括 W 个字符。每个字符表示一块瓷砖的颜色，规...
AcWing 1113. 红与黑（dfs实现floodfill）
Jacob0824的博客
03-03 291
题意： 有个铺满方形瓷砖的矩形房间，瓷砖只有红或黑两种颜色。某人在一块砖上，他可以移动到相邻的四块砖上。但他只能走黑砖，不能走红砖。 统计一下总共可以到达多少块黑色的瓷砖。 思路： 用dfs实现floodfill算法 对于这种问题,既可以用DFS,又可以用BFS。 DFS代码比较短,但存在爆栈的风险,BFS代码较长,没有爆栈的风险且可以求得最小值 深搜有两种模型 第一种是棋盘内部从某个地方到另外一个地方(内部搜索,为了保证每个点只被搜索一次,不能回复现场,即不回溯),第二种是把棋盘当作一个整体(整个...
NOI2.5.1818 红与黑 题解(C++)
jerry20183的博客
05-06 954
NOI2.5.1818 红与黑 题解(C++) 题目 1818:红与黑 总Time Limit: 1000ms Memory Limit: 65536kB Description 有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。你站在其中一块黑色的瓷砖上，只能向相邻的黑色瓷砖移动。请写一个程序，计算你总共能够到达多少块黑色的瓷砖。 Input 包括多个数据集合。每个数据集合的第一行是两...
双指针，BFS与图论（一）
微赚开发者技术分享博客
01-30 363
（一）双指针 1.日志统计 小明维护着一个程序员论坛。现在他收集了一份”点赞”日志，日志共有N行。 其中每一行的格式是： ts id 表示在ts时刻编号id的帖子收到一个”赞”。 现在小明想统计有哪些帖子曾经是”热帖”。 如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞，小明就认为这个帖子曾是”热帖”。 具体来说，如果存在某个时刻T满足该帖在...
搜索与图论（一）——DFS、BFS、树与图的遍历
qq_44005993的博客
02-26 591
算法基础课-3.1,3.2 第三章 搜索与图论（一）+ Week4——习题课 共7题，知识点如下 DFS：排列数字、n-皇后问题。 BFS：走迷宫、八数码。 树与图的深度优先遍历：树的重心 树与图的广度优先遍历：图中点的层次 拓扑排序：有向图的拓扑序列
【AcWing】蓝桥杯C++ AB组辅导课
wei2019_的博客
04-29 7769
蓝桥杯 C++ AB 组辅导课教学计划与递归如何准备蓝桥杯比赛做题的套路递归与递推例题：递归实现指数型枚举例题：递归实现排列型枚举 教学计划与递归 如何准备蓝桥杯比赛 要有一定刷题量 若想在省赛中取得较好成绩，建议做200题左右。 若想在国赛中取得较好成绩，建议做300题左右。 本课程约讲解100题左右。 要重视调试 有思路得前提下，若调试不过，不要立马问别人。要自己努力解决问题。 要重视考试。 感受真实氛围，检验学习成果。 比赛时比的并不是去发明或者去创造某一个思路，比赛比的是熟练度。
蓝桥杯辅导课笔记
zh825的博客
04-19 376
第一讲 递归与递推 递归 将问题分解为若干个同种子问题 自己调用自己 所有递归都可以转化为递归搜索树来理解 斐波那契数列 AcWing 717. 简单斐波那契 - AcWing int f(int n) { if(n == 1) return 0; if(n == 2) return 1; return f(n - 1) + f(n - 2); } 指数型枚举 AcWing 92. 递归实现指数型枚举 - AcWing const int N = 16; in...
1216：红与黑
C_Dreamy的博客
02-05 1670
【题目描述】 有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。你站在其中一块黑色的瓷砖上，只能向相邻的黑色瓷砖移动。请写一个程序，计算你总共能够到达多少块黑色的瓷砖。 【输入】 包括多个数据集合。每个数据集合的第一行是两个整数W和H，分别表示x方向和y方向瓷砖的数量。W和H都不超过20。在接下来的H行中，每行包括W个字符。每个字符表示一块瓷砖的颜色，规则如下: 1）‘.’：黑色...
ACWing.1113 红与黑-DFS+BFS题解
HeartFireY的博客
10-23 1524
ACWing.1113 红与黑-DFS+BFS题解 题目描述 有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。 你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。 请写一个程序，计算你总共能够到达多少块黑色的瓷砖。 输入格式 输入包括多个数据集合。 每个数据集合的第一行是两个整数 W 和 H，分别表示 x 方向和 y 方向瓷砖的数量。 在接下来的 H 行中，每行包括 W 个字符。每个字符表示一块瓷砖的颜色，规则如下 1）‘.’：黑色的瓷砖； 2）‘#’：白色的瓷砖； 3）
寒假每日一题题解(1.12)：红与黑(bfs & dfs)
qq_49666427的博客
01-26 341
红与黑 有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。 你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。 请写一个程序，计算你总共能够到达多少块黑色的瓷砖。 输入格式 输入包括多个数据集合。 每个数据集合的第一行是两个整数 WW 和 HH，分别表示 xx 方向和 yy 方向瓷砖的数量。 在接下来的 HH 行中，每行包括 WW 个字符。每个字符表示一块瓷砖的颜色，规则如下 1）‘.’：黑色的瓷砖； 2）‘#’：红色的瓷砖； 3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。
HDU1312 / POJ1979 / ZOJ2165 Red and Black（红与黑） 解题报告
一蓑烟雨
09-04 1301
HDU1312 / POJ1979 / ZOJ2165 Red and Black（红与黑） DFS解题报告
NOI2.5 .1818 红与黑C++题解
最新发布
bajia2013的博客
03-30 567
接下来，我们就能写出DFS函数。只要输入“@”就可以判断起点。首先，我们要一个增量数组。这道题可以用爆搜实现。然后是完整代码，含注释。
红与黑 DFS(JAVA解法)
weixin_41988889的博客
01-28 1032
有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。 你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。 请写一个程序，计算你总共能够到达多少块黑色的瓷砖。 输入格式 输入包括多个数据集合。 每个数据集合的第一行是两个整数WW和HH，分别表示xx方向和yy方向瓷砖的数量。 在接下来的HH行中，每行包括WW个字符。每个字符表示一块瓷砖...
寒假每日一题_AcWing1113.红与黑--Java代码
星航夜空的帆舟
01-19 461
原题链接 题目描述 有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。 你站在其中一块黑色的瓷砖上，只能向相邻（上下左右四个方向）的黑色瓷砖移动。请写一个程序，计算你总共能够到达多少块黑色的瓷砖。 输入格式 输入包括多个数据集合。 每个数据集合的第一行是两个整数 W 和 H，分别表示 x 方向和 y 方向瓷砖的数量。 在接下来的 H 行中，每行包括 W 个字符。每个字符表示一块瓷砖的颜色，规则如下 1）‘.’：黑色的瓷砖； 2）‘#’：红色的瓷砖； 3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该
java红与黑算法_AcWing 1113. 红与黑-Java解法(DFS、BFS)
weixin_39881167的博客
02-28 127
BFS解法import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.util.LinkedList;import java.util.Queue;public class Main {private static int count = 1;privat...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值