python/TangDou/AcWing/ChaFenYueShu/1169.md

AcWing 1169 分糖果

一、题目描述

幼儿园里有 N 个小朋友，老师现在想要给这些小朋友们分配糖果，要求每个小朋友都要分到糖果。

但是小朋友们也有 嫉妒心，总是会提出一些要求，比如:小明不希望小红分到的糖果比他的多，于是在分配糖果的时候， 老师需要满足小朋友们的 K 个要求。

幼儿园的糖果总是有限的，老师想知道他 至少需要准备多少个糖果，才能使得每个小朋友都能够分到糖果，并且满足小朋友们所有的要求。

输入格式 输入的第一行是两个整数 N,K。

接下来 K 行，表示分配糖果时需要满足的关系，每行 3 个数字 X,A,B。

如果 X=1．表示第 A 个小朋友分到的糖果必须和第 B 个小朋友分到的糖果一样多。 如果 X=2，表示第 A 个小朋友分到的糖果必须少于第 B 个小朋友分到的糖果。 如果 X=3，表示第 A 个小朋友分到的糖果必须不少于第 B 个小朋友分到的糖果。 如果 X=4，表示第 A 个小朋友分到的糖果必须多于第 B 个小朋友分到的糖果。 如果 X=5，表示第 A 个小朋友分到的糖果必须不多于第 B 个小朋友分到的糖果。 小朋友编号从 1 到 N。

输出格式 输出一行，表示老师 至少 需要准备的糖果数，如果不能满足小朋友们的所有要求，就输出 −1。

数据范围 1≤N<105, 1≤K≤105, 1≤X≤5, 1≤A,B≤N 输入数据完全随机。

输入样例：

5 7
1 1 2
2 3 2
4 4 1
3 4 5
5 4 5
2 3 5
4 5 1

输出样例：

11

二、题目解析

本题考查 差分约束。

如果一个系统由n个变量和m个约束条件组成，其中每个约束条件形如x_j-x_i<=b(i,j∈[1,n],k∈[1,m]),则称为 差分约束系统。亦即，差分约束系统是 求解关于一组变量的特殊不等式组的方法。简而言之，差分约束就是用来 求解一种特殊的不等式组: 这种不等式组里面不等式的格式都是类似于X_a <= X_b + c这种形式。

差分约束问题可以用求单源最短路的算法来求解，一般使用spfa算法求解。

1.差分约束问题与最短路问题的联系

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

2.不等式组解的最小值与最大值

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

再来考察求最长路的过程，将求最短路的松弛条件 倒过来 就可以求最长路了，即dist[v] < dist[u] + w[i]时，就更新dist[v]为dist[u] + w[i]，最后dist[v] = max(dist[i] + w[i])，也就是求完最长路后dist[v] >= dist[u] + w[i]。

同样的如果起点s的距离设为0，设从起点到某点t的路径上依次经过x_1，x_2，x_3三个点，对应的边权依次是w_1，w_2，w_3。则有x_1 >= s + w_1，x_2 >= x_1 + w_2，x_3 >= x_2 + w_3，可以推出x_3 >= x_2 + w_3 >= x_1 + w_2 + w_3 >= s + w_1 + w_2 + w_3，s在这里是定值，可以看出x_3的值不会小于s + w_1 + w_2 + w_3，这样就求出了x_3的 最小值 了，也就是说 最长路可以求出不等式组的最小解。

注意: ① 最短路 算法求解的是形如x_a <= x_b + c这种形式的不等式 ② 最长路 算法求解的是形如x_a >= x_b + c这种形式的不等式

3.无约束的变量与无解情况

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

再来考察无解的情况:

• 如果求最短路时存在负环，假设负环上的点有x_1，x_2，x_3，则有x_2 <= x_1 + w_1，x_3 <= x_2 + w_2，x_1 <= x_3 + w_3，可以推出x_1 <= x_3 + w_3 <= x_2 + w_2 + w_3 <= x_1 + w_1 + w_2 + w_3，又w_1 + w_2 + w_3 < 0（存在负环），所以x_1 <= x_1 + w_1 + w_2 + w_3 < x_1得出了x_1 < x_1的矛盾结论了

