P11228 [CSP-J 2024] 地图探险

原创 于 2025-12-13 00:42:18 发布 · 475 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #图论 #数据结构 #c++ #题解 #CSP-J

记录51

#include<bits/stdc++.h>
using namespace std;
char mp[1010][1010]={};
int vis[1010][1010]={};
int dx[5]={0,1,0,-1};
int dy[5]={1,0,-1,0};
int main(){
	int T,n,m,k,x,y,d;
	cin>>T;
	while(T--){
		cin>>n>>m>>k;
		cin>>x>>y>>d;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++) cin>>mp[i][j];
		}
		int ans=1;
    vis[x][y]=1;
    	//int cnt=1;
		while(k--){
      		//printf("第%d次操作:",cnt);
			int xn=x+dx[d];
			int yn=y+dy[d];
			if(xn>=1&&xn<=n&&yn>=1&yn<=m&&mp[xn][yn]=='.'){
				if(vis[xn][yn]==0){
					ans++;
					vis[xn][yn]=1;
				}
				x=xn;
				y=yn;
        		//printf("走到(%d,%d)  第%d个位置\n",xn,yn,ans);
			}
			else{
        		d=++d%4;
        		//printf("向%d方向转向\n",d);
      		} 
      		//cnt++;
		}
		cout<<ans<<endl;
    	memset(vis,0,sizeof(vis));
	}
	return 0;
}

题目传送门https://www.luogu.com.cn/problem/P11228

突破口

初始时，机器人的位置为 (x0​,y0​)，朝向为 d0​。保证初始时机器人所在的位置为空地。接下来机器人将要进行 k 次操作。每一步，机器人将按照如下的模式操作

👉转向也算一次操作

保证字符串中只包含 x 和 . 两个字符。其中，第 x 行的字符串的第 y 个字符代表的位置为 (x,y)。这个位置是 x 即代表它是障碍，否则代表它是空地。数据保证机器人初始时所在的位置为空地。

👉有障碍物

地图上所有被机器人经过的位置（包括起始位置）有几个。

👉计算走的格子数，不重复计数

思路

并不是bfs跟dfs的题目，但是如果会搜索就很轻松做本题，这题纯模拟

  1. 构建地图
  2. 寻找可行路径
  3. 计数走过的格子

代码简析

#include<bits/stdc++.h>
using namespace std;
char mp[1010][1010]={};
int vis[1010][1010]={};
int dx[5]={0,1,0,-1};
int dy[5]={1,0,-1,0};
int main(){
	int T,n,m,k,x,y,d;
	cin>>T;
	while(T--){
		cin>>n>>m>>k;
		cin>>x>>y>>d;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++) cin>>mp[i][j];
		}
    }
	...
	return 0;
}

char mp[1010][1010]={};👉地图空间

int vis[1010][1010]={};👉判断地图上的点是否访问过，防止重复计数

int dx[5]={0,1,0,-1};👉x方向移动，上(减)下(加)移动

int dy[5]={1,0,-1,0};👉y方向移动，左(减)右(加)移动

注意：二者结合起来看，就是右下左上的逆时针转动

int T（几组数据）,n（行数）,m（列数）,k（次数）,x（停留的点）,y（停留的点）,d（转动方向）;

#include<bits/stdc++.h>
using namespace std;
char mp[1010][1010]={};
int vis[1010][1010]={};
int dx[5]={0,1,0,-1};
int dy[5]={1,0,-1,0};
int main(){
	int T,n,m,k,x,y,d;
	cin>>T;
	while(T--){
		cin>>n>>m>>k;
		cin>>x>>y>>d;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++) cin>>mp[i][j];
		}
		int ans=1;
    vis[x][y]=1;
    	//int cnt=1;
		while(k--){
      		//printf("第%d次操作:",cnt);
			int xn=x+dx[d];
			int yn=y+dy[d];
			if(xn>=1&&xn<=n&&yn>=1&yn<=m&&mp[xn][yn]=='.'){
				if(vis[xn][yn]==0){
					ans++;
					vis[xn][yn]=1;
				}
				x=xn;
				y=yn;
        		//printf("走到(%d,%d)  第%d个位置\n",xn,yn,ans);
			}
			else{
        		d=++d%4;
        		//printf("向%d方向转向\n",d);
      		} 
      		//cnt++;
		}
		cout<<ans<<endl;
    	memset(vis,0,sizeof(vis));
	}
	return 0;
}

