AcWing 1169 分糖果

题目传送门

本题考查差分约束。如果一个系统由\(n\)个变量和\(m\)个约束条件组成，其中每个约束条件形如
\(x_j-x_i<=b_k(i,j∈[1,n],k∈[1,m])\),则称其为差分约束系统(\(system\) \(of\) \(difference\) \(constraints\))。亦即，差分约束系统是求解关于一组变量的特殊不等式组的方法。简而言之，差分约束就是用来求解一种特殊的不等式组，这种不等式组里面不等式的格式都是类似于\(X_a <= X_b + c\)这种形式，差分约束问题 可以 用求单源最短路的算法来求解，一般使用\(spfa\)算法求解。

一、差分约束问题与最短路问题的联系

在求解最短路的算法中，核心的语句就是松弛操作，即\(d[v] > d[u] + w\)，就可以更新\(d[v]\)为\(d[u] + w\)了。在松弛某点\(v\)的距离的时候，会考察所有可以到达\(v\)的相邻点，每次从\(v\)的相邻点尝试去松弛\(v\)之后，都会有\(d[v] <= d[u] + w\)，所以最终最短路径上\(d[v] = min(d[i] + w[i])\)。如果将\(d[v]看作X_a\)，所有与之相邻的点看作\(X_b\)，则求完最短路径后的{\(X_a\),\(X_b\)}的值一定满足形如\(X_a <= X_b + c\)的不等式组的要求，也就是说，可以用\(spfa\)求最短路的过程来求解差分约束问题。

二、不等式组解的最小值与最大值

在求最短路的过程中，如果起点\(s\)的距离设为\(0\)，设从起点到某点\(t\)的路径上依次经过\(x_1，x_2，x_3\)三个点，对应的边权依次是\(c_1，c_2，c_3\)。
注：下面的\(s\),\(x_1,x_2,x_3\)均指最短距离，即\(dist[s],dist[x_1],dist[x_2],dist[x_3]\)
则有\(x_1 <= s + c_1\)，\(x_2 <= x_1 + c_2\)，\(x_3 <= x_2 + c_3\)，可以推出\(x_3 <= x_2 + c_3 <= x_1 + c_2 + c_3 <= s + c_1 + c_2 + c_3\)，\(s\)在这里是定值，可以看出\(x_3\)的值不会超过\(s + c_1 + c_2 + c_3\)，也就是可以找到\(x_3\)的最大值，其他变量\(x_1\)，\(x_2\)也均有个上限，所以求最短路得到的解实际上是不等式组的最大解。当然，在松弛过程中\(d[v] = min(d[i] + w[i])\)，也就是为了满足所有的约束条件，\(d[v]\)实际上是取所有松弛结果的最小值的。

再来考察求最长路的过程，将求最短路的松弛条件倒过来就可以求最长路了，即\(d[v] < d[u] + w\)时，就更新\(d[v]\)为\(d[u] + w\)，最后\(d[v] = max(d[i] + w[i])\)，也就是求完最长路后\(d[v] >= d[u] + w\)。同样的如果起点\(s\)的距离设为\(0\)，设从起点到某点\(t\)的路径上依次经过\(x_1，x_2，x_3\)三个点，对应的边权依次是\(c_1，c_2，c_3\)。
注：下面的\(s\),\(x_1,x_2,x_3\)均指最短距离，即\(dist[s],dist[x_1],dist[x_2],dist[x_3]\)
则有\(x_1 >= s + c_1，x_2 >= x_1 + c_2，x_3 >= x_2 + c_3\)，可以推出\(x_3 >= x_2 + c_3 >= x_1 + c_2 + c_3 >= s + c_1 + c_2 + c_3\)，\(s\)在这里是定值，可以看出\(x_3\)的值不会小于\(s + c_1 + c_2 + c_3\)，这样就求出了\(x_3\)的最小值了，也就是说求最长路可以求出不等式组的最小解。

注意:

最短路算法求解的是形如\(x_a <= x_b + c\)这种形式的不等式。

最长路算法求解的是形如\(x_a >= x_b + c\)这种形式的不等式。

三、无约束的变量与无解情况

假设图中有一点是孤立的，与其他点没有关联边，则对应差分约束问题中的变量就是不受约束的，可以取任意值。

