ACM差分约束笔记

https://www.cnblogs.com/31415926535x/p/10463112.html

很早之前学最短路的时候就看了一眼差分约束，，当时以为这种问题不怎么会出现，，而且当时为了只为了学最短路，，所以就没有怎么做题，，知道是什么，但是不会建图使用，，
然后上一次做cf就碰到了，，虽然那道题不只是差分约束能解决还卡时间，，但是万一以后还出现这种题，，只是知道是这个类型的题却不知道如何下手也相当于是不会啊，，所以抽时间重新看了看这块的内容，，做几道题，，顺便背一背最短路的板子，，好久敲最短路的板子都已经忘记了，，

感觉这一块的东西最主要的是建图吧，，很多这样的题的解法都不止一种，，差分约束只是其中一种，，因为使用spfa实现的，，所以也很容易被卡，，

概念

这里的东西我是先参考这篇博客的还有这里
因为之前看过差分约束，，还有印象，，所以上手很快，，纯理论性东西算法导论等等的地方讲的很详细，，

首先差分约束主要是解决 不等式组的求解，，其中这些不等式组的特征是 \(x_i-x_j \leq or \geq K_i(i,j \in [1, n], k \in [1, m])\)，，

• 求 \(x_n-x_0\)的最大值就是求 \(x_n\) 到 \(x_0\)的最短路， \(x_i-x_j \leq K_i\)
• 求 \(x_n-x_0\)的最小值就是求 \(x_n\) 到 \(x_0\)的最长路， \(x_i-x_j \geq K_i\)

建图都是建 \(x_j\) -> \(x_i\) 的边，权值为K

有些题目还有一些隐藏的条件，，比如说 \(x_i-x_{i-1} \leq K_i\)等等的约束条件，，一并加上就行了，

要是出现符号不一致的就两边取相反数，，把符号化一致就行，，（这样会出现负权的边，，所以要用spfa来解，，），，

出现 \(x_i-x_j < K\) 的话可以化成 \(x_i-x_j \leq K + 1\)的形式(都是整数的情况下)，，

判断有无解的话就判断建的图有无环就行了，，，

额外的一些东西

例题

poj-1201-Intervals

题意

题意大概就是，给你n个区间 \([l_i,r_i]\) 要求这些区间内必须要几个数 \(C_i\)，问你满足这些区间的最少的数，，，

看评论区里很多人都是贪心+线段树（树状数组）做的，，

用差分约束的话就是将题目所给的东西转化成若干个不等式，，然后明白要求什么，，找出隐藏的条件，建图求解，，

这道题我们用 \(dis[i]\) 表示0~i这个区间至少要选几个数（类似前缀和的思想），，，然后任意一个区间就可以表示为 \(dis[r]-dis[l - 1] \geq c_i\) ，，题目的隐藏条件是相邻两点直接的个数是0或1，，也就是 \(0 \leq dis[i]-dis[i-1] \leq 1\)，因为对于0这个点出这样无法表示(dis[-1])，，所以对每一个点加一（向右偏移一个位置），，，最后求最长路就行了，，，

代码

//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <algorithm>
#include <queue>
#define aaa cout<<233<<endl;
#define endl '\n'
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;//1061109567
const ll linf = 0x3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = 3.14159265358979;
const int maxn = 1e5 + 5;
const int maxm = 2e5 + 5;
const ll mod = 1e9 + 7;