int ans=1;👉起点是经过的第一个格子

vis[x][y]=1;👉地图上记录起点访问过

while(k--){}👉只执行k次操作

int xn=x+dx[d];   int yn=y+dy[d];👉记录接下来移动后的位置

if(xn>=1&&xn<=n&&yn>=1&yn<=m&&mp[xn][yn]=='.'){}👉判断路径是否可行

ans++;     vis[xn][yn]=1;👉格子数加1，同时记录这个点经过了

x=xn;  y=yn;👉更新停留的点

else{d=++d%4;} 👉路径不可行的时候进行转向

cout<<ans<<endl;👉输出经过的点

memset(vis,0,sizeof(vis));👉访问数组重置，防止下一组数据被污染

补充

CSP-J DFS/BFS 技巧完全汇总

一、搜索题识别特征（先判断用哪个）

特征DFS（深度优先）BFS（广度优先）
目标找路径、方案数、连通块找最短路径/步数、最小操作
数据结构图、树、网格图、网格
关键词"有多少种方案"、"路径"、"连通""最少步数"、"最短"、"最快"
典型题迷宫路径数、连通块、选物品迷宫最短路径、倒水问题、编辑距离
CSP-J频率★★★★★★★★★★

二、DFS核心技巧（CSP-J必背）

技巧1：记忆化搜索（DP化）

场景：重复子问题，如迷宫路径数

int dfs(int x, int y) {
    if (x == n && y == m) return 1;
    if (vis[x][y]) return dp[x][y];  // 记忆化
    vis[x][y] = true;
    int ans = 0;
    for (int dir = 0; dir < 4; dir++) {
        int nx = x + dx[dir], ny = y + dy[dir];
        if (valid(nx, ny)) {
            ans += dfs(nx, ny);
        }
    }
    return dp[x][y] = ans;  // 保存结果
}

作用：将O(4ⁿ)降到O(n²)

技巧2：连通块标记（最常用）

场景：统计岛屿数量、洪水填充

void dfs(int x, int y) {
    if (x<1 || x>n || y<1 || y>m || a[x][y]!=1) return;  // 边界
    a[x][y] = 2;  // 标记为已访问
    for (int dir=0; dir<4; dir++) {
        dfs(x+dx[dir], y+dy[dir]);
    }
}

// 统计连通块
int cnt = 0;
for (int i=1; i<=n; i++)
    for (int j=1; j<=m; j++)
        if (a[i][j] == 1) {
            dfs(i, j);
            cnt++;
        }

技巧3：选物品/组合（回溯+剪枝）

场景：从n个物品选k个，和为目标值

bool dfs(int idx, int sum, int chosen) {
    if (chosen == k && sum == target) return true;
    if (idx > n || chosen > k || sum > target) return false;  // 剪枝
    
    // 选当前
    if (dfs(idx+1, sum+a[idx], chosen+1)) return true;
    
    // 不选当前
    if (dfs(idx+1, sum, chosen)) return true;
    
    return false;
}

技巧4：树形DFS（树遍历）

场景：树的深度、子树大小、路径和

int depth[N];
void dfs(int u, int parent) {
    for (int v : g[u]) {
        if (v == parent) continue;  // 避免回父节点
        depth[v] = depth[u] + 1;
        dfs(v, u);
    }
}

三、BFS核心技巧（CSP-J必背）

技巧1：最短路径（最核心）

场景：迷宫最短步数、最少操作

int bfs(int sx, int sy) {
    queue<pair<int, int>> q;
    q.push({sx, sy});
    vis[sx][sy] = 0;  // 距离数组
    
    while (!q.empty()) {
        auto [x, y] = q.front(); q.pop();
        if (x == tx && y == ty) return vis[x][y];
        
        for (int dir=0; dir<4; dir++) {
            int nx = x + dx[dir], ny = y + dy[dir];
            if (valid(nx, ny) && !vis[nx][ny]) {
                vis[nx][ny] = vis[x][y] + 1;
                q.push({nx, ny});
            }
        }
    }
    return -1;  // 无法到达
}

