POJ 1128 Frame Stacking

/*

http://acm.pku.edu.cn/JudgeOnline/problem?id=1128

DFS回溯实现拓扑排序
*/

#include <iostream>
#include <memory>
#include <string>
#include <algorithm>
#define MAX_N 32
#define MAX_L 26
using namespace std;

char mapv[MAX_N + 1][MAX_N + 1];  //记录输入
char letter[MAX_L + 1];           //记录输入中输出的字母c, C - 'A' + 1
bool graph[MAX_L + 1][MAX_L + 1]; //graph[i][j] = true, 表示i frame 排在 j frame的上面
int rowN, colN, lNum, resNum;     //输入的行数，列数，lnum表述输入中出现的字母的类别数，resNum记录输出的结果数目
int pos[MAX_L + 1][4];            //记录各个字母上下左右的Index, 从1开始记录

bool v[MAX_L + 1];
//记录结果
struct node
{
    string seq;
    node()
    {
        seq = "";
    }
}res[200]; //从0开始存

void init()
{
    resNum = lNum = 0;
    memset(pos, 0, sizeof(pos));
    memset(graph, 0, sizeof(graph));
}

bool compare(const node n1, const node n2)
{
    if(n1.seq <= n2.seq)
        return true;
    return false;
}
void topSort(int layer, string seqStr)
{
    //排完了，每排一个字母，layer + 1， 直到排完所有的字母
    if(layer > lNum)
    {
        //记录结果
        res[resNum++].seq = seqStr;
        return;
    }
    int minCom = INT_MAX, s, k, curL, curCom;
    int minNum = 0;
    //向temp这类数据必须使用局部数据，应为没一层的temp必须不能受其他层影响，
    //一开把temp设成了全局的，这样进入下一层后，下一层可能会修改上面层的temp，从而产生错误结果
    int temp[MAX_L + 1];

    //寻找入度最小的点，这个点对应的frame应该是放在最上面的frame(可能不唯一，所以会产生多个结果)
    for(s = 0; s < lNum; s++)
    {
        //当前结点是上面已经处理过已经被抹去的点
        if(letter[s] == '.')
            continue;
        curCom = 0;
        curL = letter[s] - 'A' + 1;
        for(k = 1; k <= MAX_L; k++)
            if(graph[k][curL])
                curCom++;
        //找到更小入度的点
        if(curCom < minCom)
        {
            minCom = curCom;
            minNum = 1;
            temp[minNum] = curL; //temp 从1开始存
        }
        //和最小度数相等，则记录，并使minNum + 1
        else if(curCom == minCom)
        {
            temp[++minNum] = curL;
        }
    }
    //回溯遍历所有的当前入度最小的点
    seqStr = "." + seqStr;
    for(s = 1; s <= minNum; s++)
    {
        curL = temp[s];
        //copyR和copyC也必须是局部数，原因和temp相同
        bool copyR[MAX_L + 1], copyC[MAX_L + 1];
        memset(copyR, 0, sizeof(copyR));
        memset(copyC, 0, sizeof(copyC));
        //保存当前节点对应的数据，并置位
        for(k = 1; k <= MAX_L; k++)
        {
            copyR[k] = graph[curL][k];
            copyC[k] = graph[k][curL];
            graph[curL][k] = graph[k][curL] = false;
        }
        seqStr[0] = curL - 1 + 'A';

        //已经处理过的节点要摸去
        int tempPos;
        for(k = 0; k < lNum; k++)
        {
            if(letter[k] == curL - 1 + 'A')
            {
                tempPos = k;
                letter[k] = '.';
                break;
            }
        }
        //dfs
        topSort(layer + 1, seqStr);
        //恢复相关数据
        letter[tempPos] = curL - 1 + 'A';
        for(k = 1; k <= MAX_L; k++)
        {
            graph[curL][k] = copyR[k];
            graph[k][curL] = copyC[k];
        }
    }
}
int main()
{
    int i, j, k;
    char c, cc;
    while(cin>>rowN)
    {
        cin>>colN;
        //input process
        init();
        for(i = 1; i <= rowN; i++)
        {
            for(j = 1; j <= colN; j++)
            {
                cin>>c;
                mapv[i][j] = c;
                if(c >= 'A' && c <= 'Z')
                {
                    for(k = 0; k < lNum; k++)
                        if(letter[k] == c)
                            break;
                    if(k >= lNum)
                        letter[lNum++] = c;
                }
            }
        }
        ///////////寻找每个frame最上方和最下方的行号，已经最左边和最右边的列号
        int s, p0, p1, p2, t, curL;
        //扫描行
        for(i = 1; i <= rowN; i++)
        {
            //扫描任意列
            for(j = 1; j <= colN; j++)
            {
                c = mapv[i][j];
                cc = mapv[rowN - i + 1][j];
                if(c >= 'A' && c <= 'Z')
                {
                    if(pos[c - 'A' + 1][0] == 0)
                        pos[c - 'A' + 1][0] = i;
                }
                if(cc >= 'A' && cc <= 'Z')
                {
                    if(pos[cc - 'A' + 1][1] == 0)
                        pos[cc - 'A' + 1][1] = rowN - i + 1;
                }
            }
        }
        //列扫描
        for(i = 1; i <= colN; i++)
        {
            //扫描任意行
            for(j = 1; j <= rowN; j++)
            {
                c = mapv[j][i];
                cc = mapv[j][colN - i + 1];
                if(c >= 'A' && c <= 'Z')
                {
                    if(pos[c - 'A' + 1][2] == 0)
                        pos[c - 'A' + 1][2] = i;
                }
                if(cc >= 'A' && cc <= 'Z')
                {
                    if(pos[cc - 'A' + 1][3] == 0)
                        pos[cc - 'A' + 1][3] = colN - i + 1;
                }
            }
        }
        ///////////顺次处理每个节点s,如果在s的四条边线中夹杂有其他节点t，那么表示
        //t遮住了s, graph[t][s] 设置为true
        for(s = 0; s < lNum; s++)
        {
            curL = letter[s] - 'A' + 1;
            memset(v, 0, sizeof(v));

            for(i = 0; i < 4; i++)
            {
                p0 = pos[curL][i];
                int j = ((int(i / 2) + 1) * 2) % 4;
                p1 = pos[curL][j];
                p2 = pos[curL][j + 1];

                for(t = p1; t <= p2; t ++)
                {
                    if(i <= 1)
                    {
                        if(mapv[p0][t] == letter[s])
                            continue;
                        if(v[mapv[p0][t] - 'A' + 1])
                            continue;
                        if(!(mapv[p0][t] >= 'A' && mapv[p0][t] <= 'Z'))
                            continue;
                        v[mapv[p0][t] - 'A' + 1] = true;
                        graph[mapv[p0][t] - 'A' + 1][curL] = true;
                    }
                    else
                    {
                        if(mapv[t][p0] == letter[s])
                            continue;
                        if(v[mapv[t][p0] - 'A' + 1])
                            continue;
                        if(!(mapv[t][p0] >= 'A' && mapv[t][p0] <= 'Z'))
                            continue;
                        v[mapv[t][p0] - 'A' + 1] = true;
                        graph[mapv[t][p0] - 'A' + 1][curL] = true;
                    }
                }
               
            }
        }
        string str = "";
        topSort(1, str);
        sort(res, res + resNum, compare);
        for(i = 0; i < resNum; i++)
            cout<<res[i].seq<<endl;
        /////////////////
    }
    return 0;
}