struct edge
{
    int v;
    int cost;
    edge(int _v = 0, int _cost = 0):v(_v), cost(_cost){}
};
vector<edge> e[maxn];
void addedge(int u, int v, int w)
{
    e[u].pb(edge(v, w));
}
bool vis[maxn];
int cnt[maxn];
int dis[maxn];
bool spfa(int s, int n)
{
    memset(vis, false, sizeof vis);
    memset(cnt, 0, sizeof cnt);
    cnt[s] = 1;
    for(int i = 1; i <= n; ++i)dis[i] = -inf;
    vis[s] = true;
    dis[s] = 0;
    queue<int> q;
    while(!q.empty())q.pop();
    q.push(s);
    while(!q.empty())
    {
        int u = q.front();q.pop();
        vis[u] = false;
        for(int i = 0; i < e[u].size(); ++i)
        {
            int v = e[u][i].v;
            if(dis[v] < dis[u] + e[u][i].cost)
            {
                dis[v] = dis[u] + e[u][i].cost;
                if(!vis[v])
                {
                    vis[v] = true;
                    q.push(v);
                    if(++cnt[v] > n)return false;
                }
            }
        }
    }
    return true;
}
int main()
{
//    freopen("233.in" , "r" , stdin);
//    freopen("233.out" , "w" , stdout);
//    ios_base::sync_with_stdio(0);
//    cin.tie(0);cout.tie(0);
    int n;scanf("%d", &n);
    int mi = inf, mx = 0, u, v, w;
    for(int i = 1; i <= n; ++i)
    {
        scanf("%d%d%d", &u, &v, &w);
        addedge(u, v + 1, w);
        mi = min(mi, u);
        mx = max(mx, v);
    }
    ++mx;
    for(int i = mi; i <= mx; ++i)
    {
        addedge(i, i + 1, 0);
        addedge(i + 1, i, -1);
    }
    spfa(mi, mx);
    printf("%d\n", dis[mx]);
    return 0;
}

poj-1275-Cashier Employment

题意

题意是一天之内24个小时0点到23点，某个时间点需要的营业员的个数 \(r[i]\) 给你，然后有一些应聘的人，他们开始工作的时间 \(a[i]\) 给你，，每个人可以从开始的那个时间段工作8个小时，，然后问你最少应该聘用多少个人使得每个时间段的人数 \(r[i]\) 是足够的，，

分析

乍一看这题不知道怎么下手，，就算是知道这是一道差分约束的题也不知道图怎么建，，

我的感觉是首先要 找出一个属性使得它在不同两个的状态下的满足的条件不同（也就是题目要求什么，就找什么关系（二项式），，也就是我们后面建图时的点与点之间的关系，，而且是差的不等关系，，也就是构建出一个差分约束系统，，而这个属性一般也就是我们要求的最值的一种最宽的情况，，（ \(x_n\) 到 \(x_0\)的最值）

对于这道题来说，题目要我们求一天之内需要的最少的人数 \(sum\) ，，也就是0点到23点的最小值，，这样我们就能看出我们要列出一些 时间段 内的约束条件，，用 \(dis[i]\) 表示0点到i点这段时间内至少需要人数，，（又是前缀和的思想），，，这样一段时间内至少需要的人数就是 \(dis[i] - dis[j] \leq K\) ，，

一个员工只能工作8个小时，所以我们可以得出：从i-8到i这段时间内工作的人数至少要大于i这个时间段内 \(r[i]\) 所需的人数 \(dis[i]-dis[i-8] \geq r[i]\)，此时的 \(i \geq 7\)；

对于 \(i \leq 7\) 的情况，我们可以推出 \(sum-dis[i+16] + s[i] \geq r[i]\)

同时对于每一个小时内的最多的工作人数 \(mp[i]\) 是确定的，，也就是说， \(0 \leq dis[i]-dis[i-1] \leq mp[i]\)

一整天的工作人数满足： \(dis[24]-dis[0] \geq sum\)

上面一个不等式中有一个未知量sum，，它的取值是0~n，，可以二分枚举这个sum多次建图求出最小的sum，，，

参考1
参考2

代码

