差分约束学习笔记

\(\texttt{0x00}\) 概念

差分约束系统是一种特殊的 \(n\) 元一次不等式组。

差分约束系统 是一种特殊的 \(n\) 元一次不等式组，它包含 \(n\) 个变量 \(x_1\sim x_n\) 以及 \(m\) 个约束条件，每个约束条件是由两个其中的变量做差构成的，形如

\[x_i-x_j\leq c_k \]

\[(1 \leq i, j \leq n, i \neq j, 1 \leq k \leq m) \]

并且 \(c_k\) 是常数（可以是非负数，也可以是负数）。

我们要解决的问题是：求一组解

\[x_1=a_1,x_2=a_2,\dots,x_n=a_n \]

使得所有的约束条件得到满足，否则判断出无解。

\(\texttt{0x01}\) 求解过程

差分约束系统中的每个约束条件

\[x_i-x_j\leq c_k \]

都可以变形成

\[x_i\leq x_j+c_k \]

这与单源最短路中的三角形不等式

\[dist[y]\leq dist[x]+z \]

非常相似。

因此，我们可以把每个变量 \(x_i\) 看做图中的一个结点，对于每个约束条件 \(x_i-x_j\leq c_k\)，从结点 \(j\) 向结点 \(i\) 连一条长度为 \(c_k\) 的有向边。

注意到，如果 \(\{a_1,a_2,\dots,a_n\}\) 是该差分约束系统的一组解，那么对于任意的常数 \(d\)，\(\{a_1+d,a_2+d,\dots,a_n+d\}\) 显然也是该差分约束系统的一组解，因为这样做差后 \(d\) 刚好被消掉。

所以不妨先求一组负数解，即：

假设 \(\forall i,x_i \le 0\)，这就意味着新建一个 \(0\) 号节点，令 \(x_0 = 0\)，多了 \(n\) 个形如 \(x_i - x_0 \le 0\) 的约束条件，应该从 \(0\) 号节点向每个节点连一条长度为 \(0\) 的有向边。（可以看作一个超级源点）

令 \(dist[0] = 0\)，以 \(0\) 为起点跑一遍单源最短路，（因为 \(c_k\) 可能为负数，相当于图中可能会有负权边，所以选用 spfa 算法）。

显然，\(x_i = dist[i]\) 就是差分约束系统的一组解。

那么无解情况呢？

推论：此差分约束系统无解 \(\Leftrightarrow\) 图中存在负环。

证明如下：

先证充分性：

若此差分约束系统无解，则一定是出现了 \(x_i < x_i\) 这样的关系，又根据原 \(m\) 个不等关系我们可以不断放缩，即

\[x_i \le x_{j_1} + c_{k_1} \]

\[x_{j_1} \le x_{j_2} + c_{k_2} \]

\[\cdots \]

\[x_{j_{len}} \le x_i + c_{k_{len}} \]

放缩可得：

\[x_i \le x_i + c_{k_1} + c_{k_2} + \cdots + c_{c_len} \]

又 \(\because x_i < x_i\)

\(\therefore c_{k_1} + c_{k_2} + \cdots + c_{c_{len}} < 0\)

对应到图中即：存在一个点数为 \(len + 1\) 的负环。

充分性得证。

再证必要性：

若图中存在负环，说明这个负环上的变量 \(x_p\sim x_q\) 中 \(x_p < x_{p + 1} <\cdots < x_q < x_p\)，就得到了 \(x_p < x_p\)，很显然矛盾了.

所以如果存在负环，那么给定的差分约束系统无解。

必要性得证。

\(\texttt{Q.E.D}\)

\(\texttt{0x02}\) 具体例题

P5960 【模板】差分约束

题目大意：

给定一个 \(n\) 元不等式，全是 \(x_i-x_j\leq c_k\) 的形式，若有解，求出其中一组可行解，否则输出 \(\texttt{NO}\) 表示无解。

对于每个关系 \(x_i-x_j\leq c_k\)，直接在从 \(j\) 向 \(i\) 连一条长度为 \(c_k\) 的有向边。

然后建立一个超级源点，随便取一个基准值 \(\delta\) 从这个超级源点向每个点连一条长度为 \(\delta\) 的边，最后在这个超级源点跑一遍 spfa 求最短路就行了。

这里 \(\delta\) 取的是 \(0\)。

\(\texttt{Code:}\)

#include <queue>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 100010;

