POJ 1128 Frame Stacking (拓扑排序)

/*
只能说这题构图太烦了...做了一个多小时。其实就是简单的dfs拓扑排序，然后注意字典序即可。
在输入的时候，记录每一个字母出现的区域，既左上角和右下角坐标（注意这些位置可能会被覆盖，
但是题目说保证能让你计算出每一个字母出现的区域，所以相应地，左上角坐标取的自然是横纵坐标
的最小值，右下角则是最大值。最后构图的时候，如果某字母的区域里出现的不是它自己，则连边，
并记录入度。

208K 16MS 
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

struct node
{
    int sx,sy,ex,ey;
}pt[30];

int deg[30];
bool cnt[30][30];
bool vis[30];
char map[35][35];
int order[35],idx;
int ans[35];

int h,w;

void toposort(int len)
{
    if(len == idx)
    {
        for(int j=0; j<idx; j++)
            printf("%c",ans[j]+'A');
        printf("\n");
        return;
    }
    int i;
    for(i=1; i<=idx; i++)
    {
        if(!vis[order[i]] && !deg[order[i]])
        {
            int t = order[i];
            for(int j=1; j<=idx; j++)
            {
                if(cnt[t][order[j]])
                    --deg[order[j]];
            }
            vis[t] = true;
            ans[len] = order[i];
            toposort(len+1);
            for(int j=1; j<=idx; j++)
            {
                if(cnt[t][order[j]])
                    ++deg[order[j]];
            }
            vis[t] = false;
        }
    }
    return;
}

int main()
{
    while(~scanf("%d%d",&h,&w))
    {
        memset(vis,0,sizeof(vis));
        memset(pt,0,sizeof(pt));
        idx = 0;
        for(int i=1; i<=h; i++)
        {
            for(int j=1; j<=w; j++)
            {
                cin >> map[i][j];
                if(map[i][j] == '.')
                    continue;
                if(!vis[map[i][j]-'A'])
                {
                    vis[map[i][j]-'A'] = true;
                    order[++idx] = map[i][j]-'A';
                }
                if(pt[map[i][j]-'A'].sx == 0)
                    pt[map[i][j]-'A'].sx = i;
                else
                    pt[map[i][j]-'A'].sx = min(i,pt[map[i][j]-'A'].sx);
                if(pt[map[i][j]-'A'].sy == 0)
                    pt[map[i][j]-'A'].sy = j;
                else
                    pt[map[i][j]-'A'].sy = min(j,pt[map[i][j]-'A'].sy);
                if(pt[map[i][j]-'A'].ex == 0)
                    pt[map[i][j]-'A'].ex = i;
                else
                    pt[map[i][j]-'A'].ex = max(i,pt[map[i][j]-'A'].ex);
                if(pt[map[i][j]-'A'].ey == 0)
                    pt[map[i][j]-'A'].ey = j;
                else
                    pt[map[i][j]-'A'].ey = max(j,pt[map[i][j]-'A'].ey);
            }
        }
        sort(order+1,order+1+idx); //保证字典序
        memset(deg,0,sizeof(deg));
        memset(cnt,0,sizeof(cnt));
        for(int i=1; i<=idx; i++)
        {
            int sx = pt[order[i]].sx;
            int sy = pt[order[i]].sy;
            int ex = pt[order[i]].ex;
            int ey = pt[order[i]].ey;
            for(int j=sx; j<=ex; j++)
            {
                if(map[j][sy]-'A'!=order[i] && !cnt[order[i]][map[j][sy]-'A'])
                {
                    cnt[order[i]][map[j][sy]-'A'] = true;
                    deg[map[j][sy]-'A']++;
                }
                if(map[j][ey]-'A'!=order[i] && !cnt[order[i]][map[j][ey]-'A'])
                {
                    cnt[order[i]][map[j][ey]-'A'] = true;
                    deg[map[j][ey]-'A']++;
                }
            }
            for(int j=sy; j<=ey; j++)
            {
                if(map[sx][j]-'A'!=order[i] && !cnt[order[i]][map[sx][j]-'A'])
                {
                    cnt[order[i]][map[sx][j]-'A'] = true;
                    deg[map[sx][j]-'A']++;
                }
                if(map[ex][j]-'A'!=order[i] && !cnt[order[i]][map[ex][j]-'A'])
                {
                    cnt[order[i]][map[ex][j]-'A'] = true;
                    deg[map[ex][j]-'A']++;
                }
            }
        }
        memset(vis,0,sizeof(vis));
        toposort(0);
    }
    return 0;
}