uva 705 Slash Maze

最新推荐文章于 2019-08-13 00:29:42 发布

皓首不倦

最新推荐文章于 2019-08-13 00:29:42 发布

阅读量545

点赞数

CC 4.0 BY-SA版权

分类专栏： acm 文章标签： acm uva

本文链接：https://blog.youkuaiyun.com/xiaohaowudi_grh/article/details/12508017

acm 专栏收录该内容

240 篇文章

订阅专栏

本文详细解析了一种使用深度优先搜索算法解决矩阵遍历问题的方法，通过将矩阵转换为节点图并实现递归遍历，找出形成闭合环状结构的三角形块。文中提供了代码实现细节及示意图，适用于对算法与数据结构感兴趣的读者。

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

这道题也是矩阵遍历，用的还是dfs,把所有的斜线画在一个正方形的对角线上，然后把一个小三角形作为一个节点，每个节点有左上，左下，右上，右下四种类型，总共的节点数变成w*h*2，然后对小三角形矩阵进行深度优先遍历，找到连成一片的三角形块，如果一个三角形组成的块里面没有任何一个三角形处于矩阵的边缘，那么这个块一定是一个环状的，根据这个条件找到所有环状的三角形组成的区域，统计其中包含的三角形的个数就是原题里面所说的环里面包含的小方块的数目，所有节点遍历完之后，运算结束。每次递归的时候移动的方向要注意，并不是固定的，要根据三角形的类型来进行判断。

示意图如下，数字是三角形的类型：

#include <stdio.h>
#include <vector>
using namespace std;

#define		LEFT_UP			1
#define		LEFT_DOWN		2
#define		RIGHT_UP		3
#define		RIGHT_DOWN		4
#define		MAX_LEN			160

struct node
{
	int type; //三角块的类型
	bool visited;
};

struct node arr[MAX_LEN][MAX_LEN];

int m, n;
int case_count;

bool over_flow;
int block_count;
void dfs(int i, int j)
{
	if( !(i>=1&&i<=m) || !(j>=1&&j<=n))
	{
		over_flow = true;
		return;
	}

	if(arr[i][j].visited)
		return;

	block_count++;
	arr[i][j].visited = true;

	switch(arr[i][j].type)
	{
	case LEFT_UP:
		dfs(i, j-1);
		if(i == 1)
		{
			dfs(i-1, j);
		}
		else
		{
			switch(arr[i-1][j].type)
			{
			case LEFT_UP:
				dfs(i-1, j+1);
				break;
			case LEFT_DOWN:
				dfs(i-1, j);
				break;
			}
		}
		break;
	case LEFT_DOWN:
		dfs(i, j-1);
		if(i==m)
		{
			dfs(i+1, j);
		}
		else
		{
			switch(arr[i+1][j].type)
			{
			case LEFT_UP:
				dfs(i+1, j);
				break;
			case LEFT_DOWN:
				dfs(i+1, j+1);
				break;
			}
		}
		break;
	case RIGHT_UP:
		dfs(i, j+1);
		if(i == 1)
		{
			dfs(i-1, j-1);
		}
		else
		{
			switch(arr[i-1][j].type)
			{
			case RIGHT_UP:
				dfs(i-1, j-1);
				break;
			case RIGHT_DOWN:
				dfs(i-1, j);
				break;
			}
		}
		break;
	case RIGHT_DOWN:
		dfs(i, j+1);
		if(i == m)
		{
			dfs(i+1, j);
		}
		else
		{
			switch(arr[i+1][j].type)
			{
			case RIGHT_UP:
				dfs(i+1, j);
				break;
			case RIGHT_DOWN:
				dfs(i+1, j-1);
				break;
			}
		}
		break;
	}
}

void func(int m, int n)
{
	::m = m;	::n = n;

	int i, j;
	int max_len, circle_count;

	max_len = 0;
	circle_count = 0;
	for(i=1; i<=m; i++)
	{
		for(j=1; j<=n; j++)
		{
			block_count = 0;
			over_flow = false;
			dfs(i, j);
			if(!over_flow && block_count>0)
			{
				circle_count ++;
				//printf("circle:i=%d j=%d\n", i, j);
				if(max_len < block_count)
					max_len = block_count;
			}
		}
	}

	printf("Maze #%d:\n", case_count);
	if(max_len)
		printf("%d Cycles; the longest has length %d.\n", circle_count, max_len);
	else
		printf("There are no cycles.\n");
	printf("\n");
}

int main(void)
{
	//freopen("input.dat", "r", stdin);

	int m, n;
	int i, j;
	char ch;

	case_count = 0;
	while(1)
	{
		scanf("%d %d", &n, &m);
		getchar();
		if(!m && !n)
			break;

		for(i=1; i<=m; i++)
		{
			for(j=1; j<=n; j++)
			{
				ch = getchar();
				if(ch == '/')
				{

					arr[i][j*2-1].type = LEFT_UP;
					arr[i][j*2-1].visited = false;
					arr[i][j*2].type = RIGHT_DOWN;
					arr[i][j*2].visited = false;
				}
				else if(ch == '\\')
				{
					arr[i][j*2-1].type = LEFT_DOWN;
					arr[i][j*2-1].visited = false;
					arr[i][j*2].type = RIGHT_UP;
					arr[i][j*2].visited = false;
				}
			}
			getchar(); //读入\n
		}
		case_count ++;
		func(m, n*2);	
	}

	return 0;
}