再来考察无解的情况，如果求最短路时存在负环，假设负环上的点有\(x_1，x_2，x_3\)，则有\(x_2 <= x_1 + c_1\)，\(x_3 <= x_2 + c_2\)，\(x_1 <= x_3 + c_3\)，可以推出\(x_1 <= x_3 + c_3 <= x_2 + c_2 + c_3 <= x_1 + c_1 + c_2 + c_3\)，又\(c_1 + c_2 + c_3 < 0\)（存在负环），所以\(x_1 <= x_1 + c_1 + c_2 + c_3 < x_1\)得出了\(x_1 < x_1\)的矛盾结论了，所以\(spfa\)算法如果求出了负环则说明差分约束问题无解。

求最长路时如果存在正环，设正环上的点有\(x_1，x_2，x_3\)，则有\(x_2 >= x_1 + c_1，x_3 >= x_2 + c_2，x_1 >= x_3 + c_3\)，可以推出\(x1 >= x_3 + c_3 >= x_2 + c_2 + c_3 >= x_1 + c_1 + c_2 + c_3\)，又\(c_1 + c_2 + c_3 > 0\)（存在正环），所以\(x_1 >= x_1 + c_1 + c_2 + c_3 > x_1\)得出了\(x_1 > x_1\)的矛盾结论了。

四、差分约束问题的建图

找到了\(spfa\)算法可以求解差分约束问题，下面需要做的就是将不等式组转化为图。
建图的过程深刻的反映了求最短路最长路与差分约束问题的关联。比如\(x_1 <= x_2 + 1\)，是建一条\(x_2\)到\(x_1\)长度为\(1\)的边，还是建一条\(x_1\)到\(x_2\)长度为\(-1\)的边呢？

在最短路问题中，我们需要\(x_1 <= x_2 + c\)这种形式的不等式，遇见\(x_1 >= x_2 + 1\)形式的不等式就转化为了
\(x_2 <= x_1 - 1\)，从而建立了\(x_1\)到\(x_2\)长度为\(-1\)的边。而在最长路问题中，遇见\(x_1 >= x_2 + 1\)可以建一条\(x_2\)到\(x_1\)长度为\(1\)的边，遇见\(x_1 <= x_2 + 1\)这种形式的不等式可以转化为\(x_2 >= x_1 - 1\)，建立起了\(x_1\)到\(x_2\)长度为\(-1\)的边。从而得出了一个重要结论：
同一个不等式在最长路和最短路问题中建图的方向是相反的，建立的边权互为相反数，比如\(x_1 <= x_2 + 1\)，最短路问题是建一条\(x_2\)到x_1$长度为\(1\)的边，而在最长路问题中则是建一条\(x_1\)到\(x_2\)长度为\(-1\)的边（\(x_2 >= x_1 - 1\)）。

其他类型的不等式：对于\(x_1 < x_2 + c\)形式的不等式，可以转化为\(x_1 <= x_2 + c - 1\)形式；对于\(x_1 = x_2\)形式的不等式，可以转化为\(x_1 <= x_2\)和\(x_2 <= x_1\)两个不等式。

由于建的图不一定连通，所以为了保证从起点出发一定能到达所有点，一般会建一个超级源点，从这个超级源点向各个点引一条长度为\(0\)的边，即在不等式组中加上了\(x_0 <= x_1,x_0 <= x_2,...,x_0 <=x_n\)这么多不等式。

五、回归本题

由于每个小朋友都需要分到糖，所以某个变量都不能小于\(1\)，所以建图时可以由\(x_0\)向各点引一条长度为\(1\)的边，因为要求\(x_1 >= 1\)等价于\(x_1 >= x_0 + 1\),\(x_0 = 0\)。本题是求差分约束的最小解，所以需要求最长路。\(spfa\)算法求最长路时需要将距离数组初始化为负无穷，当存在正环时存在某个点会一直被更新，所以更新超过一定次数后就说明无解。本题的\(spfa\)使用队列会超时，所以要用栈替换队列。

六、SPFA+SLF优化版本

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 100010, M = 300010;

// SPFA+SLF优化
deque<int> q;

LL dist[N];
bool st[N];
int cnt[N];
int n, m; //表示点数和边数
//邻接表
int e[M], h[N], idx, w[M], ne[M];
void add(int a, int b, int c) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}