//hdu
//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <algorithm>
#include <queue>
#include <map>
#define aaa cout<<233<<endl;
#define endl '\n'
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;//1061109567
const ll linf = 0x3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = 3.14159265358979;
const int maxn = 1e5 + 5;
const int maxm = 2e5 + 5;
const ll mod = 1e9 + 7;
struct edge
{
    int to, next, w;
}edge[maxn];
int head[maxn], tot;
void addedge(int u, int v, int w)
{
    edge[tot].to = v; edge[tot].next = head[u]; edge[tot].w = w; head[u] = tot++;
}
void init()
{
    tot = 0;
    memset(head, -1, sizeof head);
}
bool vis[maxn];
int dis[maxn], cnt[maxn];
bool spfa(int s, int n)
{
    memset(vis, false, sizeof vis);
    memset(cnt, 0, sizeof cnt);
    for(int i = 0; i <= n; ++i)dis[i] = -inf;
    vis[s] = true;
    dis[s] = 0;
    cnt[s] = 1;
    queue<int> q;
    while(!q.empty())q.pop();
    q.push(s);
    while(!q.empty())
    {
        int u = q.front(); q.pop();
        vis[u] = false;
        //if(u == 24 && dis[u] > m)return 0;
        for(int i = head[u]; ~i; i = edge[i].next)
        {
            int v = edge[i].to;
            int w = edge[i].w;
            if(dis[v] < dis[u] + w)
            {
                dis[v] = dis[u] + w;
                if(!vis[v])
                {
                    vis[v] = true;
                    q.push(v);
                    if(++cnt[v] > n)return false;
                }
            }
        }
    }
    return true;
}
int r[30], a[maxn];
map<int, int> mp;
int check(int m)
{
    init();
    for(int i = 0; i <= 23; ++i)
    {
        addedge(i, i + 1, 0);
        addedge(i + 1, i, -mp[i]);
    }
    for(int i = 7; i <= 23; ++i)
        addedge(i - 8 + 1, i + 1, r[i]);
    for(int i = 0; i < 7; ++i)
        addedge(i + 16 + 1, i + 1, r[i] - m);
    addedge(0, 24, m);
    addedge(24, 0, -m);
    if(spfa(0, 30))
        return dis[24];
    else
        return 0;
}
int main()
{
//    freopen("233.in" , "r" , stdin);
//    freopen("233.out" , "w" , stdout);
//    ios_base::sync_with_stdio(0);
//    cin.tie(0);cout.tie(0);
    int t;scanf("%d", &t);
    while(t--)
    {
        for(int i = 0; i <= 23; ++i)scanf("%d", &r[i]);
        int n;scanf("%d", &n);
        for(int i = 1; i <= n; ++i)scanf("%d", &a[i]);
        for(int i = 1; i <= n; ++i)++mp[a[i]];
        int l = 0, r = n + 1;
        int ans = 0;
        //for(int i =  1; i <= n; ++i)cout << check(i) << endl;return 0 ;
        while(l + 1 < r)
        {
            int m = (l + r) >> 1;
            int flag = check(m);
            //cout << l << r << m << flag << endl;
            if(m == flag)
            {
                r = m;
                ans = m;
            }
            else
                l = m;
        }
        if(l >= n)
            printf("No Solution\n");
        else
            printf("%d\n", ans);
    }
    return 0;
}
//1
//1 0 3 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
//5
//0
//23
//22
//1
//10

hdu-3440-House Man

题意

题意大概是一个人可以在各个屋顶上跳，，但是必须要跳比现在的高的屋顶，，他可以不改变初始顺序的情况下移动房子来改变他们的距离，，它最大的跳跃距离是d，，然后问你能不能从最矮的房子跳到最高的房子，，如果能，求出最大的这两个房子间的距离

分析

首先是建图，，我们用 \(dis[i]\) 表示第1栋房子到第i栋房子之间的最大距离，，然后跑源点是最矮那栋房子的最短路就行了

对于每栋房子，，我们连一条矮房子i到较高房子j的边表示 \(dis[j]-dis[i] \leq d\)，，注意这里为了保证次序不变，，如果i的编号大于了j，，说明i栋房子在j的右边，，这样 \(dis[i] \geq dis[j]\)，，上面那个式子就是负的，，不成立（也就是无解），，所以要判断一下，，，