int n, m, C;
int h[N], e[N], w[N], ne[N], idx;
int dist[N], cnt[N];
bool vis[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 s) {
	queue<int> q;
	q.push(s);
	memset(dist, 0x3f, sizeof dist);
	dist[s] = 0;
	vis[s] = true;
	while(q.size()) {
		int t = q.front();
		q.pop();
		vis[t] = false;
		for(int i = h[t]; ~i; i = ne[i]) {
			int j = e[i];
			if(dist[j] > dist[t] + w[i]) {
				cnt[j] = cnt[t] + 1;
				if(cnt[j] >= n + 1) return false;
				dist[j] = dist[t] + w[i];
				if(!vis[j]) {
					vis[j] = true;
					q.push(j);
				}
			}
		}
	}
	return true;
}

int main() {
	memset(h, -1, sizeof h);
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; i++) add(0, i, 0); //建立超级源点并建边
	for(int i = 1, a, b, c; i <= m; i++) {
		scanf("%d%d%d", &a, &b, &c);
		add(b, a, c); //注意a,b的顺序
	}
	if(!spfa(0)) puts("NO");
	else for(int i = 1; i <= n; i++) printf("%d ", dist[i]);
	return 0;
} 

P6145 [USACO20FEB] Timeline G

题目大意：给定一个 \(n\) 元不等式，全是 \(x_i-x_j \ge c_k\) 的形式，并给定长度为 \(n\) 的序列 \(\{s\}\)，\(\forall i \in [1,n]\)，都有 \(x_i \ge S_i\) 。（满足一定有解）

求出所有 \(x_i\) 的最小值。

如果采用上一道题的建边方式。

把 \(x_i-x_j \ge c_k\) 变成 \(x_j-x_i \le -c_k\)，然后从 \(i\) 向 \(j\) 连一条长度为 \(-c_k\) 的有向边，这没问题。

但是对于 \(\forall i \in [1,n]\)，都有 \(x_i \ge S_i\) 这个条件，建立一个超级源点，令其为 \(0\) 号点，且 \(x_0 = 0\)，则上式化成：

\[x_0 - x_i \le -S_i \]

那么就应该从 \(i\) 向 \(0\) 连一条长度为 \(-S_i\) 的有向边，超级源点变成了超级汇点？所以这样做是不行的。

思来想去，考虑到这道题要求每个 \(x_i\) 的最小值，所以按道理根据这个不等式组，\(\forall i \in [1,n]\)，都应该有 \(x_i \ge a_i\)，而在求每个 \(x_i\) 时，可能有多个下界，为使它们全部满足，应该取它们中最大的那个，即：

\[\forall i \in [1,n],x_i \ge\max\limits _{1\le p\le l}\{a_p\} \]

其中 \(l\) 是下界个数。

这里就要用到一个结论，即：

求最小值则求最长路；

求最大值则求最短路。

所以这道题应该求最长路。

（所以讲了半天就是为了说明这个结论）

这样建图方式也应相应做出改变。

对于每个关系 \(x_i-x_j\ge c_k\)，从 \(j\) 向 \(i\) 建一条长度为 \(c_k\) 的有向边。

对于 \(x_i \ge S_i\)，化为 \(x_i - x_0 \ge S_i\)，所以从 \(0\) 号点向 \(i\) 建一条长度为 \(S_i\) 的有向边。

最后在 \(0\) 号点用 spfa 跑一遍最长路即可。

\(\texttt{Code:}\)

#include <queue>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 200010;

int n, m, C;
int h[N], e[N], w[N], ne[N], idx;
int dist[N];
bool vis[N];

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

void spfa(int s) {
	queue<int> q;
	q.push(s);
	memset(dist, -0x3f, sizeof dist);
	dist[s] = 0;
	vis[s] = true;
	while(q.size()) {
		int t = q.front();
		q.pop();
		vis[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];
				if(!vis[j]) {
					vis[j] = true;
					q.push(j);
				}
			}
		}
	}
}

int main() {
	memset(h, -1, sizeof h);
	scanf("%d%d%d", &n, &C, &m);
	for(int i = 1, s; i <= n; i++) {
		scanf("%d", &s);
		add(0, i, s);
	}
	for(int i = 1, a, b, c; i <= m; i++) {
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
	}
	spfa(0);
	for(int i = 1; i <= n; i++) printf("%d\n", dist[i]);
	return 0;
} 

从此我们可以总结出一个规律：

两个变量相减那边的建边是反过来的，即 \(a - b\) 则建边 \(b\to a\)

对于 \(x_i-x_j\ge c_k\) 这样的关系，思考跑最长路，执行 add(j, i, ck)，或转化成 \(x_j-x_i\le -c_k\)，执行add(i, j, -ck)。

对于 \(x_i-x_j\le c_k\) 这样的关系，思考跑最短路，执行 add(j, i, ck)，或转化成 \(x_j-x_i\ge -c_k\)，执行add(i, j, -ck)。

P1250 种树

这道题非常有意思，因为除了给出的数据需要建边，还有隐藏的建边关系。

