差分约束

一.讲解：

https://blog.csdn.net/dragon60066/article/details/80245797

二.洛谷1993

题目：
小K在MC里面建立很多很多的农场，总共n个，以至于他自己都忘记了每个农场中种植作物的具体数量了，他只记得一些含糊的信息（共m个），以下列三种形式描述：

农场a比农场b至少多种植了c个单位的作物，
农场a比农场b至多多种植了c个单位的作物，
农场a与农场b种植的作物数一样多。

但是，由于小K的记忆有些偏差，所以他想要知道存不存在一种情况，使得农场的种植作物数量与他记忆中的所有信息吻合。

输入格式：

第一行包括两个整数 n 和 m，分别表示农场数目和小 K 记忆中的信息数目。

接下来 m 行：

如果每行的第一个数是 1，接下来有 3 个整数 a,b,c，表示农场 a 比农场 b 至少多种植

了 c 个单位的作物。

如果每行的第一个数是 2，接下来有 3 个整数 a,b,c，表示农场 a 比农场 b 至多多种植

了 c 个单位的作物。如果每行的第一个数是 3，家下来有 2 个整数 a,b，表示农场 a 终止的

数量和 b 一样多。

输出格式：

如果存在某种情况与小 K 的记忆吻合，输出“Yes”，否则输出“No”。

输入样例#1：

3 3
3 1 2
1 1 3 1
2 2 3 2

输出样例#1：

Yes

说明

对于 100% 的数据保证：1 ≤ n，m，a，b，c ≤ 10000。

思路：

对于至少的,a-b>=c 可以写成: b-a<=-c
对于至多的,a-b<=c
对于相等的,直接加一条权值为0的边即可.

代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#define re register
using namespace std;
const int maxn = 200005;
const int maxm = 1000005;
const int inf=0x3f3f3f3f;
int n,m,st,en,dis[maxn];///距离数组
int head[maxn],cnt;///head->是总边数中的第几边，cnt->总边数
int vis[maxn];///判断是否存入需更新数组
int times[maxn];///判断负环

inline int read() {
    int X=0,w=1; char c=getchar();
    while (c<'0'||c>'9') { if (c=='-') w=-1; c=getchar(); }
    while (c>='0'&&c<='9') X=(X<<3)+(X<<1)+c-'0',c=getchar();
    return X*w;
}

struct edge
{
    int u,v,w,ne;
}ed[maxm];                                                          ///定义边

void init()
{
    for(int i=0;i<=n;i++)
        head[i]=-1,dis[i]=inf,vis[i]=0,times[i]=0;///初始化
    cnt=0;
}                                                                ///初始化

void addedge(int u,int v,int w)
{
    ed[cnt].u=u;
    ed[cnt].v=v;
    ed[cnt].w=w;
    ed[cnt].ne=head[u];///对于u点，上一条边的编号
    head[u]=cnt++;///这条边的编号,更新head
}                                                                ///加边

struct cmp
{
    bool operator()(int a,int b)
    {
        return dis[a]>dis[b];
    }
};
bool spfa(int st)
{
    priority_queue<int,vector<int>,cmp>q;

    q.push(st);///放入队列
    vis[st]=1;///标记
    dis[st]=0;///定义初始点的距离为0

    while(!q.empty())
    {
        int u=q.top();
        q.pop();///弹出正在更新的数
        vis[u]=0;///取消标记
        for(int i=head[u];i!=-1;i=ed[i].ne)///i等于u最后一条边的编号，然后等于上一条边的编号
        {
            int v=ed[i].v;
            if(dis[v]>dis[u]+ed[i].w)  ///已存的下一个点到st的距离  与  （st到此点距离 + 此点到下一点距离） 比较
            {                          ///如果已存的大，说明此时的路径为最短路径，   然后更新！！！
                dis[v]=dis[u]+ed[i].w;
                if(!vis[v])///不在队列中
                {
                    vis[v]=1;
                    q.push(v);///标记并放入队列
                    if(++times[v]>n)
                    {
                        return 0;
                    }///判负环
                }
            }
        }
    }
    return 1;
}                                                                 ///定义算法                                                              ///定义算法

