【USACO4.4.3】重叠的图像（DAG图的拓扑排序）

【问题描述】

　　看下面的五张 9 x 8 的图像：
　　　　
　　现在，把这些图像按照 1—5 的编号从下到上重叠，第 1 张在最下面，第 5 张在最顶端。如果一张图像覆盖了另外一张图像，那么底下的图像的一部分就变得不可见了。我们得到下面的图像：
　　　　　　　　　　　　
　　对于这样一张图像，计算构成这张图像的矩形图像从底部到顶端堆叠的顺序。

　　下面是这道题目的规则：

　　1）、矩形的边的宽度为 1 ，每条边的长度都不小于 3 。
　　2）、矩形的每条边中，至少有一部分是可见的。注意，一个角同时属于两条边。
　　3）、矩形用大写字母表示，并且每个矩形的表示符号都不相同。

【输入格式】

第一行 两个用空格分开的整数：图像高 H 和图像宽 W 。
第二行到第 H+1 行 H 行，每行 W 个字母。

【输出格式】

按照自底向上的顺序输出字母。如果有不止一种情况，按照字典顺序输出每一种情况（至少会有一种合法的顺序）。

【输入样例】

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

【输出样例】

EDABC

【数据范围】

3 <= H <=30
3 <= W <= 30

找到每个矩阵方框的四个顶点，遍历每一条边上的字母，构建一个DAG图，然后DFS按字典序输出所有的拓扑排序。

#include<cstdlib>
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
#include<queue>
#define maxn 1005
#define oo 200
using namespace std;
int n,m,t=0;
int rd[maxn]={0};
vector<int>g[maxn];
char a[maxn][maxn],c[maxn*2];
int sx[oo],sy[oo],lx[oo]={0},ly[oo]={0};
bool ok,vis[oo]={0},v[oo]={0},f[oo][oo]={0};

void fuck(int x)
{
    if(x>t)
    {
        for(int i=1;i<x;i++) printf("%c",c[i]);
        printf("\n");
        return;
    }

    for(int i='A';i<='Z';i++) if(!rd[i]&&v[i])
    {
        c[x]=i;
        for(int k=0;k<g[i].size();k++) rd[g[i][k]]--;
        v[i]=false;
        fuck(x+1);
        for(int k=0;k<g[i].size();k++) rd[g[i][k]]++;
        v[i]=true;
    }
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    for(int i=0;i<oo;i++) sx[i]=sy[i]=oo;

    scanf("%d%d\n",&n,&m);
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    {
        cin>>a[i][j];
        if(a[i][j]=='.') continue;
        vis[a[i][j]]=v[a[i][j]]=1;
        sx[a[i][j]]=min(sx[a[i][j]],i);
        sy[a[i][j]]=min(sy[a[i][j]],j);
        lx[a[i][j]]=max(lx[a[i][j]],i);
        ly[a[i][j]]=max(ly[a[i][j]],j);
    }

    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++) if(vis[a[i][j]])
    {
        vis[a[i][j]]=0;//标记
        t++;//统计字母数
        int k=a[i][j];
        //开始痛苦的查找构图，其实可以避免循环，用矩形的顶点计算
        for(int t=sy[k];t<=ly[k];t++) 
        if(a[sx[k]][t]!=k&&!f[k][a[sx[k]][t]])
        g[k].push_back(a[sx[k]][t]),rd[a[sx[k]][t]]++,f[k][a[sx[k]][t]]=1;

        for(int t=sy[k];t<=ly[k];t++)
        if(a[lx[k]][t]!=k&&!f[k][a[lx[k]][t]])
        g[k].push_back(a[lx[k]][t]),rd[a[lx[k]][t]]++,f[k][a[lx[k]][t]]=1;  

        for(int t=sx[k];t<=lx[k];t++)
        if(a[t][sy[k]]!=k&&!f[k][a[t][sy[k]]]) 
        g[k].push_back(a[t][sy[k]]),rd[a[t][sy[k]]]++,f[k][a[t][sy[k]]]=1;

        for(int t=sx[k];t<=lx[k];t++)
        if(a[t][ly[k]]!=k&&!f[k][a[t][ly[k]]]) 
        g[k].push_back(a[t][ly[k]]),rd[a[t][ly[k]]]++,f[k][a[t][ly[k]]]=1;
    }

    fuck(1);

    return 0;
}