小结：求最短路时存在负环,说明差分约束问题无解

• 求最长路时如果存在正环，设正环上的点有x_1，x_2，x_3，则有x_2 >= x_1 + w_1，x_3 >= x_2 + w_2，x_1 >= x_3 + w_3，可以推出x_1 >= x_3 + w_3 >= x_2 + w_2 + w_3 >= x_1 + w_1 + w_2 + w_3，又w_1 + w_2 + w_3 > 0（存在正环），所以x_1 >= x_1 + w_1 + w_2 + w_3 > x_1得出了x_1 > x_1的矛盾结论了。

小结：求最长路时存在正环,说明差分约束问题无解

4.差分约束问题的建图

下面将不等式组转化为图:

建图的过程 深刻的反映 了求最短路、最长路与差分约束问题的关联。比如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这么多不等式。

5.回归本题

由于每个小朋友都需要分到糖，所以某个变量都不能小于1，所以建图时可以由x_0向各点引一条长度为1的边，因为要求x_1 >= 1等价于x_1 >= x_0 + 1,x_0 = 0。本题是求差分约束的最小解，所以需要求最长路。

spfa算法求 最长路时需要将距离数组初始化为负无穷，当存在正环时存在某个点会一直被更新，所以更新超过一定次数后就说明无解。

坑点：本题的spfa使用队列会超时，可以用数组模拟队列，或者用栈替换队列。

6.答疑解惑

在SPFA算法中，通常使用队列（queue）作为广度优先搜索的数据结构来遍历图的顶点。然而，有时候将队列替换为栈（stack）可以提升算法的性能。

原理如下：当使用队列时，SPFA算法采用的是一种宽度优先搜索（BFS）的策略，每次从队列头部取出一个顶点进行处理。这会导致算法以层级的方式逐步扩展搜索范围，从而保证了找到的路径是最短路径。

相比之下，如果将队列替换为栈，SPFA算法就会采用深度优先搜索（DFS）的策略。深度优先搜索并不关心当前处理的顶点与起始点的距离，而是一直深入到无法继续深入为止，然后回溯到上一个顶点进行处理。

使用栈而不是队列的主要好处在于，深度优先搜索会更快地遍历图的分支，而不是逐层扩展搜索范围。在某些情况下，这可能会导致更早地发现最短路径，从而提高算法的性能。

然而，需要注意的是，由于深度优先搜索不保证找到的路径是最短路径，所以在使用栈替代队列时，SPFA算法可能会得到非最短路径的结果。因此，如果对于问题的解必须是最短路径，使用队列作为搜索数据结构是更可靠的选择。

数组模拟队列版本,可以AC

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 100010, M = 300010;
int n, m;
int h[N], e[M], w[M], ne[M], idx;
int q[N], cnt[N];
LL d[N];
bool st[N];
void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
bool spfa() {
    int hh = 0, tt = -1;
    for (int i = 1; i <= n; i++) {
        q[++tt] = i;
        st[i] = true;
        d[i] = 1;
    }

    while (hh <= tt) {
        int u = q[hh++];
        st[u] = false;

        for (int i = h[u]; ~i; i = ne[i]) {
            int v = e[i];
            if (d[v] < d[u] + w[i]) {
                d[v] = d[u] + w[i];
                cnt[v] = cnt[u] + 1;
                if (cnt[v] >= n) return true;
                if (!st[v]) {
                    q[++tt] = v, st[v] = true;
                }
            }
        }
    }
    return false;
}
int main() {
    // 最小值最长路,i->j,dj>=di+c

    memset(h, -1, sizeof h);

    cin >> n >> m;

    while (m--) {
        int x, a, b;
        cin >> x >> a >> b;
        if (x == 1) add(a, b, 0), add(b, a, 0); // A=B,A>=B,B>=A
        if (x == 2) add(a, b, 1);               // A<B,B-1>=A
        if (x == 3) add(b, a, 0);               // A>=B,B->A
        if (x == 4) add(b, a, 1);               // A>B,A>=B+1,B->A
        if (x == 5) add(a, b, 0);               // A<=B,B>=A,A->B
    }

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

    return 0;
}

