UVA - 387 A Puzzling Problem（回溯）

最新推荐文章于 2024-03-25 14:24:51 发布

HelloWorld10086

最新推荐文章于 2024-03-25 14:24:51 发布

阅读量779

点赞数

CC 4.0 BY-SA版权

分类专栏：回溯文章标签： Uva A Puzzling Problem

本文链接：https://blog.youkuaiyun.com/helloworld10086/article/details/38711013

回溯专栏收录该内容

36 篇文章

订阅专栏

本文详细介绍了如何通过回溯算法解决拼图问题，目标是在限定的拼图数量下，尝试组合形成一个完整的4×4正方形。通过输入指定的拼图形状和数量，程序将输出所有可能的解决方案之一，或者报告无法形成正方形的情况。

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

A Puzzling Problem

The goal of this problem is to write a program which will take from 1 to 5 puzzle pieces such as those shown below and arrange them, if possible, to form a square. An example set of pieces is shown here.

The pieces cannot be rotated or flipped from their original orientation in an attempt to form a square from the set. All of the pieces must be used to form the square. There may be more than one possible solution for a set of pieces, and not every arrangement will work even with a set for which a solution can be found. Examples using the above set of pieces are shown here.

Input

The input file for this program contains several puzzles (i.e. sets of puzzle pieces) to be solved. The first line of the file is the number of pieces in the first puzzle. Each piece is then specified by listing a single line with two integers, the number of rows and columns in the piece, followed by one or more lines which specify the shape of the piece. The shape specification consists of `0' and `1' characters, with the `1' characters indicating the solid shape of the puzzle (the `0' characters are merely placeholders). For example, piece `A' above would be specified as follows:

2 3
111
101

The pieces should be numbered by the order they are encountered in the puzzle. That is, the first piece in a puzzle is piece #1, the next is piece #2, etc. All pieces may be assumed to be valid and no larger than 4 rows by 4 columns.

The line following the final line of the last piece contains the number of pieces in the next puzzle, again followed by the puzzle pieces and so on. The end of the input file is indicated by a zero in place of the number of puzzle pieces.

Output

Your program should report a solution, if one is possible, in the format shown by the examples below. A 4-row by 4-column square should be created, with each piece occupying its location in the solution. The solid portions of piece #1 should be replaced with `1' characters, of piece #2 with `2' characters, etc. The solutions for each puzzle should be separated by a single blank line.

If there are multiple solutions, any of them is acceptable. For puzzles which have no possible solution simply report ``No solution possible''.

Sample Input

Sample Output

1112
1412
3422
3442

No solution possible

1133
1153
2223
2444

题目大意：在二维平面上放木块拼图，问能用所有的拼图把4×4的平面拼满，注意拼图不能旋转，翻转，而且所有的拼图都要用到。

解析：
我写代码能力太差了，这题做了一整天才完成。直接dfs回溯就行。
直接按照顺序取木块，平移，放入，到取完最后一个木块时，即表示能组成一个满4*4的矩型。
但是请注意所有的木块都要用到，所以当总的面积不等于16时可以不用考虑，因为不可能拼出4×4的平面。

#include <stdio.h>
#include <string.h>
using namespace std;
const int N = 6;

struct Piece{
	int r,c;
	int grid[N][N];
}p[N];

int vis[N][N];
int n;
bool ok;

void init() {
	memset(vis,0,sizeof(vis));
	memset(p,0,sizeof(p));
}

void dfs(int cur) {
	if(cur == n+1) {
		ok = true;
		return ;
	} 
	if(ok) {
		return ;
	}
	for(int i = 0; i <= 4 - p[cur].r; i++) {
		for(int j = 0; j <= 4 - p[cur].c; j++) {
			bool flag = true;
			for(int y = 0; y < p[cur].r; y++) {
				for(int x = 0; x < p[cur].c; x++) {
					if(flag && !vis[i+y][j+x] && p[cur].grid[y][x]) {
						vis[i+y][j+x] = cur;
					}else if(vis[i+y][j+x] && p[cur].grid[y][x]) {
						flag = false;
					}
				}
			}
			if(flag) {
				dfs(cur+1);
			}
			if(ok) {
				return ;
			}
			for(int y = 0; y < 4; y++) {
				for(int x = 0; x < 4; x++) {
					if(vis[y][x] == cur) {
						vis[y][x] = 0;
					}
				}
			}
		}
	}
}

int main() {
	int cas = 0;
	while(scanf("%d",&n) != EOF && n) {
		init();
		int sum = 0;
		for(int i = 1; i <= n; i++) {
			scanf("%d%d",&p[i].r,&p[i].c);
			for(int j = 0; j < p[i].r; j++) {
				for(int k = 0; k < p[i].c; k++) {
					scanf("%1d",&p[i].grid[j][k]);
					sum += p[i].grid[j][k];
				}
			}
		}
		if(cas++) {
			printf("\n");
		}
		ok = false;
		if(sum == 16) {
			dfs(1);
		}
		if(ok) {
			for(int i = 0; i < 4; i++) {
				for(int j = 0; j < 4; j++) {
					printf("%d",vis[i][j]);
				}
				printf("\n");
			}
		}else{
			printf("No solution possible\n");	
		}
	}
	return 0;
}