差分约束 【知识点】

知识点 详解 一 （点我）

简单的 差分约束

1. 如果是求解 d[st]-d[ed]的最大值 就要将所有的约束条件都转化为 d[x]-d[y]<=z 的形式 然后建图求最短路
2. 如果是求解 d[st]-d[ed] 的最小值 就要将所有的约束条件转户为 d[x]-d[y]>=z 的形式，然后建图，求最长路。
3. 不等式标准化
   如果给出的不等式有”<=”也有”>=”，又该如何解决呢？很明显，首先需要关注最后的问题是什么，如果需要求的是两个变量差的最大值，那么需要将所有不等式转变成”<=”的形式，建图后求最短路；相反，如果需要求的是两个变量差的最小值，那么需要将所有不等式转化成”>=”，建图后求最长路。
   如果有形如：A - B = c 这样的等式呢？我们可以将它转化成以下两个不等式：
   A - B >= c (1)
   A - B <= c (2)
   再通过上面的方法将其中一种不等号反向，建图即可。最后，如果这些变量都是整数域上的，那么遇到A - B < c这样的不带等号的不等式，我们需要将它转化成”<=”或者”>=”的形式，即 A - B <= c - 1
4. 差分约束系统的解有三种情况：1、有解 （最短路（长路）能够从起点到终点）；2、无解（中间出现 圈的情况 ）；3、无限多解（图不是连通：到不了终点）；

差分约束 模版
（这只是我现在的理解，如有错误，欢迎指出 ）
代码

//** 求解  最短路类型的 差分约束
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#include<set>
#define CLR(a,b) memset((a),(b),sizeof(a))
#define inf 0x3f3f3f3f
#define mod 100009
#define LL long long
#define MAXN  1000+10
#define MAXM 2000000+100
#define ll o<<1
#define rr o<<1|1
#define lson o<<1,l,mid
#define rson o<<1|1,mid+1,r
using namespace std;
void read(int &x){
    x=0;char c;
    while((c=getchar())<'0');
    do x=x*10+c-'0';while((c=getchar())>='0');
}
struct Edge {
    int from,to,val,next;
}edge[MAXM];
int head[MAXN],top;  //前向星存图
int dis[MAXN]; // 保存距离 
int qcnt[MAXN]; // 记录每个点入队列的次数 
int vis[MAXN]; // 点是否在 队列中 
int n,m;  // n个点 
void addedge(int a,int b,int c)
{
    Edge e={a,b,c,head[a]};
    edge[top]=e;head[a]=top++;
 } 
 void init()
 {
    memset(head,-1,sizeof(head));
    top=0;
    memset(qcnt,0,sizeof(qcnt));
 }
void getmap()
{
    //根据约束条件 建图  **核心 
    while(m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        addedge(a,b,c);
    }

}
int spfa(int st,int ed)
{
    for(int i=0;i<MAXN;i++) // 这里看情况，应该没有这么大
    dis[st]=i==st ?0:inf;
    vis[st]=1;
    queue<int>Q;
    Q.push(st);
    while(!Q.empty())
    {
        int now=Q.front();Q.pop();
        if(qcnt[now]++>n) return 0;  // 如果一点入队列大于n次，说明图中有环 无解  
        vis[now]=0;
        for(int i=head[now];i!=-1;i=edge[i].next)
        {
            Edge e=edge[i];
            dis[e.to]=min(dis[now]+e.val,dis[e.to]);
            if(!vis[e.to])
            {
                vis[e.to]=1;
                Q.push(e.to);
            }
        }
    }       
if(dis[ed]!=inf) return 1; // 能够到达终点  有解
else return -1;  // 图不是连通的 无限个解 
}
int main()
{

    return 0;
}