Southern African 2001 框架折叠 (拓扑序列的应用)

#include <stdio.h>  
#include <string.h>  
#include <iostream>  
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;  

const int MAXN = 26; //最多26个字母
char Gra[MAXN][MAXN];//存储初始图
int head[MAXN + 7];//用链式前向星存建立起来的图中
int flag[MAXN + 7][MAXN + 7];//flag[i][j]用于判断i 和 j 之间是否有边，用于忽略掉重复边
int h, w;//高h ， 宽 w
int N; //图中一共有 N 个点
int e;  //图中一共有 e 条边

struct Map{ //把初始图先转为u v 之间存在的边，再转为链式前向星
    int u;
    int v;
}map[MAXN * MAXN + 7]; 

typedef struct EdgeNode{//链式前向星
    int to;
    int next;
}edgeNode;
edgeNode Edges[MAXN * MAXN + 7];

typedef struct Point{//坐标
    int x;
    int y;
}point;

typedef struct Photo{//照片的位置
    point leftUp;//左上角
    point rightDown;//右下角
}photos;
photos pht[MAXN + 7];

int getN()//由初始图获得节点的个数
{
    int has[27] ={0};
    for(int i = 1; i <= h; i++)
        for(int j = 1; j <= w; j++)
            if(Gra[i][j] != ‘.‘)
                has[ Gra[i][j] - ‘A‘ ]++;    
    int n = 0;
    for(int i = 0; i <= 26; i++)
        if(has[i] != 0)
            n++;
    return n;
}

void getXY()//由初始图获得每个照片的两个对角坐标
{
    for(int i = 1; i <= h; i++)
    {
        for(int j = 1; j <= w; j++)
        {
            for(int k = 1; k <= N; k++)
            {
                if(Gra[i][j] != ‘.‘ && Gra[i][j] == k + ‘A‘ - 1)
                {
                    //cout << "*" << i << " " << j <<"*"<<endl;
                    pht[k].leftUp.x = min( pht[k].leftUp.x, i);
                    pht[k].leftUp.y = min( pht[k].leftUp.y, j);
                    pht[k].rightDown.x = max( pht[k].rightDown.x, i);
                    pht[k].rightDown.y = max( pht[k].rightDown.y, j);
                }
            }
        }
    }
}

void initPht()//初始化对角坐标
{
    for(int i = 0; i <= N; i++)
    {
        pht[i].leftUp.x = h + 1;
        pht[i].leftUp.y = w + 1;
        pht[i].rightDown.x = -1;
        pht[i].rightDown.y = -1;
    }
}

void buidEdge(photos pht, int m)//由初始图建立起来的一个基本图
{
    int go;
    go = pht.leftUp.y;
    //cout << pht.leftUp.x << " " << pht.leftUp.y<<"     " << pht.rightDown.x <<" "<< pht.rightDown.y<<endl;
    while( go <= pht.rightDown.y)//横向遍历
    {
        //如果不是‘.‘，且不是本身，且之间尚未有边那么就建立起边
        if( Gra[pht.leftUp.x][go] != ‘.‘ && Gra[pht.leftUp.x][go] != m + ‘A‘ - 1 && flag[Gra[pht.leftUp.x][go] - ‘A‘ + 1][m] != 1)
        {
            //cout << pht.leftUp.x << " ^ " << go << endl;
            ++e;
            flag[Gra[pht.leftUp.x][go] - ‘A‘ + 1][m] = 1;
            map[e].v = Gra[pht.leftUp.x][go] - ‘A‘ + 1;
            map[e].u = m;
        }
        if( Gra[pht.rightDown.x][go] != ‘.‘ && Gra[pht.rightDown.x][go] != m + ‘A‘ - 1 && flag[Gra[ pht.rightDown.x][go] - ‘A‘ + 1][m] != 1)
        {
            ++e;
            flag[Gra[ pht.rightDown.x][go] - ‘A‘ + 1][m] = 1;
            map[e].v = Gra[pht.rightDown.x][go] - ‘A‘ + 1;
            map[e].u = m;
        }
        go++;
    }
    go = pht.leftUp.x;
    while( go <= pht.rightDown.x)//纵向遍历
    {
        if( Gra[go][pht.rightDown.y] != ‘.‘ && Gra[go][pht.rightDown.y] != m + ‘A‘ - 1 && flag[Gra[go][pht.rightDown.y] - ‘A‘ + 1][m] != 1)
        {
            ++e;
            flag[Gra[go][pht.rightDown.y] - ‘A‘ + 1][m] = 1;
            map[e].v = Gra[go][pht.rightDown.y] - ‘A‘ + 1;
            map[e].u = m;
        }
        if( Gra[go][pht.leftUp.y] != ‘.‘ && Gra[go][pht.leftUp.y] != m + ‘A‘ - 1 && flag[Gra[go][pht.leftUp.y] - ‘A‘ + 1][m] != 1)
        {
            ++e;
            flag[Gra[go][pht.leftUp.y] - ‘A‘ + 1][m] = 1;
            map[e].v = Gra[go][pht.leftUp.y] - ‘A‘ + 1;
            map[e].u = m;
        }
        go++;
    }
}

