前言

我对差分约束有我个人独特的看法，写这题解既是与大家分享，又算作我对差分约束系统的总结。

浅谈差分约束

对于一些给出形如\(x_i-x_j\leq a\)不等式（差分约束）组，求\(x_t-x_s\)的最大值问题，我们考虑把这些式子移项，变成\(x_i\leq x_j+a\)的形式。我们知道该问题存在解则所有的不等式都应该得到满足。而所有的\(x_i\leq x_j+a\)都得到满足的要求正好与最短路算法中最终结果算出来后的性质\(dis_i\leq dis_j+w_{i,j}\)类似，所以联想到可以用最短路来求解该方程组问题，即把\(\{x_n\}\)当做\(V\)，对每个不等式建边\((j,i,a)\)，设\(x_s=0\)，跑最短路后，\(x_t\)即为最大值（因为xs=0了）。下证方法的正确性，先假设问题有解。

1. 必要性 算出最短路后根据最短路的性质那么所有的不等式都应该被满足，说明答案是正确的。
2. 充分性 根据最短路算法的过程\(x_i\)都被它的限制牢牢控制住，且有一个最严格的限制使得\(x_i\)恰好满足它，那么不可能存在比最短路结果更优的解，说明答案是最优的。

综上，算法正确。（谁看出了问题请联系我。）

无解的情况为图中有负环，对应到原问题中就是一个数比它自己大（小）。

分析此题

每个要求就是个差分约束，然后移项令路权为正，发现都是形如\(b\geq a+1\)的形式，与最长路的结果性质类似，故建立最长路模型，用Bellman-Ford（或者LPFA）求解。对小朋友的要求建模：

1. a比b多：\(a>b \rightarrow a\geq b+1\)
2. a不少于b：\(a \geq b \rightarrow a \geq b+0\)
3. a跟b一样：\(a = b \rightarrow a \geq b+0 \& b \geq a+0\)

其余的都是对偶情况。考虑\(x_i>0 \rightarrow x_i\geq x_0+1\)用0节点向1-n连权为1的边，表示每个小朋友都要分到糖，将dis[0]设为0，这样对0节点的差分就是每个小朋友应得的点数。

然后注意无解的情况，最长路无解即有正环。另外输入的时候特判一下约束是否是“a大于a自己”这种类型的，直接输出-1，可以提高程序效率。

代码

#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<ctime>
#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
#define rg register
#pragma GCC optimize ("O0")
using namespace std;
typedef long long ll;
const int INF=0x7fffffff;
template<class T> inline T read(T&x){
    T data=0;
    int w=1;
    char ch=getchar();
    while(ch!='-'&&!isdigit(ch))
        ch=getchar();
    if(ch=='-')
        w=-1,ch=getchar();
    while(isdigit(ch))
        data=10*data+ch-'0',ch=getchar();
    return x=data*w;
}

const int MAXN=1e5+7;
int n,m;

struct Edge
{
    int to,nx,w;
}E[MAXN*3]; // 0连边还要O(n)空间
int head[MAXN],ecnt;

inline void addedge(int x,int y,int w)
{
    E[++ecnt].to=y,E[ecnt].w=w;
    E[ecnt].nx=head[x],head[x]=ecnt;
}

int num[MAXN],dis[MAXN];
bool inq[MAXN];
queue<int>Q;

inline bool SPFA()
{
    memset(dis,-1,sizeof(dis));
    dis[0]=0;
    Q.push(0);
    inq[0]=1;
    num[0]=1;
    while(!Q.empty())
    {
        int x=Q.front();
        Q.pop();
        inq[x]=0;
        for(rg int i=head[x];i;i=E[i].nx)
        {
            int y=E[i].to;
            if(dis[y]<dis[x]+E[i].w)
            {
                dis[y]=dis[x]+E[i].w;
                if(!inq[y])
                {
                    if(++num[y]>=n) // 一个点最多被松弛n-1次，入队n-1次
                        return 0;
                    Q.push(y);
                    inq[y]=1;
                }
            }
        }
    }
    return 1;
}

int main()
{
//  freopen(".in","r",stdin);
//  freopen(".out","w",stdout);
    read(n);read(m);
    for(rg int i=1;i<=m;++i)
    {
        int x,a,b;
        read(x);read(a);read(b);
        if(x==1)
        {
            addedge(a,b,0);
            addedge(b,a,0);
        }
        else if(x==2)
        {
            if(a==b)
            {
                printf("-1");
                return 0;
            }
            addedge(a,b,1);
        }
        else if(x==3)
        {
            addedge(b,a,0);
        }
        else if(x==4)
        {
            if(a==b)
            {
                printf("-1");
                return 0;
            }
            addedge(b,a,1);
        }
        else if(x==5)
        {
            addedge(a,b,0);
        }
    }
    for(rg int i=n;i>=1;--i)
        addedge(0,i,1);
//  cerr<<"build end"<<endl;
    if(!SPFA())
        printf("-1");
    else
    {
        ll ans=0;
        for(rg int i=1;i<=n;++i)
            ans+=dis[i];
        printf("%lld",ans);
    }
//  fclose(stdin);
//  fclose(stdout);
    return 0;
}

Hint

ans要开long long，0节点向1-n连边要逆序，因为根据讨论

这个题原数据有一个点是一个十万的链

可以卡掉SPFA。