Codevs2404糖果——差分约束系统整理

http://codevs.cn/problem/2404/
典型的差分约束系统，给定多个约束条件，求满足条件的答案最小，最大值等。
对于一个差分约束系统，我们可以将其转化为一个不等式组，然后据此建边跑最短路算法。为什么要建边跑最短路算法呢？
观察，在单元最短路问题中存在如下的三角形不等式
对于最短路有：f + v <=t，即 f - t <=-v 或 t - f >=v
对于最长路有：f + v >=t，即 f - t >=-v 或 t - f <=v
与约束条件转化为的不等式在形式和意义上其实是相同的。
那么不等式问题就可以转化为最短路径问题了
一.
先按照最短路径的三角形不等式建边，
以此题为例：可以建正权边跑最长路（1），或者建负权边，将所有边权加上最小负权边的绝对值跑最短路（2）。
1.a<=b，b<=a 即a - b <=0，b - a <=0.则由a到b建一条权值为0的边，由b到a建一条权值为0的边。
2.a< b 即a - b <0，a - b <=-1.则由a到b建一条权值为1（1）/-1（2）的边。
3.a>=b 即b - a <=0.则由b到a建一条权值为0的边。
4.a> b 即b - a <0，b - a <=-1.则由b到a建一条权值为1（1）/-1（2）的边。
5.a<=b 即a - b <=0.则由a到b建一条权值为0的边。
代码如下，是按照最短路径不等式，跑的最长路。
注意，因为存在不满足条件的情况，需要判正环。
加SPFA的SLF优化（基于贪心的双端队列优化）。
另外并不一定保证图是连通的，所以建立超级原点向所以点连权值为1的边（保证每个小朋友至少有一个糖果），从超级原点跑SPFA。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<deque>
using namespace std;
int n,k,x,a,b,tot;
int next[500001],first[500001],dis[500001],cnt[500001];
long long ans;
bool flag;
bool inq[500001];
struct edge
{
    int u,v,w;
}l[500001];
deque<int>q;
void build(int f,int t,int c)
{
    l[++tot]=(edge){f,t,c};
    next[tot]=first[f];
    first[f]=tot;
}
void SPFA()
{
    dis[0]=0;
    q.push_front(0);
    inq[0]=1;
    while(!q.empty())
    {
        int k=q.front();
        q.pop_front();
        inq[k]=0;
        for(int i=first[k];i!=-1;i=next[i])
        {
            int x=l[i].v;
            if(dis[x]<dis[k]+l[i].w)
            {
                dis[x]=dis[k]+l[i].w;
                if(!inq[x])
                {
                    if(!q.empty()&&dis[x]>=dis[q.front()])
                    q.push_front(x);
                    else q.push_back(x);
                    inq[x]=1;
                    cnt[x]=max(cnt[x],cnt[k]+1);
                    if(cnt[x]>n+2)
                    {
                        flag=1;
                        return;
                    }
                }
            }
        }
    }
}
int main()
{
    memset(first,-1,sizeof(first));
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++)
    {
        build(0,i,1);
    }
    for(int i=1;i<=k;i++)
    {
        scanf("%d%d%d",&x,&a,&b);
        if(x==1)
        {
            build(a,b,0);
            build(b,a,0);
        }
        if(x==2)
        build(a,b,1);
        if(x==3)
        build(b,a,0);
        if(x==4)
        build(b,a,1);
        if(x==5)
        build(a,b,0);
    }
    SPFA();
    for(int i=1;i<=n;i++)
    ans+=dis[i];
    if(flag==1)
    printf("-1");
    else printf("%lld",ans);
    return 0;
}

二.补充
按照最长路径的三角形不等式建边，
以此题为例：可以建正权边跑最长路（1），或者建负权边，将所有边权加上最小负权边的绝对值跑最短路（2）。
1.a<=b，b<=a 即b - a >=0，a - b >=0.则由b到a建一条权值为0的边，由a到b建一条权值为0的边。
2.a< b 即b - a >0，b - a >=1.则由b到a建一条权值为-1（2）/1（1）的边。
3.a>=b 即a - b >=0.则由a到b建一条权值为0的边。
4.a> b 即a - b >0，a - b >=1.则由a到b建一条权值为-1（2）/1（1）的边。
5.a<=b 即b - a >=0.则由b到a建一条权值为0的边。
三.总结
明确自己的使用习惯，切记不要记混。
如果上面的不好理解的话，只需要记住：
如果a<(=)b，由a向b建边，最后跑最长路统计答案即可。