还有一个隐藏条件： 相邻两栋房子之间的距离一定是 \(dis[i+1] > dis[i]\)，，也就是： \(dis[i] - dis[i+1] \leq -1\)，，所以建边(i+1)->i权值为-1

代码

没尝试过栈实现的spfa，，据说快一些，，大概是队列时间的三分之一左右，，

普通的队列实现

//hdu
//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <algorithm>
#include <queue>
#include <map>
#define aaa cout<<233<<endl;
#define endl '\n'
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;//1061109567
const ll linf = 0x3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = 3.14159265358979;
const int maxn = 1e5 + 5;
const int maxm = 2e5 + 5;
const ll mod = 1e9 + 7;
struct edge
{
    int to, next, w;
}edge[maxn];
int head[maxn], tot;
void init()
{
    tot = 0;
    memset(head, -1, sizeof head);
}
void addedge(int u, int v, int w)
{
    edge[tot].to = v; edge[tot].w = w; edge[tot].next = head[u]; head[u] = tot++;
}
bool vis[maxn];
int dis[maxn], cnt[maxn];
bool spfa(int s, int n)
{
    for(int i = 0; i <= n; ++i)vis[i] = false;
    for(int i = 0; i <= n; ++i)cnt[i] = 0;
    for(int i = 0; i <= n; ++i)dis[i] = inf;
    vis[s] = true;
    cnt[s] = 1;
    dis[s] = 0;
    queue<int> q;
    while(!q.empty())q.pop();
    q.push(s);
    while(!q.empty())
    {
        int u = q.front();q.pop();
        vis[u] = false;
        for(int i = head[u]; ~i; i = edge[i].next)
        {
            int v = edge[i].to;
            int w = edge[i].w;
            if(dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                if(!vis[v])
                {
                    vis[v] = true;
                    q.push(v);
                    if(++cnt[v] > n)return false;
                }
            }
        }
    }
    return true;
}
struct node
{
    int h, id;
    const bool operator<(const node &r)const
    {
        return h < r.h;
    }
}node[maxn];
int main()
{
//    freopen("233.in" , "r" , stdin);
//    freopen("233.out" , "w" , stdout);
    int t;scanf("%d", &t);
    for(int ca = 1; ca <= t; ++ca)
    {
        int n, d;
        scanf("%d%d", &n, &d);
        for(int i = 1; i <= n; ++i)
        {
            node[i].id = i;
            scanf("%d", &node[i].h);
        }
        sort(node + 1, node + 1 + n);
        init();

        bool flag = true;
        for(int i = 1; i <= n - 1 && flag; ++i)
        {
            addedge(i + 1, i, -1);
            int u = min(node[i].id, node[i + 1].id);
            int v = max(node[i].id, node[i + 1].id);
            if(u > v)flag = false;
            addedge(u, v, d);
        }
        printf("Case %d: ", ca);
        int s = min(node[1].id, node[n].id);
        int t = max(node[1].id, node[n].id);
        if(!flag || !spfa(s, n))printf("-1\n");
        else                    printf("%d\n", dis[t]);
    }
    return 0;
}

队列实现

