AcWing 1169 分糖果
\(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\),则称为 差分约束系统。亦即,差分约束系统是 求解关于一组变量的特殊不等式组的方法。简而言之,差分约束就是用来 求解一种特殊的不等式组:
这种不等式组里面不等式的格式都是类似于\(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\),所有与之相邻的点看作\(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 + 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\)的矛盾结论了。
小结:求最长路时存在正环,说明差分约束问题无解
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;
}