Window Pains-POJ2585

Window Pains
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 1952 Accepted: 980

Description
Boudreaux likes to multitask, especially when it comes to using his computer. Never satisfied with just running one application at a time, he usually runs nine applications, each in its own window. Due to limited screen real estate, he overlaps these windows and brings whatever window he currently needs to work with to the foreground. If his screen were a 4 x 4 grid of squares, each of Boudreaux’s windows would be represented by the following 2 x 2 windows:

When Boudreaux brings a window to the foreground, all of its squares come to the top, overlapping any squares it shares with other windows. For example, if window 1and then window 2 were brought to the foreground, the resulting representation would be:

… 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

Source
South Central USA 2003

问题描述：
给你一个4*4的表格，1~9可以显示在对应的4个位子上。问是否可以通过某种点击顺序使最终屏幕上的显示如输入所示。
分析：
这个问题可以转换为Top序列问题。首先记录每个格子可以被那些数覆盖，那么最终屏幕上显示的数i必然覆盖了其他的所有的数j，即相当于存在i->j的一条有向边。若果最终这个图没有环则说明可以，否则不行（存在相互覆盖的情况）

AC代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <string>
#include <algorithm>
using namespace std;

const int n=4;
int scream[4][4];      //屏幕最终显示
string cover[4][4];    //能覆盖[i][j]位置集合
bool exist[10];        //记录i是否出现在最终屏幕上。（只用考虑出现的，没有出现的一定不会产生矛盾）
int id[10];            //入度    
bool g[10][10];        //判断i->j是否已经存在（处理重边）
int t;                 //记录有多少个点出现在屏幕上
string s;

void calc()
{
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            cover[i][j].erase();
    for(int k=1;k<=9;k++)
    {
        int i=(k-1)/3;
        int j=(k-1)%3;
        //k能覆盖的4个位置
        cover[i][j]+=char(k+'0');
        cover[i][j+1]+=char(k+'0');
        cover[i+1][j]+=char(k+'0');
        cover[i+1][j+1]+=char(k+'0');
    }
}

void init_()
{
    int i,j,k;
    memset(exist,0,sizeof(exist));
    memset(g,0,sizeof(g));
    memset(id,0,sizeof(id));
    t=0;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            scanf("%d",&k);
            scream[i][j]=k;
            if(!exist[k]) t++;
            exist[k]=true;
        }
    }
}

void build()
{
    int i,j,p;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            for(p=0;p<cover[i][j].length();p++)
            {
                if(!g[scream[i][j]][cover[i][j][p]-'0'] && (cover[i][j][p]-'0'!=scream[i][j]))
                {
                    g[scream[i][j]][cover[i][j][p]-'0']=true;
                    id[cover[i][j][p]-'0']++;
                }
            }
        }
    }
}

bool check()
{
    int i,j,k;
    for(k=0;k<t;k++)//每次只处理一个，所以要处理t次
    {
        i=1;
        while(!exist[i] || (i<=9 && id[i]>0))//找出第一个出现且入度为0的i.
            i++;
        if(i>9)
            return false;
        exist[i]=false;
        for(j=1;j<=9;j++)
        {
            if(exist[j] && g[i][j])
                id[j]--;
        }
    }
    return true;
}

int main()
{
    calc();
    while(cin>>s)
    {
        if(s=="ENDOFINPUT") break;
        init_();
        build();
        if(check())
            printf("THESE WINDOWS ARE CLEAN\n");
        else
            printf("THESE WINDOWS ARE BROKEN\n");
        cin>>s;
    }
    return 0;
}