//hdu
//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <algorithm>
#include <queue>
#include <map>
#define aaa cout<<233<<endl;
#define endl '\n'
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;//1061109567
const ll linf = 0x3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = 3.14159265358979;
const int maxn = 1e5 + 5;
const int maxm = 2e5 + 5;
const ll mod = 1e9 + 7;
struct edge
{
    int to, next, w;
}edge[maxn];
int head[maxn], tot;
void init()
{
    tot = 0;
    memset(head, -1, sizeof head);
}
void addedge(int u, int v, int w)
{
    edge[tot].to = v; edge[tot].w = w; edge[tot].next = head[u]; head[u] = tot++;
}
bool vis[maxn];
int dis[maxn], cnt[maxn];
bool spfa(int s, int n)
{
    for(int i = 0; i <= n; ++i)vis[i] = false;
    for(int i = 0; i <= n; ++i)cnt[i] = 0;
    for(int i = 0; i <= n; ++i)dis[i] = inf;
    vis[s] = true;
    cnt[s] = 1;
    dis[s] = 0;
    queue<int> q;
    while(!q.empty())q.pop();
    q.push(s);
    while(!q.empty())
    {
        int u = q.front();q.pop();
        vis[u] = false;
        for(int i = head[u]; ~i; i = edge[i].next)
        {
            int v = edge[i].to;
            int w = edge[i].w;
            if(dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                if(!vis[v])
                {
                    vis[v] = true;
                    q.push(v);
                    if(++cnt[v] > n)return false;
                }
            }
        }
    }
    return true;
}
struct node
{
    int h, id;
    const bool operator<(const node &r)const
    {
        return h < r.h;
    }
}node[maxn];
int main()
{
//    freopen("233.in" , "r" , stdin);
//    freopen("233.out" , "w" , stdout);
    int t;scanf("%d", &t);
    for(int ca = 1; ca <= t; ++ca)
    {
        int n, d;
        scanf("%d%d", &n, &d);
        for(int i = 1; i <= n; ++i)
        {
            node[i].id = i;
            scanf("%d", &node[i].h);
        }
        sort(node + 1, node + 1 + n);
        init();

        bool flag = true;
        for(int i = 1; i <= n - 1 && flag; ++i)
        {
            addedge(i + 1, i, -1);
            int u = min(node[i].id, node[i + 1].id);
            int v = max(node[i].id, node[i + 1].id);
            if(u > v)flag = false;
            addedge(u, v, d);
        }
        printf("Case %d: ", ca);
        int s = min(node[1].id, node[n].id);
        int t = max(node[1].id, node[n].id);
        if(!flag || !spfa(s, n))printf("-1\n");
        else                    printf("%d\n", dis[t]);
    }
    return 0;
}

poj-3169-Layout

题意

一排牛，，有一些牛之间的距离不能超出d，有一些牛的距离不能小于d，，问你第一头和最后一头牛直接的距离的最大值是多少

分析

简单的差分约束，，直接建图就行了，，，(貌似不加相邻两头之间距离大于1这个条件也能过)

图有环为-1，，距离是inf为-2，其他的就是dis[n]，，

代码

//hdu
//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <algorithm>
#include <queue>
#include <map>
#define aaa cout<<233<<endl;
#define endl '\n'
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;//1061109567
const ll linf = 0x3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = 3.14159265358979;
const int maxn = 1e6 + 5;
const int maxm = 2e5 + 5;
const ll mod = 1e9 + 7;
struct edge
{
    int to, next, w;
}edge[maxn];
int head[maxn], tot;
void init()
{
    tot = 0;
    memset(head, -1, sizeof head);
}
void addedge(int u, int v, int w)
{
    edge[tot].to = v; edge[tot].w = w; edge[tot].next = head[u]; head[u] = tot++;
}
bool vis[maxn];
int dis[maxn], cnt[maxn], sta[maxn];
int spfa(int s, int n)
{
    for(int i = 1; i <= n; ++i)vis[i] = false;
    for(int i = 1; i <= n; ++i)dis[i] = inf;
    for(int i = 1; i <= n; ++i)cnt[i] = 0;
    vis[s] = true;
    cnt[s] = 1;
    dis[s] = 0;
    int top = -1;
    sta[++top] = s;
    while(~top)
    {
        int u = sta[top--];
        vis[u] = false;
        for(int i = head[u]; ~i; i = edge[i].next)
        {
            int v = edge[i].to;
            int w = edge[i].w;
            if(dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                if(!vis[v])
                {
                    vis[v] = true;
                    sta[++top] = v;
                    if(++cnt[v] > n)return -1;
                }
            }
        }
    }
    if(dis[n] == inf)return -2;
    return dis[n];
}
int main()
{
//    freopen("233.in" , "r" , stdin);
//    freopen("233.out" , "w" , stdout);
//    ios_base::sync_with_stdio(0);
//    cin.tie(0);cout.tie(0);
    int n, ml, md;
    scanf("%d%d%d", &n, &ml, &md);
    int u, v, w;
    init();
    for(int i = 1; i <= ml; ++i)
    {
        scanf("%d%d%d", &u, &v, &w);
        if(u > v)swap(u, v);
        addedge(u, v, w);
    }
    for(int i = 1; i <= md; ++i)
    {
        scanf("%d%d%d", &u, &v, &w);
        if(u < v)swap(u, v);
        addedge(u, v, -w);
    }
//    for(int i = 1; i <= n; ++i)
//        addedge(i + 1, i, 0);
    printf("%d\n", spfa(1, n));
    return 0;
}

