拓补排序

在图中如果一个点被另一个点覆盖，或者一个点成立的前提是另一个点存在，那么他们成图后的关系是拓补排序。
训练题：

Window Pains （poj-2585）

题意：有九个窗口，每个窗口占四格：
                                              
然后将会任意打开多个窗口，给出打开多个窗口后的屏幕。判断屏幕呈现的数字是否是打开任意窗口后呈现的样子。
解题思路：
判断这个格原来的数字，如果这个格的数字不是原来的数字，可以知道每个数字所组成的小四方格的左上角位置为该数字i:x=（i-1）/3，y=（i-1）%3，那么说明现在这个数在所在的区域覆盖了这个格原来的数字所覆盖的区域。然后在用拓补排序即可。
代码如下：

#include <iostream>
#include <stdio.h>
#include <queue>
#include <vector>
#include <string.h>
#include <string>
using namespace std;
vector<int>    mp[1000];
int degree[1000];
int arr[4][4];//存屏幕 
int main(){
    string s;
    int x,y,num;
    while(cin>>s&&s=="START"){
        queue<int>que;
        num=0;
        for(int i=1;i<=9;i++){
            mp[i].clear();
        }
        memset(degree,0,sizeof(degree));
        for(int i=0;i<4;i++){
            for(int j=0;j<4;j++){
                cin>>arr[i][j];
            }
        }
        for(int i=1;i<=9;i++){
            x=(i-1)/3;//找i点所在的首位置 
            y=(i-1)%3;
            for(int j=0;j<2;j++){
                for(int k=0;k<2;k++){//再找其他3个位置 
                    if(arr[x+j][y+k]!=i){
                        mp[arr[x+j][y+k]].push_back(i);//拓扑排序即可 
                        degree[i]++;
                    }
                }
            }
        }
        for(int i=1;i<=9;i++){
            if(degree[i]==0){
                que.push(i);
                num++;
            }
        }
        int c;
        while(!que.empty()){
            c=que.front();
            que.pop();
            for(int i=0;i<mp[c].size();i++){
                degree[mp[c][i]]--;
                if(degree[mp[c][i]]==0){
                    que.push(mp[c][i]);
                    num++;
                }
            }
        }
        cin>>s;
        if(num==9){//每个数字都将有覆盖或被覆盖所以如果揭开完num=9; 
            puts("THESE WINDOWS ARE CLEAN");
        }
        else{
            puts("THESE WINDOWS ARE BROKEN");
        }
        
    }
    return 0;
} 

 

Rank of Tetris   （hdu-1811）

 自从Lele开发了Rating系统，他的Tetris事业更是如虎添翼，不久他遍把这个游戏推向了全球。

为了更好的符合那些爱好者的喜好，Lele又想了一个新点子：他将制作一个全球Tetris高手排行榜，定时更新，名堂要比福布斯富豪榜还响。关于如何排名，这个不用说都知道是根据Rating从高到低来排，如果两个人具有相同的Rating，那就按这几个人的RP从高到低来排。 

终于，Lele要开始行动了，对N个人进行排名。为了方便起见，每个人都已经被编号，分别从0到N-1,并且编号越大，RP就越高。 
同时Lele从狗仔队里取得一些（M个）关于Rating的信息。这些信息可能有三种情况，分别是"A > B","A = B","A < B"，分别表示A的Rating高于B,等于B,小于B。 

现在Lele并不是让你来帮他制作这个高手榜，他只是想知道，根据这些信息是否能够确定出这个高手榜，是的话就输出"OK"。否则就请你判断出错的原因，到底是因为信息不完全（输出"UNCERTAIN"），还是因为这些信息中包含冲突（输出"CONFLICT"）。 
注意，如果信息中同时包含冲突且信息不完全，就输出"CONFLICT"。 

Input

本题目包含多组测试，请处理到文件结束。 
每组测试第一行包含两个整数N,M(0<=N<=10000,0<=M<=20000),分别表示要排名的人数以及得到的关系数。 
接下来有M行，分别表示这些关系 

Output

对于每组测试，在一行里按题目要求输出

Sample Input

3 3

0 > 1

1 < 2

0 > 2

4 4

1 = 2

1 > 3

2 > 0

0 > 1

3 3

1 > 0

1 > 2

2 < 1

Sample Output

OK

CONFLICT

UNCERTAIN

 解题思路：

当rating值相同时可以用并查集合并，其他的在用拓补排序，最后判断加入队列的数是不是并查集中根的总数。

代码：

#include <iostream>
#include <queue>
#include <vector>
#include <string.h>
using namespace std;

vector<int> mp[10010];
int degree[10010];
int pre[10010];
int flag,flags;

int find(int a){//并查集 
    if(pre[a]==a){
        return a;
    }
    return pre[a]=find(pre[a]);
}

