bzoj2330 [SCOI2011]糖果题解

http://www.lydsy.com/JudgeOnline/problem.php?id=2330

• 题目大意
  对这个题我真的不想再多提一句了。
  n个人分糖，保证每个人都有糖，有k个限制条件，分别是 a=b ， a<b ， a≥b ， a>b ， a≤b 。这五种情况分别用x=1,2,3,4,5表示。求最少需要准备多少糖果。其中 n,k≤106 。

• 题解
  一看就是差分约束了。
  差分约束中求最小值用 ≥ ，跑最长路；求最大值用 ≤ ，跑最短路。
  x=1即a=b ，直接 a→b,b→a 权值都是0；
  x=3即a≥b ，直接 b→a ，权值为0；
  x=5即a≤b ，直接 a→b ，权值为0；
  那么不带等号的怎么办呢？
  （如果是实数可以不管，就是求得的最值取不到也在误差范围内。）
  因为a，b均是整数，所以
  x=2即a<b⇒a≤b−1 ，然后 a→b ，权值为1；
  同理， x=4即a>b⇒a≥b+1 ，然后 b→a ，权值为1；
  然后是与源点0连边。因为每个人都有糖，即 f[i]≥1⇒f[i]−f[0]≥1 ，所以 0→i ，权值为1。

• 注意事项
  本来是一道很裸的差分约束，但是：
  某测试点是十万条边连成一条链，如果采用邻接表从表头插入的写法，从源点0连边时如果 i=1→n ，会T掉，应该 i=n→1 ；
  某测试点是 x=2或4 时出现了 a=b 的情况，即 a>a或a<a ，这种情况应为无解，输出-1，如果不特判，你的spfa将会在毫不知情的情况下陷入死循环（就是邻接表自己连成环了）；
  dist数组要开longlong。

• Code

#include 
#include 
#include 
#include 
using namespace std;
const int maxn = 100010, oo = 1000000000, nil = 0;
int n, k;
int e, pnt[maxn], nxt[maxn << 2], u[maxn << 2], v[maxn<< 2], w[maxn << 2];
bool vis[maxn], flag;
int times[maxn];
long long d[maxn];
void addedge(int a, int b, int c)
{
    u[++e] = a; v[e] = b; w[e] = c;
    nxt[e] = pnt[a]; pnt[a] = e;
}
void init()
{
    int x, a, b;
    flag = false;
    scanf("%d%d", &n, &k);
    //跑最长路的时候我喜欢直接把边权加成负的
    for(int i = n; i > 0; --i)
    {
        addedge(0, i, -1);
    }
    for(int i = 1; i <= k; ++i)
    {
        scanf("%d%d%d", &x, &a, &b);
        switch(x)
        {
            case 1: addedge(a, b, 0);
                    addedge(b, a, 0);
                    break;
            case 2: addedge(a, b, -1);
                    if(a == b)
                    {
                        flag = true;
                    }
                    break;
            case 3: addedge(b, a, 0);
                    break;
            case 4: addedge(b, a, -1);
                    if(a == b)
                    {
                        flag = true;
                    }
                    break;
            case 5: addedge(a, b, 0);
                    break;
            default:break;
        }
    }
}
void work()
{
    if(flag)
    {
        puts("-1");
        return;
    }
    memset(d, 0x7f, sizeof(d));
    memset(vis, 0, sizeof(vis));
    memset(times, 0, sizeof(times));
    queue <int> Q;
    d[0] = 0;
    vis[0] = true;
    ++times[0];
    Q.push(0);
    while(!Q.empty())
    {
        int t = Q.front();
        Q.pop();
        vis[t] = false;
        for(int j = pnt[t]; j != nil; j = nxt[j])
        {
            if(d[v[j]] > d[t] + w[j])
            {
                d[v[j]] = d[t] + w[j];
                if(!vis[v[j]])
                {
                    vis[v[j]] = true;
                    ++times[v[j]];
                    Q.push(v[j]);
                    //因为加入了点“0”，所以总共有n+1个点
                    //某点第n+1次入队时才说明有负环
                    //虽然这里写>=n也能过
                    if(times[v[j]] > n)
                    {
                        puts("-1");
                        return;
                    }
                }
            }
        }
    }
    long long ans = 0;
    for(int i = 1; i <= n; ++i)
    {
        ans += d[i];
    }
    printf("%lld\n", -ans);
}
int main()
{
    init();
    work();
    return 0;
}