记忆：BFS第一次到达终点时，步数一定是最短的

技巧2：多源BFS（洪水填充优化）

场景：多个起点同时扩展

// 将所有起点同时入队
queue<pair<int, int>> q;
for (int i=1; i<=n; i++)
    for (int j=1; j<=m; j++)
        if (a[i][j] == 起点) {
            q.push({i, j});
            vis[i][j] = 0;
        }

// BFS扩展，谁先到终点谁最短
while (!q.empty()) { ... }

技巧3：0-1 BFS（边权为0或1）

场景：某些方向代价为0，某些为1（如转向代价）

deque<pair<int, int>> q;  // 用双端队列
vis[sx][sy] = 0;
q.push_front({sx, sy});  // 起点从队首入

while (!q.empty()) {
    auto [x, y] = q.front(); q.pop_front();
    for (int dir=0; dir<4; dir++) {
        int nx = x + dx[dir], ny = y + dy[dir];
        int w = (dir == 方向) ? 0 : 1;  // 代价
        if (valid(nx, ny) && vis[x][y] + w < vis[nx][ny]) {
            vis[nx][ny] = vis[x][y] + w;
            if (w == 0) q.push_front({nx, ny});
            else q.push_back({nx, ny});
        }
    }
}

四、DFS vs BFS 选择决策树

是否需要求最短/最少？
├── 是 → BFS（第一次到终点即最短）
│       └── 边权为0/1 → 0-1 BFS/双端队列
│
└── 否 → DFS（找路径、方案数、连通块）
        ├── 有重复子问题 → 记忆化搜索
        ├── 找所有方案 → 回溯+剪枝
        └── 只需遍历 → 普通DFS

五、CSP-J搜索题通用模板

DFS模板（连通块）

const int N = 1010;
int n, m, a[N][N];
bool vis[N][N];
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};

void dfs(int x, int y) {
    if (x<1 || x>n || y<1 || y>m || a[x][y]==0 || vis[x][y]) return;
    vis[x][y] = true;
    for (int dir=0; dir<4; dir++) {
        dfs(x+dx[dir], y+dy[dir]);
    }
}

BFS模板（最短路径）

int bfs(int sx, int sy, int tx, int ty) {
    memset(vis, -1, sizeof(vis));
    queue<pair<int, int>> q;
    q.push({sx, sy});
    vis[sx][sy] = 0;
    
    while (!q.empty()) {
        auto [x, y] = q.front(); q.pop();
        if (x == tx && y == ty) return vis[x][y];
        
        for (int dir=0; dir<4; dir++) {
            int nx = x + dx[dir], ny = y + dy[dir];
            if (nx>=1 && nx<=n && ny>=1 && ny<=m && a[nx][ny]==1 && vis[nx][ny]==-1) {
                vis[nx][ny] = vis[x][y] + 1;
                q.push({nx, ny});
            }
        }
    }
    return -1;  // 无法到达
}

六、性能优化技巧

1. 剪枝（Pruning）

if (当前步数 >= 最优解) return;  // 步数剪枝
if (当前和 > 目标值) return;      // 和剪枝
if (不可能到达) return;            // 可行性剪枝

2. 迭代加深（DFS深度限制）

for (int depth = 1; depth <= MAX_DEPTH; depth++) {
    if (dfs(起点, depth)) {  // 限制深度搜索
        cout << depth;  // 找到最优解
        break;
    }
}

3. 双向BFS

// 从起点和终点同时开始BFS，在中间相遇
queue<pair<int, int>> q1, q2;
// 交替扩展，直到相遇

七、调试与容错技巧

1. 访问越界检查

#define valid(x, y) (x>=1 && x<=n && y>=1 && y<=m && !vis[x][y])
// 或函数形式
inline bool check(int x, int y) {
    return x>=1 && x<=n && y>=1 && y<=m && a[x][y]==1;
}

2. 递归深度限制

// DFS递归深度超过10^5会栈溢出，改用栈模拟迭代
if (depth > 100000) return false;  // 提前退出

3. BFS队列大小

// 最坏情况队列大小 = n×m，开数组要开够
queue<pair<int, int>> q;  // 或用数组模拟队列

八、CSP-J高频搜索题清单