poj-1364-King

题意

题意是一个序列的一些子序列的和与k的大小关系给你，然后问你原序列的与一个数k的大小关系是否能确定出来，，

分析

还是前缀和的思想，\(dis[i]\) 表示第一个数到第i个数的和，，那么子序列[i,j]的和就表示为 \(dis[j]-dis[i]\)，，题目又给了一些子序列和与一个数的大小关系，也就是： \(dis[j] - dis[i] < or > K_i\)，，用这个条件建图，，因为最后的图可能不连通，所以再加一个源点到所有点为0的边，，

注意，题目给的是每个子序列的起点和它的长度，，大小关系没有等于的情况，，加一减一就行了，，

代码

//hdu
//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <algorithm>
#include <queue>
#include <map>
#define aaa cout<<233<<endl;
#define endl '\n'
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;//1061109567
const ll linf = 0x3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = 3.14159265358979;
const int maxn = 1e6 + 5;
const int maxm = 2e5 + 5;
const ll mod = 1e9 + 7;
struct edge
{
    int to, w, next;
}edge[maxn];
int head[maxn], tot;
void init()
{
    tot = 0;
    memset(head, -1, sizeof head);
}
void addedge(int u, int v, int w)
{
    edge[tot].to = v; edge[tot].w = w; edge[tot].next = head[u]; head[u] = tot++;
}
bool vis[maxn];
int dis[maxn], cnt[maxn], sta[maxn];
bool spfa(int s, int n)
{
    for(int i = 0; i <= n; ++i)vis[i] = false;
    for(int i = 0; i <= n; ++i)dis[i] = inf;
    for(int i = 0; i <= n; ++i)cnt[i] = 0;
    vis[s] = true;
    cnt[s] = 1;
    dis[s] = 0;
    int top = -1;
    sta[++top] = s;
    while(~top)
    {
        int u = sta[top--];
        vis[u] = false;
        for(int i = head[u]; ~i; i = edge[i].next)
        {
            int v = edge[i].to;
            int w = edge[i].w;
            if(dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                if(!vis[v])
                {
                    vis[v] = true;
                    sta[++top] = v;
                    if(++cnt[v] > n)return false;
                }
            }
        }
    }
    return true;
}
int main()
{
//    freopen("233.in" , "r" , stdin);
//    freopen("233.out" , "w" , stdout);
//    ios_base::sync_with_stdio(0);
//    cin.tie(0);cout.tie(0);
    int n, m;
    while(~scanf("%d", &n) && n)
    {
        scanf("%d", &m);
        int u, v, d;
        char s[2];
        init();
        for(int i = 1; i <= m; ++i)
        {
            scanf("%d %d %s %d", &u, &v, s, &d);
            if(s[0] == 'g')
                addedge(u + v, u - 1, -d - 1);
            else
                addedge(u - 1, u + v, d - 1);
        }
        for(int i = 0; i <= n; ++i)
            addedge(n + 1, i, 0);
        if(spfa(n + 1, n + 1))
            printf("lamentable kingdom\n");
        else
            printf("successful conspiracy\n");
    }
    return 0;
}

