POJ1128-拓扑排序+DFS

题目链接：POJ-1128

看到题应该很容易想到利用拓扑排序来判断相框之间的关系，对于每一个相框，我们遍历一遍可以找到他的 上下左右 四条边的位置，再搜索这几条边上是否有其他字母，有的话就添加一个类似于A<B的关系，为后面进行拓扑排序做准备

然后就是我个人认为的这道题的难点，怎么按照字典序输出所有可能答案，
最开始我想的是利用bfs跑拓扑，确定每个点的层级，再对相同层级的点利用next_permutationh函数进行排列，最后发现可能出现一个点属于多个层级的情况，如下图

此时是无法确定D的层级的

对这道题的正确处理应该是利用dfs来跑拓扑，并记录深度和答案，
当深度等于相框数量时 输出答案 否则将当前节点指向的所有点的度减少1，并再次进行拓扑排序，在调用结束后还需要回溯，将所有减去的点的度加回去，这样就可以输出所有的正确答案

这道题有好几个坑点，稍微列举一下：
（1）给定的相框不一定是5个，可能更多，也可能更少
（2）有多个可能解的时候需要输出所有解，并按照字典序进行排序
（3）多组输入

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <map>
#include <queue>
#include <functional>
#include <vector>
#include <stack>
#include <set>
#include <bitset>
//#define int long long
using namespace std;
typedef long long ll;
const int maxn=2e5+50;
const int inf=0x3f3f3f3f;
const int mod=1e9+7;
const int HASH=131;

string s[40];
vector<int> v[30];
int degree[30]={0};
int vis[30]={0};
int h,w,n;
int cnt[30]={0};
void init()
{
    n=0;
    for(int i=0;i<=26;i++)
    {
        v[i].clear();
        degree[i]=0;
        vis[i]=0;
        cnt[i]=0;
    }
}

char ans[30];

void topsort(int tmp,int depth)
{
    ans[depth]=tmp+'A';

    if(depth==n-1)
    {
        cout<<ans<<endl;
        return;
    }
    cnt[tmp]++;
    for(int i=0;i<v[tmp].size();i++)
    {
        int t=v[tmp][i];
        --degree[t];
    }
    for(int i=0;i<26;i++)
        if(vis[i]&&degree[i]==0&&!cnt[i])
            topsort(i,depth+1);
    for(int i=0;i<v[tmp].size();i++)
    {
        int t=v[tmp][i];
        ++degree[t];
    }
    cnt[tmp]--;
}




int main()
{

    while(scanf("%d %d",&h,&w)!=EOF)
    {
        init();
        for(int i=0;i<h;i++)
            cin>>s[i];
        for(int num=0;num<26;num++)
        {
            char id=num+'A';
            int shang=100,xia=-1,zuo=100,you=-1;
            for(int i=0;i<h;i++)
            {
                for(int j=0;j<w;j++)
                {
                    if(s[i][j]==id)
                    {
                        shang=min(i,shang);
                        xia=max(i,xia);
                        zuo=min(j,zuo);
                        you=max(j,you);
                    }
                }
            }
            if(shang!=100) vis[num]=1;
            for(int i=zuo;i<=you;i++)
            {
                if(s[shang][i]!=id)
                {
                    int id1=id-'A';
                    int id2=s[shang][i]-'A';
                    v[id1].push_back(id2);
                    degree[id2]++;
                }
                if(s[xia][i]!=id)
                {
                    int id1=id-'A';
                    int id2=s[xia][i]-'A';
                    v[id1].push_back(id2);
                    degree[id2]++;
                }
            }
            for(int i=shang;i<=xia;i++)
            {
                if(s[i][zuo]!=id)
                {
                    int id1=id-'A';
                    int id2=s[i][zuo]-'A';
                    v[id1].push_back(id2);
                    degree[id2]++;
                }
                if(s[i][you]!=id)
                {
                    int id1=id-'A';
                    int id2=s[i][you]-'A';
                    v[id1].push_back(id2);
                    degree[id2]++;
                }
            }
        }
        for(int i=0;i<26;i++)
            if(vis[i]) n++;
        ans[n]='\0';
        for(int i=0;i<26;i++)
        {
            if(vis[i]&&degree[i]==0)
            topsort(i,0);
        }
    }
    return 0;
}