年份题目搜索类型难度
2023 T1小苹果流程模拟（类BFS）★☆☆☆☆
2022 T1乘方DFS（递归）★☆☆☆☆
2021迷宫BFS最短路径★★☆☆☆
2020连通块DFS染色★★☆☆☆
2019选物品DFS回溯★★☆☆☆

九、一句话总结

CSP-J搜索题 = 先判BFS/DFS → 写模板 → 加剪枝 → 防越界 → 调试输出，BFS找最短，DFS找路径，记忆化防超时，全局开大数组。

cpp_2501
关注
CSP-J系列【2024】P11228 [CSP-J 2024] 地图探险题解
djy2024的博客
07-23 797
摘要 本文描述了一个机器人丛林探险的模拟问题。给定n×m的字符矩阵表示丛林地图（'.'可通行，'x'障碍物），机器人从初始位置(x0,y0)和方向d0出发，执行k次操作：每次尝试沿当前方向移动，若受阻则右转90度。要求统计机器人最终访问过的不同位置总数（含起点）。输入包含T组测试数据，每组包括地图尺寸、操作次数、初始状态和地图信息。输出每组数据中机器人访问过的位置数量。样例展示了机器人在受阻时转向和成功移动的不同情况。算法需要模拟每一步操作，维护位置和方向状态，并用标记数组记录访问轨迹。时间复杂度主要取决于
洛谷P11228[CSP-J 2024] 地图探险
2501_91189146的博客
07-30 1512
大家好！今天我们要聊的是 2024 年 CSP-J 认证中的一道有趣题目 ——《地图探险》。这道题属于模拟类问题，核心是让我们模拟一个角色在地图上的移动过程，统计它探索过的不同格子数量。先看看题目大概讲了什么（用大白话翻译一下）：有一个 n 行 m 列的地图，地图上的格子要么是可以走的空地（用 '.' 表示），要么是障碍物（题目里没明说，但从代码看应该是不能走的格子，比如用其他字符表示）。我们的探险者从坐标 (x,y) 出发，一开始面朝某个方向（d=0,1,2,3 分别代表四个方向）。
P11228 [CSP-J 2024] 地图探险（官方数据）
yaosichengalpha的博客
11-15 1305
P11228 [CSP-J 2024] 地图探险（官方数据）
P11228 [CSP-J 2024] 地图探险（民间数据）
xiebohang的博客
10-27 464
这道题挺简单的，就是把题中所给的条件换成代码就行了，题解感觉不知道咋写，注释都放在代码里了，非常清楚。
[CSP-J 2024] 地图探险
no_play_no_games的博客
10-27 837
见选手目录下的 explore/explore2.in 与 explore/explore2.ans。见选手目录下的 explore/explore3.in 与 explore/explore3.ans。见选手目录下的 explore/explore4.in 与 explore/explore4.ans。对于每组数据：输出一行包含一个正整数，表示地图上所有被机器人经过的位置（包括起始位置）的个数。接下来，机器人判断它下一步的位置是否在地图内，且是否为空地。因此，四步之后，机器人经过的位置有三个，分别为。
洛谷 P11228：[CSP-J 2024 T2] 地图探险 ← 搜索算法
Liuchang0911的博客
07-30 712
这道题今天考试考了，作为了附加题，那我们来看看是怎嘛个事儿。
信息学奥赛一本通 2112：【24CSPJ普及组】地图探险（explore） | 洛谷 P11228 [CSP-J 2024] 地图探险
君义NOIP的博客
02-03 1180
题目中已经给出了表示方向的方法：整数d表示机器人前进的方向，d = 0 代表向东（右），d = 1 代表向南（下），d = 2 代表向西（左），d = 3 代表向北（上）。在一个矩阵中，当前位置为(sx, sy)，将下一个位置与当前位置横纵坐标的差值记到一个数组中，即为方向数组。表示向整数d代表的方向走一步后，新位置和原位置横纵坐标的差值。走一步后新的位置和当前位置横纵坐标的差值，走一步后新的位置和当前位置横纵坐标的差值，走一步后新的位置和当前位置横纵坐标的差值，所以将方向数组声明为。
CSP-J 2024 T2 地图探险【题解】
applelin的博客
04-12 433
CSP-J 2024 T2 地图探险【题解】
题解 P11228 [CSP-J 2024] 地图探险 题解
PandaLYL的博客
01-23 332
起始点也算被走过，所以可以用一个标记数组，判断当前格子有没有被走过.但因为起点终点，并且走的步数都告诉你了，所以直接模拟就行.第一眼，可能有人回想起 dfs.
2024 CSP-J2 CSP-S2 第2轮 复赛 真题 讲解、解析（2024.10.27）.pdf
10-27
对于2024年的CSP-J2和CSP-S2复赛题目，文件详细讲解了各个题目，例如“扑克牌”、“地图探险”、“小木棍”和“接龙”等。这些题目往往需要参赛者具备一定的编程基础和算法知识，如递归、贪心算法、二分算法、分治...
精选资源
CSP-J 2024第二轮上机真题
10-26
CSP-J 2024第二轮上机真题涉及信息学奥赛，是一系列传统的编程挑战，要求参与者在限定时间内通过编程解决给定的数学和逻辑问题。本次认证包含四个题目：扑克牌、地图探险、小木棍接龙、题目链。每位参赛者需用C++...
Louvain 算法
最新发布
FionaDong的博客
12-12 115
Louvain 是一种经典的图社区发现算法（Community Detection），由 Blondel 等人在 2008 年提出。核心目标：通过最大化 Modularity（模块度）来自动划分图中的社区（cluster）。它最大的特点是：✔ 速度非常快✔ 能处理百万级节点的大图✔ 结果相对稳定。
shardingsphere-jdbc分表实现案例和算法比对
Sunchaser的博客
12-08 872
本文档基于shardingsphere-jdbc-core-spring-boot-starter 5.2.1版本验证分表能力，同时基于实际的业务场景对比几类分表策略和实现方案 分库和分表是两个截然不同的功能，分表只要我们在Springboot中引入shardingsphere-jdbc这个依赖库即可，但是分库就要单独部署一个服务shardingsphere-proxy，其他服务连接shardingsphere-proxy，从而实现分库的功能
【每天学习一点算法 2025/12/10】反转链表
Colorful9的博客
12-10 862
本文介绍了反转链表的三种实现方法：1）使用栈结构存储节点后弹栈重建；2）迭代法通过遍历直接修改节点指向；3）递归法在回归过程中逐步反转节点。重点解析了递归实现的原理，通过递推找到尾节点后，在回归过程中逐个反转节点指向并断开原链接。三种方法各有特点，栈实现直观但需额外空间，迭代法高效，递归法则展示了递归的独特处理方式。
**智能建模算法（GA-ELM）**与**多目标优化算法（NSGA-Ⅱ）** 相结合，用于解决**42CrMo钢表面激光熔覆工艺优化**问题
算法如诗的博客
12-09 711
**智能建模算法（GA-ELM）**与**多目标优化算法（NSGA-Ⅱ）** 相结合，用于解决**42CrMo钢表面激光熔覆工艺优化**问题
二次多项式RSM响应面模型+NSGA-II算法多目标优化，高端绘图（拟合效果图、单因素影响图、交互作用图、三维曲面图）！
机器学习之心的博客，关注并私信文章链接，获取对应文章源码和数据。
12-08 1269
二次多项式RSM响应面模型+NSGA-II算法多目标优化，高端绘图（拟合效果图、单因素影响图、交互作用图、三维曲面图）！
数据结构（12）堆排序
2401_87986548的博客
12-09 760
堆排序是一种基于堆数据结构的选择排序算法，通过构建大堆（升序）或小堆（降序）实现排序。算法分为两步：首先通过向下调整算法构建初始堆（时间复杂度O(N)），然后通过反复交换堆顶与末尾元素并调整堆完成排序（时间复杂度O(N*logN)）。堆排序空间复杂度为O(1)，但不稳定。实现时需注意升序建大堆、降序建小堆的关键区别，并通过调整父子节点关系维持堆性质。典型实现包括交换函数、向下调整函数和主排序函数，通过比较和交换操作逐步完成排序。
基于小波分析和TV非凸模型的图像去模糊去噪算法
rit8432499的博客
12-11 243
基于小波分析和TV非凸模型的图像去模糊去噪算法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值