【POJ 2585】Window Pains 拓扑排序

Description

. . . and so on . . . 
Unfortunately, Boudreaux's computer is very unreliable and crashes often. He could easily tell if a crash occurred by looking at the windows and seeing a graphical representation that should not occur if windows were being brought to the foreground correctly. And this is where you come in . . .

Input

Input to this problem will consist of a (non-empty) series of up to 100 data sets. Each data set will be formatted according to the following description, and there will be no blank lines separating data sets. 

A single data set has 3 components: 

1. Start line - A single line: 
   START 
   
   
2. Screen Shot - Four lines that represent the current graphical representation of the windows on Boudreaux's screen. Each position in this 4 x 4 matrix will represent the current piece of window showing in each square. To make input easier, the list of numbers on each line will be delimited by a single space. 
3. End line - A single line: 
   END 

After the last data set, there will be a single line: 
ENDOFINPUT 

Note that each piece of visible window will appear only in screen areas where the window could appear when brought to the front. For instance, a 1 can only appear in the top left quadrant.

Output

For each data set, there will be exactly one line of output. If there exists a sequence of bringing windows to the foreground that would result in the graphical representation of the windows on Boudreaux's screen, the output will be a single line with the statement: 

THESE WINDOWS ARE CLEAN 

Otherwise, the output will be a single line with the statement: 
THESE WINDOWS ARE BROKEN 

Sample Input

START
1 2 3 3
4 5 6 6
7 8 9 9
7 8 9 9
END
START
1 1 3 3
4 1 3 3
7 7 9 9
7 7 9 9
END
ENDOFINPUT

Sample Output

THESE WINDOWS ARE CLEAN
THESE WINDOWS ARE BROKEN
-----------------------------------------------------------------------------
最早想到的是dfs 从最上面一层倒着往回推，但最后没法记录点了.....

其实就是个拓扑排序的水题.....
主要是建边：枚举9个炮台，如果在自己射程区域内不是自己，说明被覆盖，因此说明这个颜色是当前颜色的先决条件，
于是连一条边。（开始理解为只要不是自己就连边，结果根本没有入度为0的边23333
然后跑一遍拓扑排序，如果没成环就成功了，成环就失败。
这是代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#define N 20
using namespace std;
struct node
{
    int u,v,nxt;
}e[N*2];
int first[N],cnt;
void ade(int u,int v)
{
    e[++cnt].nxt=first[u]; first[u]=cnt;
    e[cnt].u=u; e[cnt].v=v;
}
int ru[N],cnnt;
int dir[4][2]= {0,0, 1,0, 0,1, 1,1};
int local[10][2]= {-1,-1, 0,0, 0,1, 0,2, 1,0, 1,1, 1,2, 2,0, 2,1, 2,2};
void topsort()
{
    priority_queue<int>q;
    for(int i=1;i<=9;i++)
        if(ru[i]==0) q.push(i);
    while(!q.empty())
    { 
        int x=q.top(); q.pop();
        ++cnnt;
    //    cout<<cnnt<<" ";
        for(int i=first[x];i;i=e[i].nxt)
        {
            int v=e[i].v;
            ru[v]--;
            if(ru[v]==0) q.push(v);
        }
    }    
    if(cnnt!=9) printf("THESE WINDOWS ARE BROKEN\n");
    else cout<<"THESE WINDOWS ARE CLEAN"<<endl;
}
int a[5][5];
bool vis[N][N];
int main()
{
    char str[20];
    while(scanf("%s",str),strcmp(str,"ENDOFINPUT"))
    {
        for(int i=0;i<4;i++)
            for(int j=0;j<4;j++)
                scanf("%d",&a[i][j]);
        scanf("%s",str);
        memset(e,0,sizeof(e)); 
        memset(vis,0,sizeof(vis));
        memset(first,0,sizeof(first));
        memset(ru,0,sizeof(ru));
        cnt=cnnt=0;
        for(int k=1;k<=9;k++)
            for(int i=0;i<4;i++)//在自己射程区域内不是自己->被覆盖 
            {
                int x=local[k][0]+dir[i][0];
                int y=local[k][1]+dir[i][1];
                int now=a[x][y];
                if(k!=now&&!vis[k][now])
                {
                    vis[k][now]=1;
                    ade(k,now);
                    ru[now]++;
                }
            }
        topsort();
    } 
    return 0;
}