UVA - 519 Puzzle (II)（回溯+剪枝）

最新推荐文章于 2018-12-01 11:30:00 发布

原创最新推荐文章于 2018-12-01 11:30:00 发布 · 801 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Uva #519 #Puzzle II

回溯专栏收录该内容

36 篇文章

订阅专栏

本文介绍了一个拼图游戏问题，玩家需要将15块带有不同边类型的拼图块组成一个矩形。文章详细解释了游戏规则，并提供了一种通过深度优先搜索（DFS）结合剪枝策略的解决方案。

Puzzle (II)

Little Barborka has just started to learn how to solve a picture puzzle. She has started with a small one containing 15 pieces. Her daddy tries to solve the puzzle too. To make it a little bit harder for himself, he has turned all puzzle pieces upside down so that he cannot see pictures on the pieces. Now he is looking for a solution of the puzzle. Normally the solution should exist but he is not sure whether Barborka has not replaced some pieces of the puzzle by pieces of another similar puzzle. Help him and write a program which reads a description of a set of puzzle pieces and decides whether it is possible to assembly the pieces into a rectangle with given side lengths or not.

Input

The input file consists of blocks of lines. Each block except the last describes one puzzle problem. In the first line of the block there are integers nand m, $0 < n, m �\le 6$ separated by one space. The integers n, m indicate the number of rows and columns in the puzzle respectively. The description of individual puzzle pieces is in the following $n \times m$ lines of the block. Each piece is a rectangle 3 centimeters wide and 4 centimeters high with possible juts or cavities in the middle of its sides. For each side of a puzzle piece just one of the following possibilities is true (see picture):

there is no jut or cavity on the side, i.e., the side is flat - such sides can be used only on edges of the final picture when assembling the puzzle,
there is one jut in the middle of the side,
there is one cavity in the middle of the side.

$\begin{picture}(2301,2118)(0,-10)\put(585.000,912.000){\arc{450.000}{1.5708}{4.......{\SetFigFont{14}{16.8}{\rmdefault}{\mddefault}{\updefault}jut}}}}}\end{picture}$

As is usual, two pieces can be placed side by side only if one has a jut and the other has a cavity on corresponding sides. We will denote the flat sides by F, the sides with juts by O and the sides with cavities by I. Each piece is described by four letters characterizing its top, right, bottom, and left side. To make the task easier the pieces can be used only as they are described i.e. they cannot be turned.

After each block there is an empty line. The last block consists of just one line containing 0 0, i.e. two zeros separated by one space.

Output

The output file contains the lines corresponding to the blocks in the input file. A line contains YES if the corresponding block in the input file describes a puzzle that can be correctly assembled. Otherwise it contains NO. There is no line in the output file corresponding to the last ``null'' block of the input file.

Sample Input

3 5
FOOF
FOOI
FOOI
FOOI
FFOI
IOOF
IOOI
IOOI
IOOI
IFOI
IOFF
IOFI
IOFI
IOFI
IFFI
0 0

Sample Output

YES

题意：
输入n，m。表示有一个n*m的拼图。然后输入每一块拼图F代表平的。I代表凸的。O代表凹的。要求判断这个拼图能不能拼出来。
字符串中的每个位置的字符从左到右，分别表示：顶、右、下、左。

思路：dfs+剪枝。一格格去放拼图。放不了就进行回溯。

剪枝点：
1、由于边缘一定是平的，内部一定是凸凹结合的。所以判断F的数量等不等于2 * (n + m)，以及I的数量等不等于O的数量。如果都等于再进行dfs。
2、如果有一块拼图在一个位置上不能拼。那么下次遇到一样的拼图的时候直接跳过。

注意：衔接处的判断。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

const int N = 8;
int tot;
int m,n;
int vis[N*N];
char piece[N*N][5];
char grid[N][N][5];
int in,out,flat;
bool ok;

int cmp(const void *a,const void *b) {
	return strcmp((char*)a,(char*)b);
}

void init() {
	memset(grid,0,sizeof(grid));
	memset(vis,0,sizeof(vis));
	in = out = flat = 0;
}

bool judge(int cur,int r,int c) {
	if(r == 0 && piece[cur][0] != 'F' ||
			r == m-1 && piece[cur][2] != 'F' ||
			c == 0 && piece[cur][3] != 'F' ||
			c == n-1 && piece[cur][1] != 'F') {
		return false;
	}
	if(r > 0) {
		if(piece[cur][0] == 'I' && grid[r-1][c][2] != 'O' || 
				piece[cur][0] == 'O' && grid[r-1][c][2] != 'I' ||
				piece[cur][0] == 'F' && grid[r-1][c][2] != 'F') {
			return false;
		}
	}
	if(c > 0) {
		if(piece[cur][3] == 'I' && grid[r][c-1][1] != 'O' || 
				piece[cur][3] == 'O' && grid[r][c-1][1] != 'I' ||
				piece[cur][3] == 'F' && grid[r][c-1][1] != 'F') {
			return false;
		}
	}
	return true;
}

void dfs(int r,int c) {
	if(r == m) {
		ok = true;
		return;
	}
	if(c == n) {
		dfs(r+1,0);
		return;
	}
	char tmp[5] = "a";
	for(int i = 0; i < tot; i++) {
		if(!vis[i] && judge(i,r,c) && strcmp(tmp,piece[i])) {
			strcpy(tmp,piece[i]);
			strcpy(grid[r][c],piece[i]);
			vis[i] = true;
			dfs(r,c+1);
			vis[i] = false;
			if(ok) {
				return;
			}
		}
	}
}

int main() {
	while(scanf("%d%d",&m,&n) != EOF && (m || n)) {
		init();
		tot = m*n;
		for(int i = 0; i < tot; i++) {
			scanf("%s",piece[i]);
			for(int j = 0; j < 4; j++) {
				if(piece[i][j] == 'I') {
					in++;
				}else if(piece[i][j] == 'O') {
					out++;
				}else if(piece[i][j] == 'F') {
					flat++;
				}
			}
		}
		qsort(piece,tot,sizeof(piece[0]),cmp);
		ok = false;
		if(flat == 2*(m+n) && in == out) {
			dfs(0,0);
		}
		if(ok) {
			printf("YES\n");
		}else {
			printf("NO\n");
		}
	}
	return 0;
}