void join(int a,int b){
    int aa=find(a),bb=find(b);
    if(aa!=bb){
        pre[aa]=bb;
    }
    return ;
}

int main(){
    int n,m,a[10010],b[10010],c;
    char s[10010];
    while(cin>>n>>m&&n){
        flags=0;
        flag=0;
        for(int i=1;i<=n;i++){
            pre[i]=i;
        }
        queue<int>que;
        for(int i=1;i<=n;i++){
            mp[i].clear();
        }
        memset(degree,0,sizeof(degree));
        
        for(int i=1;i<=m;i++){
            cin>>a[i]>>s[i]>>b[i];
            a[i]++,b[i]++;
            if(s[i]=='='){//如果等于=号那么将他们合并，不将其他的直接加入存图数组中，因为会有儿子结点。 
                join(a[i],b[i]); 
            }
        }
        for(int i=1;i<=m;i++){
            int aa=find(a[i]),bb=find(b[i]);
            if(s[i]=='>'){
                mp[aa].push_back(bb);//将他们转化为根加入到存图数组中 
                degree[bb]++;
            }
            else if(s[i]=='<'){
                mp[bb].push_back(aa);
                degree[aa]++;
            }
        }
        for(int i=1;i<=n;i++){
            if(degree[i]==0&&pre[i]==i){
                que.push(i);
                flag++;
            }
        }
        while(!que.empty()){
            if(que.size()>1){
                flags=1;
            }
            c=que.front();
            que.pop();
            for(int j=0;j<mp[c].size();j++){
                int i=mp[c][j];
                degree[i]--;
                if(degree[i]==0){
                    que.push(i);
                    flag++;
                }
            }
        }
        for(int i=1;i<=n;i++){
            if(pre[i]==i){
                flag--;//存入队列中的个数是不是等于并查集跟的个数 
            }
        }
        if(flag){
            puts("CONFLICT");
        }
        else if(flags){
            puts("UNCERTAIN");
        }
        else{
            puts("OK");
        }
    }
    return 0;
} 

 

Reward   （hdu-2647）

Dandelion's uncle is a boss of a factory. As the spring festival is coming , he wants to distribute rewards to his workers. Now he has a trouble about how to distribute the rewards. 
The workers will compare their rewards ,and some one may have demands of the distributing of rewards ,just like a's reward should more than b's.Dandelion's unclue wants to fulfill all the demands, of course ,he wants to use the least money.Every work's reward will be at least 888 , because it's a lucky number.

Input

One line with two integers n and m ,stands for the number of works and the number of demands .(n<=10000,m<=20000) 
then m lines ,each line contains two integers a and b ,stands for a's reward should be more than b's.

Output

For every case ,print the least money dandelion 's uncle needs to distribute .If it's impossible to fulfill all the works' demands ,print -1.

Sample Input

2 1

1 2

2 2

1 2

2 1

Sample Output

1777

-1

题意：

在发奖金的时候，有的人希望比其他某个人高，所以你要判断满足所有人的要求下你要发的所有奖金。每个人的奖金不小于888。如果无法全部满足就输出-1。

解题思路：

用奖金少的覆盖奖金多的，即谁大谁被覆盖。然后可以知道被覆盖的比覆盖他的多1，没被覆盖的为初始奖金888。然后在全部相加即可得到要付的最大奖金，如果过程中出现环，那么就无法继续，输出-1。

代码：

#include <bits/stdc++.h>
using namespace std;
vector<int> mp[10010];
int degree[10010];
int sum;
int reward[10010];//存取每个人的奖金 
int main(){
    int n,m,a,b,c,flag;
    while(cin>>n>>m){
        queue<int>que;
        flag=0;
        sum=0;
        for(int i=1;i<=n;i++){
            mp[i].clear();
        }
        memset(reward,0,sizeof(reward));
        memset(degree,0,sizeof(degree));//初始化 
        for(int i=1;i<=m;i++){
            cin>>b>>a;
            mp[a].push_back(b);//数据量过大所以用vector存图 
            degree[b]++;//改点度数+1 
        }
        for(int i=1;i<=n;i++){
            if(degree[i]==0){
                que.push(i);
                reward[i]=888;//初始没被覆盖的人的奖金 
                flag++;//代表这个人不在不覆盖 
            }
        }
        while(!que.empty()){
            c=que.front();
            que.pop();
            for(int j=0;j<mp[c].size();j++){
                int i=mp[c][j];
                degree[i]--;//度数减去一 
                if(degree[i]==0){
                    reward[i]=reward[c]+1;//奖金比覆盖他的人多1. 
                    que.push(i);
                    flag++;
                }
            }
        }
        if(flag==n){//如果每个人的需求都被满足，即没成环 
            for(int i=1;i<=n;i++){
                sum+=reward[i];// 总共的奖金 
            }
            cout<<sum<<endl;
        }
        else{
            puts("-1");
        }   
    }
    return 0;
}