注意这句话：

每个部分为一个单位尺寸大小并最多可种一棵树。

这其实隐藏了一个关系：\(\forall i \in (1,n],0\le x_i - x_{i - 1} \le 1\)。

同时，这里 \(x_i\) 的定义变成了前缀和，所以对于每个关系可以理解为 \(sum[b] - sum[a - 1] \ge c\)。

综上，再根据刚刚的建图方式，跑最长路。

\(\texttt{Code:}\)

#include <queue>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 30010, M = 100010;

int n, m, C;
int h[N], e[M], w[M], ne[M], idx;
int dist[N];
bool vis[N];

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

int ans;
void spfa(int s) {
	queue<int> q;
	q.push(s);
	memset(dist, -0x3f, sizeof dist);
	dist[s] = 0;
	vis[s] = true;
	while(q.size()) {
		int t = q.front();
		q.pop();
		vis[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];
				if(!vis[j]) {
					vis[j] = true;
					q.push(j);
				}
			}
		}
	}
}

int main() {
	memset(h, -1, sizeof h);
	scanf("%d%d", &n, &m);
	for(int i = 0; i <= n; i++) {
		if(i) add(i - 1, i, 0);
		if(i < n) add(i, i - 1, -1);
	}
	for(int i = 1, a, b, c; i <= m; i++) {
		scanf("%d%d%d", &a, &b, &c);
		add(a - 1, b, c);
	}
	spfa(0);
	printf("%d", dist[n]);
	return 0;
} 

P3275 [SCOI2011] 糖果

这道题就更有意思了，（看上去像数据结构似的）。

首先发现要求最小值，所以跑最长路，并将所有关系都转化成大于等于。

一共有五种关系，分类讨论：

第一种操作：\(x_a = x_b\)，根据 whk 上经常使用的方法可以转化为 \(x_a \le x_b\) 且 \(x_a \ge x_b\)，所以在 \(a,b\) 间连一条长度为 \(0\) 的无向边。

第二种操作：\(x_a < x_b\)，由于糖果数一定是整数，所以转化为 \(x_b - x_a \ge 1\)，所以从 \(a\) 向 \(b\) 连一条长度为 \(1\) 的有向边。

第三种操作：\(x_a \ge x_b\)，转化为 \(x_a - x_b\ge 0\)，所以从 \(a\) 向 \(b\) 连一条长度为 \(0\) 的有向边。

第四种操作：\(x_a > x_b\)，由于糖果数一定是整数，所以转化为 \(x_a - x_b \ge 1\)，所以从 \(b\) 向 \(a\) 连一条长度为 \(1\) 的有向边。

第五种操作：\(x_a \le x_b\)，转化为 \(x_a - x_b\le 0\)，所以从 \(a\) 向 \(b\) 连一条长度为 \(0\) 的有向边。

考虑到每个小朋友都要拿到糖，所以建立一个超级源点 \(0\)，向每个点连一条长度为 \(1\) 的边。

最后在 \(0\) 号点跑 spfa 求最长路，累加答案。

\(\texttt{Code:}\)

#include <queue>
#include <cstring>
#include <iostream>

using namespace std;

const int N = 100010, M = 200010;

int n, m;
int h[N], e[M << 1], w[M << 1], ne[M << 1], idx;
int dist[N], cnt[N];
bool vis[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 s) {
	memset(dist, -0x3f, sizeof dist);
	dist[s] = 0;
	queue<int> q;
	q.push(s);
	vis[s] = true;
	while(q.size()) {
		int t = q.front();
		q.pop();
		vis[t] = false;
		for(int i = h[t]; ~i; i = ne[i]) {
			int j = e[i];
			if(dist[j] < dist[t] + w[i]) {
				cnt[j] = cnt[t] + 1;
				if(cnt[j] >= n + 1) return false;
				dist[j] = dist[t] + w[i];
				if(!vis[j]) {
					vis[j] = true;
					q.push(j);
				}
			}
		}
	}
	return true;
}

int main() {
	memset(h, -1, sizeof h);
	scanf("%d%d", &n, &m);
	int op, a, b;
	for(int i = 1; i <= n; i++) add(0, i, 1);
	for(int i = 1; i <= m; i++) {
		scanf("%d%d%d", &op, &a, &b);
		if(op == 1) add(a, b, 0), add(b, a, 0);
		else if(op == 2) add(a, b, 1);
		else if(op == 3) add(b, a, 0);
		else if(op == 4) add(b, a, 1);
		else add(a, b, 0);
	}
	if(!spfa(0)) puts("-1");
	else {
		int ans = 0;
		for(int i = 0; i <= n; i++) ans += dist[i];
		printf("%d\n", ans);
	}
	return 0;
}