Queue版本，挂了最后一个点

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

int cnt[N];
LL dist[N];
bool st[N];

int h[N], e[M], w[M], ne[M], idx;
void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

bool spfa() {
    queue<int> q;
    for (int i = 1; i <= n; i++) {
        dist[i] = 1;
        st[i] = true;
        q.push(i);
    }

    while (q.size()) {
        int u = q.front();
        q.pop();

        st[u] = false;

        for (int i = h[u]; ~i; i = ne[i]) {
            int j = e[i];
            if (dist[j] < dist[u] + w[i]) {
                dist[j] = dist[u] + w[i];
                cnt[j] = cnt[u] + 1;
                if (cnt[j] >= n) return true;
                if (!st[j]) {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    return false;
}
int main() {
    memset(h, -1, sizeof h);
    cin >> n >> m;
    while (m--) {
        int x, a, b;
        cin >> x >> a >> b;
        if (x == 1) add(a, b, 0), add(b, a, 0); // A=B,A>=B,B>=A
        if (x == 2) add(a, b, 1);               // A<B,B-1>=A
        if (x == 3) add(b, a, 0);               // A>=B,B->A
        if (x == 4) add(b, a, 1);               // A>B,A>=B+1,B->A
        if (x == 5) add(a, b, 0);               // A<=B,B>=A,A->B
    }

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

用栈模拟队列 ，可以AC

#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] = 1;

    while (q.size()) {
        int u = q.top();
        q.pop();
        st[u] = 0;

        for (int i = h[u]; ~i; i = ne[i]) {
            int v = e[i];
            if (dist[v] < dist[u] + w[i]) { // 求最长路
                dist[v] = dist[u] + w[i];
                cnt[v] = cnt[u] + 1;
                // 注意多加了超级源点,共n+1个节点，边数最多是n
                if (cnt[v] > n) return 1;
                if (!st[v]) {
                    q.push(v);
                    st[v] = 1;
                }
            }
        }
    }
    return 0;
}

int main() {
    scanf("%d %d", &n, &m);
    memset(h, -1, sizeof h);
    while (m--) {
        int x, a, b; // X为大小关系描述
        scanf("%d %d %d", &x, &a, &b);

        // 求最小值，需要最长路，即形如： a>=b+1这样形式的式子

        // 表示第 a 个小朋友分到的糖果必须和第 b 个小朋友分到的糖果一样多
        //  a == b  =>  (a >= b , b >= a)  相等的关系，需要传入两条对称的边，即 a>=b,b>=a,边长为0
        if (x == 1) add(a, b, 0), add(b, a, 0);
        // 表示第 A 个小朋友分到的糖果必须少于第 B 个小朋友分到的糖果
        //  a<b => b > a => b >= a+1
        if (x == 2) add(a, b, 1);
        // 表示第 a 个小朋友分到的糖果必须不少于第 b 个小朋友分到的糖果
        // 不少于即大于等于 a >= b
        if (x == 3) add(b, a, 0);
        // 表示第 a 个小朋友分到的糖果必须多于第 b 个小朋友分到的糖果
        //  a>b => a >= b+1
        if (x == 4) add(b, a, 1);
        // 表示第 a 个小朋友分到的糖果必须不多于第 b 个小朋友分到的糖果。
        //  a<=b => b>=a
        if (x == 5) add(a, b, 0);
    }

    // 重点：需要自己从题意中挖掘出一个性质，即 每个小朋友都要至少一个糖果
    //  xi >= 1  => 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;
}