int vis[MAXN + 7];
int indegree[MAXN + 7];

void getIdg(int vis[])//获得每个点的入度
{
    memset(indegree, 0, sizeof(indegree));
    for(int i = 1;i <= N; i++)
    {
        if(!vis[i])
        {
            for(int j = head[i]; j != -1; j = Edges[j].next)
            {
                indegree[Edges[j].to ] ++;
            }
        }
    }
}

int allVis()//每个点都被删了
{
    for(int i = 1; i <= N; i++)
        if(!vis[i])return 0;
    return 1;
}

void DFS(int head[], int vis[], queue<int> Qu)
{
    queue<int> q;
    getIdg(vis);
    for(int i = 1; i <= N; i++) //每次把入度为 0 的点入到队列中
    if(!vis[i] && !indegree[i]) q.push(i);
    while(!q.empty())
    {
        int v = q.front();
        q.pop();
        queue<int> cpyQu(Qu);//复制Qu的副本并把 点 v 加入到Qu的副本中
        cpyQu.push(v);
        vis[v] = 1;        //删除已被访问到的点
        int t = head[v];    
        head[v] = 1;    //删除从这个点出发的全部有向边
        if(allVis())    //如果图为空
        {
            while(!cpyQu.empty())
            {
                cout <<(char) (cpyQu.front() + ‘A‘ - 1) ;
                cpyQu.pop();
            }
            cout << endl;
        }
        else//继续递归剩下的图，
            DFS(head, vis, cpyQu);
        vis[v] = 0;//恢复现场
        head[v] = t;
    }
}

int main() 
{
    freopen("in.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    while(~scanf("%d%d", &h, &w) && (h || w))
    {
        memset(Gra, 0, sizeof(Gra));
        for(int i = 1; i <= h; i++)
            scanf("%s",Gra[i] + 1);
        N = getN();//获得N
        initPht();//初始化图片对角的位置
        getXY();//获得图片对角的位置
        e = 0;
        memset(flag, 0, sizeof(flag));
        for(int i = 1; i <= N; i++)//建立基本图
            buidEdge(pht[i], i);
        memset(head, -1, sizeof(head));
        memset(&Edges, 0, sizeof(EdgeNode));
        memset(&pht, 0, sizeof(Photo));
        for(int i = 1; i <= e; i++)//根据基本图建立链式前向星的存图结构
        {
            Edges[i].to = map[i].v;
            Edges[i].next = head[map[i].u];
            head[map[i].u] = i; 
        }
        memset(vis, 0, sizeof(vis));
        queue<int> qu;
        DFS(head, vis, qu);//head 用于删除图的边,vis删除边,qu是每次的拓扑序列
    }
    return 0;
}