CCF模拟试题I’m stuck!

最新推荐文章于 2022-03-03 20:47:38 发布

sunny1996

最新推荐文章于 2022-03-03 20:47:38 发布

阅读量1.1k

点赞数

CC 4.0 BY-SA版权

分类专栏：算法与ACM 文章标签： c语言搜索

本文链接：https://blog.youkuaiyun.com/sunny1996/article/details/52434884

算法与ACM 专栏收录该内容

34 篇文章

订阅专栏

这篇博客探讨了一种地图路径问题，其中玩家从'S'位置开始，需要找到所有可以到达但无法到达目标'T'的方格。地图由不同符号表示不同的移动规则。文章通过示例解释了问题并展示了结果地图。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题描述

给定一个R行C列的地图，地图的每一个方格可能是'#', '+', '-', '|', '.', 'S', 'T'七个字符中的一个，分别表示如下意思：

'#': 任何时候玩家都不能移动到此方格；

'+': 当玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；

'-': 当玩家到达这一方格后，下一步可以向左右两个方向相邻的一个非'#'方格移动一格；

'|': 当玩家到达这一方格后，下一步可以向上下两个方向相邻的一个非'#'方格移动一格；

'.': 当玩家到达这一方格后，下一步只能向下移动一格。如果下面相邻的方格为'#'，则玩家不能再移动；

'S': 玩家的初始位置，地图中只会有一个初始位置。玩家到达这一方格后，下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格；

'T': 玩家的目标位置，地图中只会有一个目标位置。玩家到达这一方格后，可以选择完成任务，也可以选择不完成任务继续移动。如果继续移动下一步可以向上下左右四个方向相邻的任意一个非'#'方格移动一格。

此外，玩家不能移动出地图。

请找出满足下面两个性质的方格个数：

1. 玩家可以从初始位置移动到此方格；

2. 玩家不可以从此方格移动到目标位置。

输入格式

输入的第一行包括两个整数R 和C，分别表示地图的行和列数。(1 ≤ R, C ≤ 50)。

接下来的R行每行都包含C个字符。它们表示地图的格子。地图上恰好有一个'S'和一个'T'。

输出格式

如果玩家在初始位置就已经不能到达终点了，就输出“I'm stuck!”（不含双引号）。否则的话，输出满足性质的方格的个数。

样例输入

5 5

--+-+

..|#.

..|##

S-+-T

####.

样例输出

样例说明

如果把满足性质的方格在地图上用'X'标记出来的话，地图如下所示：

--+-+

..|#X

..|##

S-+-T

####X

#include <iostream>
#include <stdio.h>
#include <queue>

using namespace std;

struct point
{
	int x, y;
}now,create;

char grid[52][52];
int sx, sy, tx, ty, r, c;
bool CanArrive[52][52], vis[52][52];

void dfs(int x, int y)
{
	if (x < 0 || x >= r || y < 0 || y >= c || grid[x][y] == '#' || CanArrive[x][y] == true)
	{
		return;
	}
	else
	{
		CanArrive[x][y] = true;
		if (grid[x][y] == '+' || grid[x][y] == 'T' || grid[x][y] == 'S')
		{
			dfs(x + 1, y);
			dfs(x - 1, y);
			dfs(x, y + 1);
			dfs(x, y - 1);
		}
		else if (grid[x][y] == '-')
		{
			dfs(x, y + 1);
			dfs(x, y - 1);
		}
		else if (grid[x][y] == '|')
		{
			dfs(x + 1, y);
			dfs(x - 1, y);
		}
		else if (grid[x][y] == '.')
		{
			dfs(x + 1, y);
		}
	}
	return;
}

bool CannotGoT(int x, int y)
{
	queue<point> q;
	now.x = x;
	now.y = y;
	q.push(now);
	memset(vis, false, sizeof(vis));
	vis[x][y] = true;
	while (!q.empty())
	{
		now = q.front();
		if (grid[now.x][now.y] == 'T')
		{
			return false;
		}
		if (grid[now.x][now.y] == '+'||grid[now.x][now.y]=='S')
		{
			if (now.x - 1 >= 0&&vis[now.x-1][now.y]==false)
			{
				create.x = now.x - 1;
				create.y = now.y;
				vis[create.x][create.y] = true;
				q.push(create);
			}
			if (now.x + 1 < r&&vis[now.x + 1][now.y] == false)
			{
				create.x = now.x + 1;
				create.y = now.y;
				vis[create.x][create.y] = true;
				q.push(create);
			}
			if (now.y-1 >= 0&&vis[now.x][now.y-1] == false)
			{
				create.x = now.x;
				create.y = now.y-1;
				vis[create.x][create.y] = true;
				q.push(create);
			}
			if (now.y + 1 < c&&vis[now.x][now.y+1] == false)
			{
				create.x = now.x;
				create.y = now.y + 1;
				vis[create.x][create.y] = true;
				q.push(create);
			}
		}
		else if (grid[now.x][now.y] == '-')
		{
			if (now.y - 1 >= 0 && vis[now.x][now.y - 1] == false)
			{
				create.x = now.x;
				create.y = now.y - 1;
				vis[create.x][create.y] = true;
				q.push(create);
			}
			if (now.y + 1 < c&&vis[now.x][now.y + 1] == false)
			{
				create.x = now.x;
				create.y = now.y + 1;
				vis[create.x][create.y] = true;
				q.push(create);
			}
		}
		else if (grid[now.x][now.y] == '|')
		{
			if (now.x - 1 >= 0 && vis[now.x - 1][now.y] == false)
			{
				create.x = now.x - 1;
				create.y = now.y;
				vis[create.x][create.y] = true;
				q.push(create);
			}
			if (now.x + 1 < r&&vis[now.x + 1][now.y] == false)
			{
				create.x = now.x + 1;
				create.y = now.y;
				vis[create.x][create.y] = true;
				q.push(create);
			}
		}
		else if (grid[now.x][now.y] == '.')
		{
			if (now.x + 1 < r&&vis[now.x + 1][now.y] == false)
			{
				create.x = now.x + 1;
				create.y = now.y;
				vis[create.x][create.y] = true;
				q.push(create);
			}
		}
		q.pop();
	}
	return true;
}

int main()
{
	bool tempans;
	int ans = 0;
	while (scanf("%d%d", &r, &c) != EOF)
	{
		ans = 0;
		memset(CanArrive, false, sizeof(CanArrive));
		memset(vis, false, sizeof(vis));
		for (int i = 0; i <= r - 1; i++)
		{
			getchar();
			for (int j = 0; j <= c - 1; j++)
			{
				scanf("%c", &grid[i][j]);
				if (grid[i][j] == 'S')
				{
					sx = i;
					sy = j;
				}
				else if (grid[i][j] == 'T')
				{
					tx = i;
					ty = j;
				}
			}
		}
		dfs(sx, sy);
		CanArrive[sx][sy] = true;
		if (CanArrive[tx][ty] == false)
		{
			printf("I'm stuck!\n");
			return 0;
		}
		for (int i = 0; i <= r - 1; i++)
		{
			for (int j = 0; j <= c - 1; j++)
			{
				if (CanArrive[i][j])
				{
					tempans = CannotGoT(i, j);
					if (tempans == true && grid[i][j] != 'S'&&grid[i][j] != 'T')
					{
						ans++;
					}
				}
			}
		}
		printf("%d\n", ans);
	}
	return 0;
}

这个题又很多思路，我采用的是先从出发点深搜，把能走到的点都搜出来，再对能走到的点进行广搜，看他们能不能走到终点，不过应该还有更简便的算法。