poj 1128 Frame Stacking（DFS+拓扑排序）

Frame Stacking

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 3772		Accepted: 1251

Description

Consider the following 5 picture frames placed on an 9 x 8 array.

........ ........ ........ ........ .CCC....

EEEEEE.. ........ ........ ..BBBB.. .C.C....

E....E.. DDDDDD.. ........ ..B..B.. .C.C....

E....E.. D....D.. ........ ..B..B.. .CCC....

E....E.. D....D.. ....AAAA ..B..B.. ........

E....E.. D....D.. ....A..A ..BBBB.. ........

E....E.. DDDDDD.. ....A..A ........ ........

E....E.. ........ ....AAAA ........ ........

EEEEEE.. ........ ........ ........ ........

    1        2        3        4        5   

Now place them on top of one another starting with 1 at the bottom and ending up with 5 on top. If any part of a frame covers another it hides that part of the frame below.

Viewing the stack of 5 frames we see the following.

.CCC....

ECBCBB..

DCBCDB..

DCCC.B..

D.B.ABAA

D.BBBB.A

DDDDAD.A

E...AAAA

EEEEEE..

In what order are the frames stacked from bottom to top? The answer is EDABC.

Your problem is to determine the order in which the frames are stacked from bottom to top given a picture of the stacked frames. Here are the rules:

1. The width of the frame is always exactly 1 character and the sides are never shorter than 3 characters.

2. It is possible to see at least one part of each of the four sides of a frame. A corner shows two sides.

3. The frames will be lettered with capital letters, and no two frames will be assigned the same letter.

Input

Each input block contains the height, h (h<=30) on the first line and the width w (w<=30) on the second. A picture of the stacked frames is then given as h strings with w characters each.
Your input may contain multiple blocks of the format described above, without any blank lines in between. All blocks in the input must be processed sequentially.

Output

Write the solution to the standard output. Give the letters of the frames in the order they were stacked from bottom to top. If there are multiple possibilities for an ordering, list all such possibilities in alphabetical order, each one on a separate line. There will always be at least one legal ordering for each input block. List the output for all blocks in the input sequentially, without any blank lines (not even between blocks).

Sample Input

9
8
.CCC....
ECBCBB..
DCBCDB..
DCCC.B..
D.B.ABAA
D.BBBB.A
DDDDAD.A
E...AAAA
EEEEEE..

Sample Output

EDABC

题意：给出一个矩阵，这个矩阵是其他不同的矩阵从底向上堆叠而成，每个不同的矩阵里都有一个矩形相框，相框由相同的字符组成，每个矩阵的字符都不相同。矩阵堆叠时，一个字符能覆盖另一个字符。要根据最终的堆叠结果求出矩阵的堆叠顺序，按字典序输出全部解。

思路：先求出每个相框的边界，然后根据这个边界就能得出这个相框的字符被哪些字符覆盖，这样就可以建边了。建完边以后进行拓扑排序，因为要输出所有解，所以用dfs作类似全排列的输出。

AC代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdlib>
#define L(rt) (rt<<1)
#define R(rt) (rt<<1|1)
#define ll long long
#define eps 1e-6
using namespace std;

const int maxn=35;

int n,m,cnt;
char map[maxn][maxn];
int in[maxn],ltx[maxn],lty[maxn],rbx[maxn],rby[maxn];
bool vis[maxn],G[maxn][maxn];
char ans[maxn];
void getbound()
{
    memset(ltx,0x3f,sizeof(ltx));
    memset(lty,0x3f,sizeof(lty));
    memset(rbx,-1,sizeof(rbx));
    memset(rby,-1,sizeof(rby));
    for(int i=0;i<n;i++)
    for(int j=0;j<m;j++)
    {
        if(map[i][j]=='.') continue;
        int t=map[i][j]-'A';
        ltx[t]=min(ltx[t],i);
        lty[t]=min(lty[t],j);
        rbx[t]=max(rbx[t],i);
        rby[t]=max(rby[t],j);
    }
}
void build()
{
    memset(in,0,sizeof(in));
    memset(G,false,sizeof(G));
    cnt=0;
    for(int k=0;k<26;k++)
    {
        if(rbx[k]==-1) continue;
        cnt++;
        for(int i=ltx[k];i<=rbx[k];i++)
        for(int j=lty[k];j<=rby[k];j++)
        {
            if(i>ltx[k]&&i<rbx[k]&&j>lty[k]&&j<rby[k]) continue;
            if(map[i][j]=='.') continue;
            int t=map[i][j]-'A';
            if(!G[k][t]&&k!=t)
            {
                G[k][t]=true;
                in[t]++;
            }
        }
    }
}
void dfs(char *s,int num)
{
    if(num==cnt)
    {
        puts(s);
        return;
    }
    for(int k=0;k<26;k++)
    {
        if(rbx[k]==-1) continue;
        if(vis[k]) continue;
        if(!in[k])
        {
            vis[k]=true;
            for(int i=0;i<26;i++)
            if(G[k][i]) in[i]--;
            s[num]=k+'A';
            dfs(s,num+1);
            vis[k]=false;
            for(int i=0;i<26;i++)
            if(G[k][i]) in[i]++;
        }
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0;i<n;i++)
        scanf("%s",map[i]);
        getbound();
        build();
        memset(ans,0,sizeof(ans));
        memset(vis,false,sizeof(vis));
        dfs(ans,0);
    }
    return 0;
}