2.差分约束学习笔记2024-07-23

3.图论的一些建图小技巧2024-07-23 4.搜索与图论（3）最小生成树 && 二分图2023-09-26 5.搜索与图论（2）最短路2023-09-26 6.搜索与图论（1)2023-09-26 7.有向图的强连通分量2024-07-23 8.无向图的双连通分量2024-07-23 9.P10935 银河解题报告2024-09-01 10.P10934 西瓜种植解题报告2024-09-01 11.P11068 解题报告2024-09-16

$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}

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

$0x01$ 求解过程

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

x_{i} - x_{j} \leq c_{k}

都可以变形成

x_{i} \leq x_{j} + c_{k}

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

d i s t [y] \leq d i s t [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} \leq 0$ ，这就意味着新建一个 $0$ 号节点，令 $x_{0} = 0$ ，多了 $n$ 个形如 $x_{i} - x_{0} \leq 0$ 的约束条件，应该从 $0$ 号节点向每个节点连一条长度为 $0$ 的有向边。（可以看作一个超级源点）

令 $d i s t [0] = 0$ ，以 $0$ 为起点跑一遍单源最短路，（因为 $c_{k}$ 可能为负数，相当于图中可能会有负权边，所以选用 spfa 算法）。

显然， $x_{i} = d i s t [i]$ 就是差分约束系统的一组解。

那么无解情况呢？

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

证明如下：

先证充分性：

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

x_{i} \leq x_{j_{1}} + c_{k_{1}}

x_{j_{1}} \leq x_{j_{2}} + c_{k_{2}}

\dots

x_{j_{l e n}} \leq x_{i} + c_{k_{l e n}}

放缩可得：

x_{i} \leq x_{i} + c_{k_{1}} + c_{k_{2}} + \dots + c_{c_{l} e n}

又 $∵ x_{i} < x_{i}$

$∴ c_{k_{1}} + c_{k_{2}} + \dots + c_{c_{l e n}} < 0$

对应到图中即：存在一个点数为 $l e n + 1$ 的负环。

充分性得证。

再证必要性：

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

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

必要性得证。

$Q.E.D$

$0x02$ 具体例题

P5960 【模板】差分约束

题目大意：

给定一个 $n$ 元不等式，全是 $x_{i} - x_{j} \leq c_{k}$ 的形式，若有解，求出其中一组可行解，否则输出 $NO$ 表示无解。

对于每个关系 $x_{i} - x_{j} \leq c_{k}$ ，直接在从 $j$ 向 $i$ 连一条长度为 $c_{k}$ 的有向边。

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

这里 $δ$ 取的是 $0$ 。

$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} \geq c_{k}$ 的形式，并给定长度为 $n$ 的序列 ${s}$ ， $\forall i \in [1, n]$ ，都有 $x_{i} \geq S_{i}$ 。（满足一定有解）

求出所有 $x_{i}$ 的最小值。

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

把 $x_{i} - x_{j} \geq c_{k}$ 变成 $x_{j} - x_{i} \leq - c_{k}$ ，然后从 $i$ 向 $j$ 连一条长度为 $- c_{k}$ 的有向边，这没问题。

但是对于 $\forall i \in [1, n]$ ，都有 $x_{i} \geq S_{i}$ 这个条件，建立一个超级源点，令其为 $0$ 号点，且 $x_{0} = 0$ ，则上式化成：

x_{0} - x_{i} \leq - S_{i}

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

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

\forall i \in [1, n], x_{i} \geq max_{1 \leq p \leq l} {a_{p}}

其中 $l$ 是下界个数。

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

求最小值则求最长路；

求最大值则求最短路。

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

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

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

对于每个关系 $x_{i} - x_{j} \geq c_{k}$ ，从 $j$ 向 $i$ 建一条长度为 $c_{k}$ 的有向边。

对于 $x_{i} \geq S_{i}$ ，化为 $x_{i} - x_{0} \geq S_{i}$ ，所以从 $0$ 号点向 $i$ 建一条长度为 $S_{i}$ 的有向边。

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

$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} \geq c_{k}$ 这样的关系，思考跑最长路，执行 add(j, i, ck)，或转化成 $x_{j} - x_{i} \leq - c_{k}$ ，执行add(i, j, -ck)。

对于 $x_{i} - x_{j} \leq c_{k}$ 这样的关系，思考跑最短路，执行 add(j, i, ck)，或转化成 $x_{j} - x_{i} \geq - c_{k}$ ，执行add(i, j, -ck)。

P1250 种树

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

注意这句话：

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

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

同时，这里 $x_{i}$ 的定义变成了前缀和，所以对于每个关系可以理解为 $s u m [b] - s u m [a - 1] \geq c$ 。

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

$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} \leq x_{b}$ 且 $x_{a} \geq x_{b}$ ，所以在 $a, b$ 间连一条长度为 $0$ 的无向边。

第二种操作： $x_{a} < x_{b}$ ，由于糖果数一定是整数，所以转化为 $x_{b} - x_{a} \geq 1$ ，所以从 $a$ 向 $b$ 连一条长度为 $1$ 的有向边。

第三种操作： $x_{a} \geq x_{b}$ ，转化为 $x_{a} - x_{b} \geq 0$ ，所以从 $a$ 向 $b$ 连一条长度为 $0$ 的有向边。

第四种操作： $x_{a} > x_{b}$ ，由于糖果数一定是整数，所以转化为 $x_{a} - x_{b} \geq 1$ ，所以从 $b$ 向 $a$ 连一条长度为 $1$ 的有向边。

第五种操作： $x_{a} \leq x_{b}$ ，转化为 $x_{a} - x_{b} \leq 0$ ，所以从 $a$ 向 $b$ 连一条长度为 $0$ 的有向边。

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

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

$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;
}

posted @ 2024-07-23 14:42 Brilliant11001 阅读(10) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· P10934 西瓜种植解题报告

· P10935 银河解题报告

· 关于差分约束的一切

· 差分约束小记

· 【差分约束系统】总结

阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）

Brilliant11001

一只会咬人的氯化氢~

差分约束学习笔记

$0x00$ 概念

$0x01$ 求解过程

证明如下：

$0x02$ 具体例题

P5960 【模板】差分约束

P6145 [USACO20FEB] Timeline G

P1250 种树

P3275 [SCOI2011] 糖果

公告

我的标签

合集

随笔分类

一只会咬人的氯化氢~

0x00 概念

0x01 求解过程

证明如下：

0x02 具体例题

公告

合集

$0x00$ 概念

$0x01$ 求解过程

$0x02$ 具体例题