Window Pains POJ 2585

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

题意：给出可覆盖的九个窗口，1-9数字表示窗口种类，每个窗口占固定的四个格子，判断窗口的覆盖方式是否合法。分析：窗口的覆盖可以看成是有向的覆盖方式，即窗口可视为点的指向，那么这样一来，就成了有向图，有向图中无环即合法，有环即不合法，拓扑排序判环即可。

拓扑排序核心算法：1.建图，读取每个点的入度，出度，及出度的方向。（指向的点）2.每一次找到入度为0的点，添入队列中，在将其指向点的入度减1，若为0，继续添入队列，直到没有入度为0的点。(这里也可以不用队列操作，对不同题目灵活改变)3.判换，第2步之后如果还有点的入度大于0，那么一定有环。

 1 #include<cstring>
 2 #include<cstdio>
 3 #include<iostream>
 4 #include<algorithm>
 5 #include<queue>
 6 #include<map>
 7 #include<vector>
 8 #include<string>
 9
10 using namespace std;
11
12
13 int dir[][5]={{0,0},{0,1},{1,0},{1,1}};
14 int g[10][10];
15 string s;
16
17 int cur;
18 int in[15];
19 vector<int>out[10];
20
21 void init()
22 {
23     for(int i=0;i<10;i++)  out[i].clear(),in[i]=0;
24
25 }
26
27 void toposort()
28 {
29     queue<int>que;
30     for(int i=1;i<cur;i++)
31        if(in[i]==0) que.push(i);
32
33     while(que.size())
34     {
35         int k=que.front();
36         que.pop();
37
38         in[k]--;
39
40         for(int i=0;i<out[k].size();i++)
41         {
42             in[out[k][i]]--;
43             if(in[out[k][i]]==0) que.push(out[k][i]);
44         }
45     }
46
47     for(int i=1;i<=9;i++)
48     if(in[i]>0) {cout<<"THESE WINDOWS ARE BROKEN"<<endl;return ;}
49
50     cout<<"THESE WINDOWS ARE CLEAN"<<endl;
51 }
52
53 int main()
54 {
55     while(cin>>s&&s!="ENDOFINPUT")
56     {
57         for(int i=0;i<4;i++)
58             for(int j=0;j<4;j++)
59                 cin>>g[i][j];
60
61         cin>>s;
62
63         init();
64
65         cur=1;//用于表示窗口编号
66         for(int i=0;i<3;i++)//扫描每一个窗口，建立有向图，记录入度，出度
67             for(int j=0;j<3;j++)
68         {
69             map<int,int>mp;
70             for(int k=0;k<4;k++)
71             {
72                 int x=i+dir[k][0];
73                 int y=j+dir[k][1];
74                 if(g[x][y]!=cur&&mp[g[x][y]]==0)
75                 {
76                     mp[g[x][y]]=1;//防止重复的窗口覆盖
77                     in[g[x][y]]++;
78                     out[cur].push_back(g[x][y]);
79                 }
80             }
81             cur++;
82         }
83
84         toposort();
85     }
86 }