POJ1094查分约束，判断关系是否唯一

题意：

      给你一些a<b的关系，然后有三组询问。

1 当前这组之后如果能确定这n个数的大小关系，那么就输出关系

2 当前时候出现bug，就是和前面如果冲突，那么就不行

3 最后的答案是否是不确定的，就是既没确定关系，也没出现bug.

思路： 

      这个题目要清楚一点就是处理顺序，上面的三个情况可能会出现重叠的情况，那么就按照上面的1 2 3的优先级来处理，至于判断当前关系是否成立和唯一我用的是差分约束，没有用拓扑排序，差分约束跑完最短路（或者最长路）没有死环，就证明没有bug，而任意点到起点的距离都不重复，那么就是唯一，否则就是当前不能确定，还有就是讨论组里面有个人给了两组数据，我觉得很有用，我就直接粘贴过来吧，为了大家方便理解题意。

分享两组关键性数据:

Posted by MyTalent at 2013-05-08 23:24:07 on Problem 1094

6 6

A<F

B<D

C<E

F<D

D<E

E<F

output：

Inconsistency found after 6 relations.

5 5

A<B

B<C

C<D

D<E

E<A

output:

Sorted sequence determined after 4 relations: ABCDE

第一个例子讲述的是：矛盾和多选，优先判断是否矛盾

第二个例子讲述的是：在矛盾之前如果有成功的，算是成功

#include<queue>

#include<stdio.h>

#include<string.h>

#include<algorithm>

#define N_node 30

#define N_edge 1000

#define INF 100000000

using namespace std;

typedef struct

{

    int to ,cost ,next;

}STAR;

typedef struct

{

    int id ,v;

}ANS;

int list[N_node] ,tot;

int mks[N_node] ,mkt[N_node];

int s_x[N_node];

char str[1000+5][5];

STAR E[N_edge];

ANS ans[N_edge];

void add(int a ,int b ,int c)

{

    E[++tot].to = b;

    E[tot].cost = c;

    E[tot].next = list[a];

    list[a] = tot;

}

bool camp(ANS a ,ANS b)

{

    return a.v < b.v;

}

bool Spfa(int s ,int n)

{

    for(int i = 0 ;i <= n ;i ++)

    s_x[i] = INF;

    memset(mks ,0 ,sizeof(mks));

    memset(mkt ,0 ,sizeof(mkt));

    queue<int>q;

    q.push(s);

    s_x[s] = 0;

    mks[s] = mkt[s] = 1;

    while(!q.empty())

    {

        int xin ,tou;

        tou = q.front();

        q.pop();

        mks[tou] = 0;

        for(int k = list[tou] ;k ;k = E[k].next)

        {

            xin = E[k].to;

            if(s_x[xin] > s_x[tou] + E[k].cost)

            {

                s_x[xin] = s_x[tou] + E[k].cost;

                if(!mks[xin])

                {

                    mks[xin] = 1;

                    if(++mkt[xin] >= n) return 0;

                    q.push(xin);

                }

            }

        }

    }

    return 1;

}

bool judeok(int n ,int id)

{

    for(int i = 1 ;i <= n ;i ++)

    {

        ans[i].id = i;

        ans[i].v = s_x[i];

    }

    sort(ans + 1 ,ans + n + 1 ,camp);

    for(int i = 2 ;i <= n ;i ++)

    if(ans[i].v == ans[i-1].v)

    return 0;

    printf("Sorted sequence determined after %d relations: " ,id);

    for(int i = 1 ;i <= n ;i ++)

    printf("%c" ,ans[i].id + 'A' - 1);

    printf(".\n");

    return 1;

}

int main ()

{

    int n ,m ,i;

    while(~scanf("%d %d" ,&n ,&m) && n + m)

    {

        for(i = 1 ;i <= m ;i ++)

        scanf("%s" ,str[i]);

        memset(list ,0 ,sizeof(list));

        tot = 1;

        for(i = 1 ;i <= n ;i ++)

        add(0 ,i ,0);//虚拟出来一个0点，连接所有点，为了防止整个图不是连通的

        for(i = 1 ;i <= m ;i ++)

        {

            int a = str[i][0] - 'A' + 1;

            int b = str[i][2] - 'A' + 1;

            add(b ,a ,-1);

            int now = Spfa(0 ,n);

            if(now && judeok(n ,i)) break;

            if(!now)

            {

                printf("Inconsistency found after %d relations.\n" ,i);

                break;

            }

        }

        if(i == m + 1)

        {

            printf("Sorted sequence cannot be determined.\n");

            continue;

        }

    }

    return 0;

}