bool spfa() {                         //求最长路，所以判断正环
    memset(dist, -0x3f, sizeof dist); //初始化为-0x3f
    //差分约束从超级源点出发
    dist[0] = 0;
    q.push_back(0);
    st[0] = true;
    while (q.size()) {
        int t = q.front();
        q.pop_front();
        st[t] = false;
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (dist[j] < dist[t] + w[i]) { //求最长路
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                //注意多加了超级源点到各个节点的边
                if (cnt[j] >= n + 1) return false;
                if (!st[j]) {
                    if (q.size() || dist[j] < dist[q.front()])
                        q.push_front(j);
                    else
                        q.push_back(j);
                    st[j] = true;
                }
            }
        }
    }
    return true;
}

int main() {
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; ++i) {
        int op, a, b; // op为选择
        cin >> op >> a >> b;
        if (op == 1) /** a == b  =>  (a >= b , b >= a)  */
            add(a, b, 0), add(b, a, 0);
        /**  b >= a + 1         */
        else if (op == 2) {
            // SLF优化，不加特判是过不去的
            if (a == b) { //说好的A的数量小于B的数量，结果输进来的值a,b是一个点，有矛盾发生
                printf("-1");
                return 0;
            }
            add(a, b, 1);
        } else if (op == 3) /**  a >= b         */
            add(b, a, 0);

        /**  a >= b + 1        */
        else if (op == 4) {
            // SLF优化，不加特判是过不去的
            if (a == b) { //说好的A的数量大于B的数量，结果输进来的值a,b是一个点，有矛盾发生
                printf("-1");
                return 0;
            }
            add(b, a, 1);
        } else /** b >= a   */
            add(a, b, 0);
    }

    /** xi >= x0 + 1 （每个小朋友都要至少一个糖果）*/
    //将所有节点与超级源点x0相连
    for (int i = 1; i <= n; ++i) add(0, i, 1);

    if (!spfa())
        puts("-1");
    else {
        LL res = 0;
        for (int i = 1; i <= n; i++) res += dist[i];
        printf("%lld\n", res);
    }
    return 0;
}

七、Stack优化版本

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 100010, M = 300010;

stack<int> q; //有时候换成栈判断环很快就能找到答案
LL dist[N];
bool st[N];
int cnt[N];
int n, m; //表示点数和边数
//邻接表
int e[M], h[N], idx, w[M], ne[M];
void add(int a, int b, int c) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}

bool spfa() {                         //求最长路，所以判断正环
    memset(dist, -0x3f, sizeof dist); //初始化为-0x3f
    //差分约束从超级源点出发
    dist[0] = 0;
    q.push(0);
    st[0] = true;
    while (q.size()) {
        int t = q.top();
        q.pop();
        st[t] = false;
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (dist[j] < dist[t] + w[i]) { //求最长路
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                //注意多加了超级源点到各个节点的边
                if (cnt[j] >= n + 1) return false;
                if (!st[j]) {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    return true;
}

int main() {
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; ++i) {
        int op, a, b; // op为选择
        cin >> op >> a >> b;
        if (op == 1) /** a == b  =>  (a >= b , b >= a)  */
            add(a, b, 0), add(b, a, 0);
        /**  b >= a + 1         */
        else if (op == 2) {
            if (a == b) { //说好的A的数量小于B的数量，结果输进来的值a,b是一个点，有矛盾发生
                printf("-1");
                return 0;
            }
            add(a, b, 1);
        } else if (op == 3) /**  a >= b         */
            add(b, a, 0);

        /**  a >= b + 1        */
        else if (op == 4) {
            if (a == b) { //说好的A的数量大于B的数量，结果输进来的值a,b是一个点，有矛盾发生
                printf("-1");
                return 0;
            }
            add(b, a, 1);
        } else /** b >= a   */
            add(a, b, 0);
    }

    /** xi >= x0 + 1 （每个小朋友都要至少一个糖果）*/
    //将所有节点与超级源点x0相连
    for (int i = 1; i <= n; ++i) add(0, i, 1);

    if (!spfa())
        puts("-1");
    else {
        LL res = 0;
        for (int i = 1; i <= n; i++) res += dist[i];
        printf("%lld\n", res);
    }
    return 0;
}