hdu--1811--并查集&&拓扑排序<好题>

做了这题 绝逼 累啊..

mle -- re<stack overflow>--tle--wa---ac

经过这么5步 终于AC了

这题 我觉得可以让你更好地来 理解 拓扑排序的一些细节问题

首先 这题 为什么要用到并查集呢? 因为 会有 A = B这种情况的出现 然后可能再来个 B =C A = D....那么我们就需要将它们全部表示成一个点 那么就是都用一个根结点来表示

然后 这边 是要判断 能不能根据给出的条件 形成一个排列 那么就是个 拓扑问题 根据 > <情况来判断

我觉得 解这题的几点核心思想：

1.如果要对N个元素进行拓扑排序 那么如果每次 入度为0的点超过2个 就会形成多种排序结果 所以 这也就是 一般我们做拓扑的时候 题目会要求我们什么按照字典序来输出什么的 因为存在满足要求情况不止一种啊  但这边 很特殊 它一定严格按照><=来输出 所以我们可以对每次队列中的元素个数进行判断 如果大于一个 就可以确定这是不确定 即 q.size()>1

2.拓扑排序是基于---DAG<有向无环图>     其实也就是告诉我们 可以根据拓扑来判断 这个图中是否存在环? 我们只要每次有一个元素被取出 就进行统计 最后再判断下 一共被取出的元素数目  与 需要进行拓扑的元素数目 是否相等 如果不相等 就可以说它是 成环的

---我感觉 这2点 应该算是最重要的 但还有很多细节 地方要注意的   我一共写了好多份代码...

一开始 我走错了个方向 我忘记考虑了 成环的存在 我判断 A>B 是否与 A<B 同时存在 来判断conflict 这样虽然样例过了但是 我mle同时 也是错误的

恩 对了 这边进行初始入队的时候很重要一点是  这个结点 不仅仅要求是入度为0 而且是 根结点  因为不是根结点的 已经被我们合并掉了 没有纳入我们总的元素数量考虑

所以 这边 我后来做的时候 又犯了一次错误

我们对于输入的 A OP B 需要进行2次处理  第一次是把 = 号关系的2个结点合并 每次 合并 都需要对总的数目--

其实 这个合并不难理解 因为主要是来因对 A = B   B = D D>C 这种类似的情况的

　　　　　　　　touch  me

这边 题目是没有要求我们输出最终结果 但是 如果要输出的话 我们也只要根据这句话就好了 ---如果两个人具有相同的Rating，那就按这几个人的RP从高到低来排----

好了 贴下代码 有点乱啊 被这vs搞的

#include <iostream>
#include <cstring>
#include <map>
#include <queue>
using namespace std;

bool ans;
int n;
const int size = 10010;
int in[size];
int father[size];
char mp[size][size];
map<char, int>op;
queue<int>q;

int find(int x)
{
    while( father[x]!=-1 )
    {
        father[x] = father[ father[x] ];
        x = father[x];
    }
    return x;
}

void topo()
{
    for (int i = n - 1; i >= 0; i--)
    {
        if (!in[i])
        {
            q.push(i);
        }
    }
    while (!q.empty())
    {
        if (q.size()>1)
            ans = true;// uncertain
        int now = q.front();
        q.pop();
        for ( int i = 0 ; i<n ; i++ )
        {
            if( mp[now][i]=='2' )
            {
                in[i] --;
                if( in[i]==0 )
                {
                    q.push(i);
                }
            }
        }
    }
}

int main()
{
    cin.sync_with_stdio(false);
    int m , x , y;
    char ch;
    bool flag;
    while (cin >> n >> m)
    {
        memset(father, -1, n*sizeof(int));
        memset(mp,'0', sizeof(mp));
        memset(in, 0, n*sizeof(int));
        op['='] = '1';
        op['>'] = '2';
        op['<'] = '3';
        ans = flag = false;
        while (m--)
        {
            cin >> x >> ch >> y;
            x = find(x);
            y = find(y);
            if (mp[x][y]=='0')
            {
                if (ch == '=')
                {
                    mp[x][y] = '1';//1是平局
                    mp[y][x] = '1';
                    father[y] = x;
                }
                else if (ch == '>')
                {
                    mp[x][y] = '2';//2是大于
                    mp[y][x] = '3';//3是小于
                    in[y] ++;
                }
                else
                {
                    mp[x][y] = '3';
                    mp[y][x] = '2';
                    in[x] ++;
                }
            }
            else
            {
                if (op[ch] != mp[x][y])
                {
                    flag = true;//conflict
                }
            }
        }
        topo();
        if (flag)
            cout << "CONFLICT" << endl;
        else
        {
            if (ans)
                cout << "UNCERTAIN" << endl;
            else
                cout << "OK" << endl;
        }
    }
    return 0;
}