poj-2983-Is the Information Reliable?

题意

n个站点排成一排，，给出一些描述信息

两个站点之间如果是P，，说明距离是确定的x

如果是V，，距离至少是1

问是否存在这样一个序列满足上面的条件

dis[i]表示第i站所在的位置距离第一个的距离，，这样两站的描述信息就能化成很多的不等式来表示，，建图判断是否存在环就行了，，注意原图可能不连通，所以加一个源点就行了，，，

按道理说栈实现spfa应该比队列实现的快一些，，但是这道题用栈实现t了（不止我一个人），，emmm迷一遍的操作，，队列可过，，

//hdu
//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <algorithm>
#include <queue>
#include <map>
#define aaa cout<<233<<endl;
#define endl '\n'
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;//1061109567
const ll linf = 0x3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = 3.14159265358979;
const int maxn = 1e6 + 5;
const int maxm = 2e5 + 5;
const ll mod = 1e9 + 7;
struct edge
{
    int to, next, w;
}edge[maxn];
int head[maxn], tot;
void init()
{
    tot = 0;
    memset(head, -1, sizeof head);
}
void addedge(int u, int v, int w)
{
    edge[tot].to = v; edge[tot].w = w; edge[tot].next = head[u]; head[u] = tot++;
}
bool vis[maxn];
int dis[maxn], cnt[maxn], sta[maxn];
bool spfa(int s, int n)
{
    for(int i = 0; i <= n; ++i)vis[i] = false;
    for(int i = 0; i <= n; ++i)cnt[i] = 0;
    for(int i = 0; i <= n; ++i)dis[i] = -inf;
    vis[s] = true;
    cnt[s] = 1;
    dis[s] = 0;
//    int top = -1;
//    sta[++top] = s;
    queue<int> q;
    while(!q.empty())q.pop();
    q.push(s);
    //while(~top)
    while(!q.empty())
    {
//        int u = sta[top--];
        int u = q.front(); q.pop();
        vis[u] = false;
        for(int i = head[u]; ~i; i = edge[i].next)
        {
            int v = edge[i].to;
            int w = edge[i].w;
            if(dis[v] < dis[u] + w)
            {
                dis[v] = dis[u] + w;
                if(!vis[v])
                {
                    vis[v] = true;
                    //sta[++top] = v;
                    q.push(v);
                    if(++cnt[v] > n)return false;
                }
            }
        }
    }
    return true;
}
int main()
{
//    freopen("233.in" , "r" , stdin);
//    freopen("233.out" , "w" , stdout);
//    ios_base::sync_with_stdio(0);
//    cin.tie(0);cout.tie(0);
    int n, m;
    while(~scanf("%d%d", &n, &m))
    {
        init();
        for(int i = 1; i <= m; ++i)
        {
            int u, v, w;
            char pv;
            w = 1;
            scanf(" %c %d %d", &pv, &u, &v);
            if(pv == 'P')
            {
                scanf("%d", &w);
                addedge(v, u, -w);
            }
            addedge(u, v, w);
        }
        for(int i = 1; i <= n; ++i)
            addedge(0, i, 0);
        if(spfa(0, n))
            printf("Reliable\n");
        else
            printf("Unreliable\n");
    }
    return 0;
}

codeofeces-1131d-D. Gourmet choice

做这些差分约束的题的主要的原因就是这道cf的题，，当时比赛的时候就有人说是差分约束的题，，但是因为我只是了解这块内容，，但是实际的题目完全没有写过，，所以看到题也没有什么思路，，就放弃了，，

现在再看这道题，，感觉十分的简单，，，

题意

