UVA11846-Finding Seats Again(DFS)

Problem UVA11846-Finding Seats Again

Accept: 69    Submit: 433
Time Limit: 10000 mSec

Problem Description

A set of n2 computer scientists went to the movies. Fortunately, the theater they chose has a square layout: n rows, each one with n seats. However, these scientists are not all from the same research area and they want to seat together. Indeed, there are K independent research groups of scientists among them (no scientist belongs to two of them) with a distiguished leader for each group. Then the leader bought the tickets for his whole group, and he did it in such a way that all his group could seat occupying a rectangular set of seats (and everyone in this set of seats belongs to the same group). Every group was placed satisfying this bizarre condition, although the scientists did not care where the actual assigned areas were. The usher was informed of the situation and he decided to annotate in a theater map a satisfactory seats deploying. He thought that if he wrote the position of each group’s leader in the map indicating besides the corresponding group size, he could tell where to accomodate every scientist. But he discovered that it is not so easy! The usher asks for your help. You must tell him a way to place the K rectangular areas with the given sizes, and with the corresponding leader for each group seated where it was originally assigned.

Input

Input consists of several test cases, each one defined by a set of lines:

• the first line in the case contains two numbers n and K separated by blanks, with n representing the size of the theater (0 < n < 20) and K the number of groups (K ≤ 26);

• the next n lines describe the usher’s map. A one-digit decimal number in the map indicates the seat of a leader and the size of his group. A point indicates that no leader will sit there.
The end of the input is indicated by the line
0 0

 Output

For each test case, display an answer consisting in n lines each one of them with n characters representing a seat occupation for the theater. Each group is assigned to an uppercase letter and all of its members are identified with that letter. No two groups are assigned to the same letter.

 

 Sample Input

3 3
3.4
...
.2.
7 18
...4.2.
...45..
222..3.
...2..3
.24...2
...2.3.
22..3..
0 0

 

 Sample Output

ABB
ABB
ACC
AAAABCC
DDDDBEF
GHIIBEF
GHJKBEF
LLJKBMM
NOJPQQQ
NOJPRRR

题解：这个题还是挺有价值的，看到这个题目，第一时间想到了UVA211的那个多米诺效应那个题，但是这两个题除了题意有点相似之外感觉就没啥相同的了（虽然都是DFS），一开始的思路围绕是数字的格子展开，这个思路在填字母的时候就有很大的困难，这个是数字的格子位于这个矩形的哪里，这个矩形的长宽分别是多少，这两个问题使得这个思路几乎就行不通了。最后参考了大佬的题解（orz），发现他不是从是数字的格子开始扩展，而是直接顺着从没有填过字母的格子开始扩展，扩展的范围很清楚，就是先枚举行，再枚举列，对于枚举中一个给定的矩形，首先这里不能有字母，其次有且仅有一个数字，并且数字的大小等于矩形的面积，满足了这些，就是一个可以继续深层递归的状态，接着dfs下去。这里在枚举的过程中有一个不错的减少枚举的方法，就是如果先枚举行，那么列的最大值随着行的增加一定是不增的（原因很简单，详见代码），这样就可以随时改变列的最大值从而减少枚举。

 #include <bits/stdc++.h>

 using namespace std;

 const int maxn = ;
 const int  INF = 0x3f3f3f3f;

 int n, k;
 char gra[maxn][maxn], ans[maxn][maxn];

 bool dfs(int id, char ch) {
     while (ans[id / n][id % n] != '.') id++;
     if (id == n * n) return true;

     int sr = id / n, sc = id % n, ec = n;
     for (int r = sr; r < n; r++) {
         for (int c = sc; c < ec; c++) {
             if (ans[r][c] != '.') { ec = c; break; }
             int sum = (r - sr + )*(c - sc + );
             int num = INF;
             bool ok = true;
             for (int i = sr; i <= r; i++) {
                 for (int j = sc; j <= c; j++) {
                     if (isdigit(gra[i][j])) {
                         if (num != INF) { ok = false; break; }
                         else num = gra[i][j] - '';
                     }
                 }
                 if (!ok) break;
             }
             if (!ok || sum > num) { ec = c; break; }
             if (sum < num) continue;

             for (int i = sr; i <= r; i++) {
                 for (int j = sc; j <= c; j++) {
                     ans[i][j] = ch;
                 }
             }
             if (dfs(id + c - sc + , ch + )) return true;
             for (int i = sr; i <= r; i++) {
                 for (int j = sc; j <= c; j++) {
                     ans[i][j] = '.';
                 }
             }
         }
     }
     return false;
 }

 int main()
 {
     //freopen("input.txt", "r", stdin);
     while (~scanf("%d%d", &n, &k) && (n || k)) {
         for (int i = ; i < maxn; i++) {
             for (int j = ; j < maxn; j++) {
                 ans[i][j] = '.';
             }
         }
         for (int i = ; i < n; i++) {
             scanf("%s", gra[i]);
         }

         dfs(, 'A');

         for (int i = ; i < n; i++) {
             for (int j = ; j < n; j++) {
                 printf("%c", ans[i][j]);
             }
             printf("\n");
         }
     }
     return ;
 }