#include <iostream>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

int n , cnt;
bool CONFLICT , UNCERTAIN;
const int size = 10010;
int x[size];
int y[size];
char ch[size];
int in[size];
int father[size];
vector<int>ve[size];
queue<int>q;

void init( )
{
    memset( father , -1 , sizeof(father) );
    memset( in , 0 , sizeof(in) );
    for( int i = 0 ; i<size ; i++ )
    {
        ve[i].clear();
    }
}

int find( int x )
{
    return father[x] == -1 ? x : father[x] = find( father[x] );
}

void topo( )
{
    for( int i = 0 ; i<n ; i++ )
    {
        if( !in[i] && father[i] == -1 )
        {
            q.push(i);
        }
    }
    while( !q.empty() )
    {
        if( q.size()>1 )
            UNCERTAIN = true;
        int now = q.front();
        q.pop();
        cnt --;
        for( int i = 0 ; i<ve[now].size() ; i++ )
        {
            int u = ve[now][i];
            if( --in[u] == 0 )
            {
                q.push(u);
            }
        }
    }
    if( cnt>0 )
        CONFLICT = true;
}

int main()
{
    int m , xx , yy;
    while( cin >> n >> m )
    {
        init( );
        cnt = n;
        CONFLICT = UNCERTAIN = false;
        for( int i = 0 ; i<m ; i++ )
        {
            cin >> x[i] >> ch[i] >> y[i];
            if( ch[i]=='=' )
            {    
                xx = find(x[i]);
                yy = find(y[i]);
                if(xx!=yy)
                {
                    father[xx] = yy;
                    cnt --;
                }
            }
        }
        for( int i = 0 ; i<m ; i++ )
        {
            if( ch[i] == '=' )
                continue;
            xx = find(x[i]);
            yy = find(y[i]);
            if( ch[i]=='>' )
            {
                ve[xx].push_back(yy);
                in[yy] ++;
            }
            else
            {
                ve[yy].push_back(xx);
                in[xx] ++;
            }
        }
        topo( );
        if( CONFLICT )
            cout << "CONFLICT" << endl;
        else if( UNCERTAIN )
            cout << "UNCERTAIN" << endl;
        else
            cout << "OK" << endl;
    }
    return 0;
}

//1. 当入队的个数 >1 时证明拓扑排序结果不唯一 uncertain
//2. 入队进行拓扑排序的元素 < 总共的元素个数 成环的存在 conflict 
#include <iostream>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

int n , cnt;
bool CONFLICT , UNCERTAIN;
const int size = 10010;
int in[size];
int father[size];
vector<int>ve[size];
queue<int>q;

void init( )
{
    memset( father , -1 , sizeof(father) );
    memset( in , 0 , sizeof(in) );
    for( int i = 0 ; i<size ; i++ )
    {
        ve[i].clear();
    }
}

int find( int x )
{
    return father[x] == -1 ? x : father[x] = find( father[x] );
}

void topo( )
{
    for( int i = 0 ; i<n ; i++ )
    {
        if( !in[i] && father[i] == -1 )
        {
            q.push(i);
        }
    }
    while( !q.empty() )
    {
        if( q.size()>1 )
            UNCERTAIN = true;
        int now = q.front();
        q.pop();
        cnt --;
        for( int i = 0 ; i<ve[now].size() ; i++ )
        {
            int u = ve[now][i];
            if( --in[u] == 0 )
            {
                q.push(u);
            }
        }
    }
    if( cnt>0 )
        CONFLICT = true;
}

int main()
{
    int m , x , y;
    char ch;
    while( cin >> n >> m )
    {
        init( );
        cnt = n;//原来的元素总数
        CONFLICT = UNCERTAIN = false;//1是关于conflice  2是关于uncertain
        while( m-- )
        {
            cin >> x >> ch >> y;
            x = find(x);
            y = find(y);
            if( ch=='=' )
            {
                if(x!=y)
                {
                    father[x] = y;
                    cnt --;
                }
            }
            else if( ch=='>' )
            {
                ve[x].push_back(y);
                in[y] ++;
            }
            else
            {
                ve[y].push_back(x);
                in[x] ++;
            }
        }
        topo( );
        if( CONFLICT )
            cout << "CONFLICT" << endl;
        else if( UNCERTAIN )
            cout << "UNCERTAIN" << endl;
        else
            cout << "OK" << endl;
    }
    return 0;
}