【差分约束系统】【SCOI2011】分糖果

【题目描述】
幼儿园里有N个小朋友，lxhgww老师现在想要给这些小朋友们分配糖果，要求每个小朋友都要分到糖果。但是小朋友们也有嫉妒心，总是会提出一些要求，比如小明不希望小红分到的糖果比他的多，于是在分配糖果的时候，lxhgww需要满足小朋友们的K个要求。幼儿园的糖果总是有限的，lxhgww想知道他至少需要准备多少个糖果，才能使得每个小朋友都能够分到糖果，并且满足小朋友们所有的要求。
【输入】
输入的第一行是两个整数N，K。
接下来K行，表示这些点需要满足的关系，每行3个数字，X，A，B。
如果X=1， 表示第A个小朋友分到的糖果必须和第B个小朋友分到的糖果一样多；
如果X=2， 表示第A个小朋友分到的糖果必须少于第B个小朋友分到的糖果；
如果X=3， 表示第A个小朋友分到的糖果必须不少于第B个小朋友分到的糖果；
如果X=4， 表示第A个小朋友分到的糖果必须多于第B个小朋友分到的糖果；
如果X=5， 表示第A个小朋友分到的糖果必须不多于第B个小朋友分到的糖果；
【输出】
输出一行，表示lxhgww老师至少需要准备的糖果数，如果不能满足小朋友们的所有要求，就输出-1。
【样例输入】
5 7
1 1 2
2 3 2
4 4 1
3 4 5
5 4 5
2 3 5
4 5 1
【样例输出】
11
【数据范围】
    对于30%的数据，保证 N<=100
    对于100%的数据，保证 N<=100000
对于所有的数据，保证 K<=100000，1<=X<=5，1<=A, B<=N

此题考察差分约束系统。
但由于满足差分约束系统的所有解是一个区间，
而用最短路松弛出来的结果总是只能求到一个最大的解，
所以只能求最长路。

Accode：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <bitset>

using std::bitset;
using std::queue;

const char fi[] = "candy.in";
const char fo[] = "candy.out";
const int maxN = 100010;
const int MAX = 0x3f3f3f3f;
const int MIN = ~MAX;

typedef long long int64;
struct Edge{int u, v; int64 d; Edge *next; };
Edge *edge[maxN];
bitset <maxN> marked;
queue <int> q;
int In[maxN];
int cnt[maxN];
int64 dist[maxN];
int n, m;

void init_file()
{
	freopen(fi, "r", stdin);
	freopen(fo, "w", stdout);
	return;
}

inline void insert(int u, int v, int64 d)
{
    Edge *p = new Edge;
    p -> u = u;
    p -> v = v;
    p -> d = d;
    p -> next = edge[u];
    edge[u] = p;
    return;
}

void readdata()
{
    scanf("%d%d", &n, &m);
    for (; m; --m)
    {
        int x, u, v;
        scanf("%d%d%d", &x, &u, &v);
        switch (x)
        {
        case 1:
            insert(u, v, 0);
            insert(v, u, 0);
            break;
        case 2:
            insert(u, v, 1);
            if (u == v)
            {
                printf("-1");
                exit(0);
            } //这个很重要！
            break;
        case 3:
            insert(v, u, 0);
            break;
        case 4:
            insert(v, u, 1);
            if (u == v)
            {
                printf("-1");
                exit(0);
            } //这个很重要！
            break;
        case 5:
            insert(u, v, 0);
            break;
        }
    }
    while (!q.empty()) q.pop();
    marked.reset();
    for (int i = 1; i < n + 1; ++i)
    {
        marked.set(i);
        dist[i] = 1;
        q.push(i);
    } //将每个点都入队，且初始d值置为1。
    return;
}

inline bool Spfa()
{
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        marked.reset(u);
        for (Edge *p = edge[u]; p; p = p -> next)
        {
            int v = p -> v;
            if (dist[u] + p -> d > dist[v])
            {
                dist[v] = dist[u] + p -> d;
                if (++cnt[v] >= n) return false;
		//判断是否有环，利用每个点至多被松弛(n-1)次。
                if (!marked.test(v))
                {
                    marked.set(v);
                    q.push(v);
                }
            }
        }
    }
    return true;
}

void work()
{
    if (!Spfa())
    {
        printf("-1");
        return;
    }
    int64 ans = 0;
    for (int i = 1; i < n + 1; ++i)
        ans += dist[i];
    printf("%I64d", ans);
    return;
}

int main()
{
	init_file();
	readdata();
	work();
	return 0;
}