uva 387 A Puzzling Problem （回溯)

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

4
2 3
111
101
4 2
01
01
11
01
2 1
1
1
3 2
10
10
11
4
1 4
1111
1 4
1111
1 4
1111
2 3
111
001
5
2 2
11
11
2 3
111
100
3 2
11
01
01
1 3
111
1 1
1
0

Sample Output

1112
1412
3422
3442

No solution possible

1133
1153
2223
2444

题目大意：给出一些积木，要求将积木全部使用后拼成一个4*4的正方形。

解题思路：这题思路很简单，将所有积木以数组的形式储存起来，然后在4*4的地图上逐一去判断。主要注意也就三点。

1：积木的表示方法，我是使用结构体去存的，只要记录下面的所有木块与第一个木块的关系就可以了。

2：放入木块前先判断放入木块是否会越界重叠的问题后再放入。

3：如果当前位置没有合适的积木可以放的话可以直接回溯了，因为题目要求是不能旋转（这点最关键，需要空间想象力好的才能理解）

一不小心跑进uva rank 10，唉，小开心一下。

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define N 20
const int R = 4;

int n, vis[R][R], rec[N];
struct sque{
    int dir[N][2];
    int cnt;
}b[N];

void get_block(int cur){
    int r, c, t, ok = 0, p, q;
    char str[N];
    scanf("%d%d", &r, &c);
    for (int i = 0; i < r; i++){
	scanf("%s", str);
	for (int j = 0; j < c; j++){
	    if (str[j] - '0'){
		if (ok){
		    b[cur].dir[b[cur].cnt][0] = i - p;
		    b[cur].dir[b[cur].cnt][1] = j - q;
		    b[cur].cnt++;
		}
		else{
		    b[cur].dir[b[cur].cnt][0] = 0;
		    b[cur].dir[b[cur].cnt][1] = 0;
		    p = i;
		    q = j;
		    b[cur].cnt++;
		    ok = 1;
		}
	    }
	}
    }
}

bool judge(int x, int y, int cur){
    for (int i = 0; i < b[cur].cnt; i++){
	if (x + b[cur].dir[i][0] < 0 || x + b[cur].dir[i][0] >= 4)
	    return false;
	if (y + b[cur].dir[i][1] < 0 || y + b[cur].dir[i][1] >= 4)
	    return false;
	if (vis[x + b[cur].dir[i][0]][y + b[cur].dir[i][1]])
	    return false;
    }
    return true;
}

bool dfs(int x, int y, int sum, int k){
    if (sum == 16){
	if (k == n)
	    return true;
	else
	    return false;
    }

    if (x == 4)
	return false;
    if (vis[x][y]){
	if (y == 3){
	    if (dfs(x + 1, 0, sum, k))
		return true;
	}
	else{
	    if (dfs(x, y + 1, sum, k))
		return true;
	}
	return false;
    }

    for (int i = 1; i <= n; i++){
	if (rec[i]) continue;
	if (judge(x, y, i)){
	    rec[i] = 1;
	    for (int j = 0; j < b[i].cnt; j++)
		vis[x + b[i].dir[j][0]][y + b[i].dir[j][1]] = i;

	    if (y == 3){
		if (dfs(x + 1, 0, sum + b[i].cnt, k + 1))
		    return true;
	    }
	    else{
		if (dfs(x, y + 1, sum + b[i].cnt, k + 1))
		    return true;
	    }

	    rec[i] = 0;
	    for (int j = 0; j < b[i].cnt; j++)
		vis[x + b[i].dir[j][0]][y + b[i].dir[j][1]] = 0;
	}
    }
    return false;
}

int main(){
    int text = 0;
    while (scanf("%d", &n), n){
	if (text++)
	    printf("\n");
	// Init;
	memset(b, 0, sizeof(b));
	memset(vis, 0, sizeof(vis));
	memset(rec, 0, sizeof(rec));

	// Read;
	for (int i = 1; i <= n; i++)
	    get_block(i);

	if(dfs(0, 0, 0, 0)){
	    for (int i = 0; i < R; i++){
		for (int j = 0; j < R; j++)
		    printf("%d", vis[i][j]);
		printf("\n");
	    }
	}
	else
	    printf("No solution possible\n");
    }
    return 0;
}