大概的意思就是有n+m个点，，他们直接的大小关系已知（具体大或小多少没有说），，，然后问你能不能给每一个点赋一个值使得满足所给的关系，，

分析

一种解法是用并查集缩点后跑一边拓扑排序，，最后求得的最长链就是答案，，，

用差分约束解的话就是用所给的关系直接建图就行了，，对于i->j大于就正的建一条边，小于就反着建一条边，，等于就建两条就行了，，，

因为图可能是不连通的，，所以再弄个源点，连到每个点就行了，，，

因为最后要的是每一的节点一个数，，而且尽可能小，，所以就找出dis数组里距离源点最小的那个数，，然后每一个点减去这个最小的数就是最后要赋的值了，，，

对了这题用链式前向星来建图会T，，，换邻接表就好了，，，（不是说链式前向星的效率更高吗，，，emmmm，，迷，，，就像那道用栈的spfaT掉用队列就过了一样迷，，，

代码

//cf
#include <bits/stdc++.h>
//#include <iostream>
//#include <cstdio>
//#include <cstdlib>
//#include <string.h>
//#include <algorithm>
#define aaa cout<<233<<endl;
#define endl '\n'
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const int inf = 0x3f3f3f3f;//1061109567
const ll linf = 0x3f3f3f3f3f3f3f;
const double eps = 1e-6;
const double pi = 3.14159265358979;
const int maxn = 1e6 + 5;
const int maxm = 2e5 + 5;
const ll mod = 1e9 + 7;
struct edge
{
    int v, w;
    edge(int _v, int _w):v(_v), w(_w){}
};
vector<edge> e[maxn];
void addedge(int u, int v, int w)
{
    e[u].push_back(edge(v, w));
}
bool vis[maxn];
int cnt[maxn], dis[maxn], sta[maxn];
bool spfa(int s, int n)
{
    for(int i = 0; i <= n; ++i)vis[i] = false;
    for(int i = 0; i <= n; ++i)cnt[i] = 0;
    for(int i = 0; i <= n; ++i)dis[i] = inf;
    vis[s] = true;
    cnt[s] = 1;
    dis[s] = 0;
    int top = -1;
    sta[++top] = s;
    while(~top)
    {
        int u = sta[top--];
        vis[u] = false;
        for(int i = 0; i < e[u].size(); ++i)
        {
            int v = e[u][i].v;
            int w = e[u][i].w;
            if(dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                if(!vis[v])
                {
                    vis[v] = true;
                    sta[++top] = v;
                    if(++cnt[v] > n)return false;
                }
            }
        }
    }
    return true;
}
char s[1005][1005];
int main()
{
//    freopen("233.in" , "r" , stdin);
//    freopen("233.out" , "w" , stdout);
//    ios_base::sync_with_stdio(0);
//    cin.tie(0);cout.tie(0);
    int n, m; scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; ++i)scanf("%s", s[i] + 1);
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= m; ++j)
        {
            if(s[i][j] == '>')
                addedge(i, j + n, -1);
            else if(s[i][j] == '<')
                addedge(j + n, i, -1);
            else
            {
                addedge(i, j + n, 0);
                addedge(j + n, i, 0);
            }
        }
    }
    for(int i = 1; i <= n + m; ++i)
        addedge(0, i, 1);
    if(spfa(0, n + m))
    {
        printf("Yes\n");
        int k = *min_element(dis + 1, dis + 1 + n + m);
        for(int i = 1; i <= n; ++i)
            printf("%d ", dis[i] - k + 1);
        printf("\n");
        for(int i = 1 + n; i <= n + m; ++i)
            printf("%d ", dis[i] - k + 1);
        printf("\n");
    }
    else
        printf("No\n");
    return 0;
}

估计这一段时间里是不会在做差分约束的题了，，，不过正好复习一遍最短路的写法，，，

这貌似是写的最长的一篇博客了，，，30多K，，，，，233

(end)
https://www.cnblogs.com/31415926535x/p/10463112.html