int main()
{
     n=read(),m=read();///>>en;///n个点，m条路径，st->初始值，en->结束值
    init();///初始化
    for(int i=1;i<=n;i++)
    {
        addedge(0,i,0);
    }

    for(int i=0;i<m;i++)
    {
        int u,v,w,p;
         p=read();
        if(p==1)
        {
            u=read(),v=read(),w=read();
            addedge(u,v,-w);
        }
        else if(p==2)
        {
             v=read(),u=read(),w=read();
            addedge(u,v,w);
        }
        else if(p==3)
        {
             u=read(),v=read();
            addedge(u,v,0);
            addedge(v,u,0);
        }
    }
     if(spfa(0))cout << "Yes";
     else cout << "No";
    return 0;
}

三.HDU3592

题意：
题意简述：

当排队等候喂食时，奶牛喜欢和它们的朋友站得靠近些。FJ有N（2<=N<=1000）头奶牛，编号从1到N，沿一条直线站着等候喂食。奶牛排在队伍中的顺序和它们的编号是相同的。因为奶牛相当苗条，所以可能有两头或者更多奶牛站在同一位置上。即使说，如果我们想象奶牛是站在一条数轴上的话，允许有两头或更多奶牛拥有相同的横坐标。

一些奶牛相互间存有好感，它们希望两者之间的距离不超过一个给定的数L。另一方面，一些奶牛相互间非常反感，它们希望两者间的距离不小于一个给定的数D。给出ML条关于两头奶牛间有好感的描述，再给出MD条关于两头奶牛间存有反感的描述。（1<=ML,MD<=10000，1<=L,D<=1000000）

你的工作是：如果不存在满足要求的方案，输出-1；如果1号奶牛和N号奶牛间的距离可以任意大，输出-2；否则，计算出在满足所有要求的情况下，1号奶牛和N号奶牛间可能的最大距离。

代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#define re register
using namespace std;
const int maxn = 200005;
const int maxm = 1000005;
const int inf=0x3f3f3f3f;
int n,x,t,y,st,en,dis[maxn];///距离数组
int head[maxn],cnt;///head->是总边数中的第几边，cnt->总边数
int vis[maxn];///判断是否存入需更新数组
int times[maxn];///判断负环

inline int read() {
    int X=0,w=1; char c=getchar();
    while (c<'0'||c>'9') { if (c=='-') w=-1; c=getchar(); }
    while (c>='0'&&c<='9') X=(X<<3)+(X<<1)+c-'0',c=getchar();
    return X*w;
}

struct edge
{
    int u,v,w,ne;
}ed[maxm];                                                          ///定义边

void init()
{
    for(int i=0;i<=n;i++)
        head[i]=-1,dis[i]=inf,vis[i]=0,times[i]=0;///初始化
    cnt=0;
}                                                                ///初始化

void addedge(int u,int v,int w)
{
    ed[cnt].u=u;
    ed[cnt].v=v;
    ed[cnt].w=w;
    ed[cnt].ne=head[u];///对于u点，上一条边的编号
    head[u]=cnt++;///这条边的编号,更新head
}                                                                ///加边

struct cmp
{
    bool operator()(int a,int b)
    {
        return dis[a]>dis[b];
    }
};
int spfa(int st)
{
    priority_queue<int,vector<int>,cmp>q;

    q.push(st);///放入队列
    vis[st]=1;///标记
    dis[st]=0;///定义初始点的距离为0

    while(!q.empty())
    {
        int u=q.top();
        q.pop();///弹出正在更新的数
        vis[u]=0;///取消标记
        for(int i=head[u];i!=-1;i=ed[i].ne)///i等于u最后一条边的编号，然后等于上一条边的编号
        {
            int v=ed[i].v;
            if(dis[v]>dis[u]+ed[i].w)  ///已存的下一个点到st的距离  与  （st到此点距离 + 此点到下一点距离） 比较
            {                          ///如果已存的大，说明此时的路径为最短路径，   然后更新！！！
                dis[v]=dis[u]+ed[i].w;
                if(!vis[v])///不在队列中
                {
                    vis[v]=1;
                    q.push(v);///标记并放入队列
                    if(++times[v]>n)
                    {
                        return -1;
                    }///判负环
                }
            }
        }
    }
    if(dis[n]==inf)return -2;
    else return dis[n];
}                                                                 ///定义算法                                                              ///定义算法

int main()
{
    t=read();
  while(t--)
  {
      n=read(),x=read(),y=read();
    init();///初始化
    int u,v,w;
    for(int i=0;i<x;i++)
    {
        u=read(),v=read(),w=read();
        addedge(u,v,w);
    }
    for(int i=0;i<y;i++)
    {
        v=read(),u=read(),w=read();
        addedge(u,v,-w);
    }
    printf("%d\n",spfa(1));
  }

    return 0;
}